elanous 0.2.9 → 0.2.11

package/src/hooks/receiver.ts

@@ -1,8 +1,10 @@
 import { debug } from '../debug/log.js';
 import { readFileSync } from 'node:fs';
-import { userConfigPath } from '../user-config.js';
+import { getUserConfig, parseEventsConfig, userConfigPath, type EventsConfig } from '../user-config.js';
+import { dispatchHook, type HookWake } from './dispatch.js';
 import { getSecretAsync } from '../nexus/config/secrets/index.js';
 import { HookQueue, type QueuedHook } from './queue.js';
+import { recordGithubShadow } from './github-shadow.js';
 import { toExternalTask, verifyWebhook, type HookProvider } from './providers.js';
 import { drainReports, handleReportPost, ReportLimiter, ReportQueue, type ReceivedReport } from './error-report.js';
 import { effectiveInstanceRoot } from '../instance/resolve.js';
@@ -10,6 +12,7 @@ import { effectiveInstanceRoot } from '../instance/resolve.js';
 export interface HookSecrets {
   linear?: string;
   asana?: string;
+  github?: string;
   saveAsana?: (secret: string) => Promise<void>;
 }
 export interface HookReceiverOptions {
@@ -20,8 +23,12 @@ export interface HookReceiverOptions {
   now?: () => number;
   root?: string;
   retryBaseMs?: number;
+  events?: EventsConfig;
+  wakeSeat?: HookWake;
   /** ER2 — forward one queued error report to the Primary; default = POST /v1/reports/ingest over the tailnet. */
   forwardReport?: (item: ReceivedReport) => Promise<boolean>;
+  /** GET-only public metadata lookup; failure forces human review. */
+  githubFetch?: typeof fetch;
 }
 
 /** `/v1/tasks` lives on the Primary's nexus API, not on the control plane — so the address is its own setting. */
@@ -33,19 +40,6 @@ export function hooksPrimaryUrl(config: { hooks?: { primaryUrl?: unknown } }): U
   return url;
 }
 
-async function forwardToPrimary(event: QueuedHook): Promise<Response> {
-  const config = JSON.parse(readFileSync(userConfigPath(), 'utf8')) as { hooks?: { primaryTokenRef?: string; primaryUrl?: unknown } };
-  const ref = config.hooks?.primaryTokenRef;
-  if (!ref) throw new Error('primary token reference missing');
-  const token = await getSecretAsync(ref);
-  if (!token) throw new Error('primary token missing');
-  return fetch(new URL('/v1/tasks', hooksPrimaryUrl(config)), {
-    method: 'POST', headers: { 'content-type': 'application/json', authorization: `Bearer ${token}`,
-      'x-elanous-trace-id': `${event.provider}:${event.eventId}` },
-    body: JSON.stringify({ ...event.task, eventId: `${event.provider}:${event.eventId}` }), signal: AbortSignal.timeout(10_000),
-  });
-}
-
 async function forwardReportToPrimary(item: ReceivedReport): Promise<boolean> {
   const config = JSON.parse(readFileSync(userConfigPath(), 'utf8')) as { hooks?: { primaryTokenRef?: string; primaryUrl?: unknown } };
   const ref = config.hooks?.primaryTokenRef;
@@ -81,7 +75,12 @@ export function startHookReceiver(options: HookReceiverOptions): { url: string;
     } finally { reportsDraining = false; }
   }
   const now = options.now ?? Date.now;
-  const forward = options.forward ?? forwardToPrimary;
+  const events = options.events ?? getUserConfig().events ?? parseEventsConfig(undefined);
+  // L14: public-repository intake events take the shadow ledger path; every other event keeps the seat dispatch path.
+  const dispatch = options.forward ?? ((event: QueuedHook) => dispatchHook(event, options.root ?? effectiveInstanceRoot(), events, options.wakeSeat).then(() => 204));
+  const forward = (event: QueuedHook) => event.provider === 'github' && event.task.github
+    ? recordGithubShadow(event, options.root ?? effectiveInstanceRoot(), options.githubFetch).then(() => 204)
+    : dispatch(event);
   const attempts = new Map<string, { next: number; failures: number }>();
   const pending = new Set<string>();
   let stopped = false;
@@ -124,7 +123,7 @@ export function startHookReceiver(options: HookReceiverOptions): { url: string;
       if (request.method === 'POST' && url.pathname === '/v1/reports')
         return handleReportPost(request, { limiter: reportLimiter, queue: reportQueue, ...(options.now ? { now: options.now } : {}),
           log: (event, data) => debug.log('hooks.reports', event, data), wake: () => { reportNextAt = 0; void drainReportQueue(); } });
-      if (request.method !== 'POST' || !/^\/hooks\/(linear|asana)$/.test(url.pathname)) return new Response('Not Found', { status: 404 });
+      if (request.method !== 'POST' || !/^\/hooks\/(linear|asana|github)$/.test(url.pathname)) return new Response('Not Found', { status: 404 });
       const provider = url.pathname.slice('/hooks/'.length) as HookProvider;
       const reject = (reason: string) => {
         debug.log('hooks.receiver', 'rejected', { provider, reason });
@@ -150,13 +149,15 @@ export function startHookReceiver(options: HookReceiverOptions): { url: string;
           debug.log('hooks.receiver', 'ignored', { provider, kind: verified.ignored });
           return new Response(null, { status: 200 });
         }
-        if (provider === 'linear') {
+        if (provider === 'linear' || provider === 'github') {
           const eventId = verified.eventIds[0]!;
-          queue.enqueue({ provider, eventId, task: toExternalTask(provider, { ...(verified.body as object), eventId }) });
+          const body = verified.body as { type?: string; action: string; githubEvent?: string };
+          const kind = provider === 'linear' ? `${body.type}:${body.action}` : `${body.githubEvent}:${body.action}`;
+          queue.enqueue({ provider, eventId, kind, task: toExternalTask(provider, { ...body, eventId }) });
         } else {
           const body = verified.body as { events: unknown[] };
-          const tasks = body.events.map(event => toExternalTask(provider, { event, task: (event as { task?: unknown }).task }));
-          for (const task of tasks) queue.enqueue({ provider, eventId: task.eventId, task });
+          const tasks = body.events.map(event => ({ event: event as { action?: string }, task: toExternalTask(provider, { event, task: (event as { task?: unknown }).task }) }));
+          for (const { event, task } of tasks) queue.enqueue({ provider, eventId: task.eventId, kind: `task:${event.action ?? 'unknown'}`, task });
         }
         if (!draining) {
           if (timer) clearTimeout(timer);

package/src/index.ts

@@ -9,6 +9,7 @@ import { LOGS_SINCE_OPTION, registerLogsCommands } from './cli/logs-cli.js';
 import { registerDocsCommands } from './cli/docs-cli.js';
 import { registerA2ACommands } from './cli/a2a-cli.js';
 import { registerPluginCommands } from './cli/plugin-cli.js';
+import { registerMakeCommand } from './cli/make-cli.js';
 import { registerConnectCommand, registerSkillsCommands } from './cli/skills-cli.js';
 import { registerImportCommand } from './cli/import-cli.js';
 import { registerPersonaCommands } from './cli/persona-cli.js';
@@ -96,6 +97,7 @@ applyTestFlagFromArgv();
 applyConfigDirFlagFromArgv();
 
 import { Command, Option } from 'commander';
+import { filterCliRootHelp } from './maturity/cli-maturity.js';
 import type { AdPipelinePlan, AdPipelineResult } from './ad-pipeline/run.js';
 import type { AcpPermissionApprover } from './acp/client.js';
 import { runGitCommand } from './git-fs/runner.js';
@@ -122,7 +124,7 @@ import { DEFAULT_REVIEW_BACKEND } from './agent-substrate/acp-reviewer.js';
 import type { ReviewResult } from './agent-substrate/pr-reviewer.js';
 import type { ReviewVerdict } from './agent-mission/review-loop.js';
 import type { SyncMode } from './types.js';
-import { runOnboarding, runOnboardingStep, runOnboardingNonInteractive, needsOnboarding, handleOnboardingRefusal, type OnboardingStepId } from './onboarding.js';
+import { runOnboarding, runOnboardingStep, runOnboardingNonInteractive, needsOnboarding, needsFirstRun, handleOnboardingRefusal, type OnboardingStepId } from './onboarding.js';
 import {
   getUserConfig, reloadUserConfig, userConfigPath, saveUserConfig,
   backupUserConfig, backupConfigPath, addRotationEntry, type RotationEntry,
@@ -137,6 +139,7 @@ import {
 } from './session/index.js';
 import { requestSessionTurnControl } from './session/session-turn-control.js';
 import { ensureCliSession, sessionBudget } from './session/chat.js';
+import { suggestProjectForFolder } from './project/project-store.js';
 import { botFromConfig, TelegramBot } from './telegram.js';
 import { acquireTelegramLock, TelegramLockError, defaultLockPath, safeReadLock } from './telegram-lock.js';
 import { basename, join as _joinPath, resolve } from 'node:path';
@@ -865,6 +868,31 @@ registerUsageCommand(program);
 registerLiveCommands(program);
 registerResearchCommand(program);
 registerReleaseCommands(program);
+const seatCmd = program.command('seat').description('분배된 자리의 하루 루프와 보고');
+seatCmd.command('loop').requiredOption('--seat <SEAT>', 'MK|OP|TC|UX')
+  .requiredOption('--once', '한 번 실행')
+  .option('--json', 'JSON 출력')
+  .action(async (opts: { seat: string; once: boolean; json?: boolean }) => {
+    try {
+      // V3 F5: without the sink, the seat loop's judgment lines (seat.loop) never reach the log store when cron runs it.
+      await (await import('./domains/standalone-log-sink.js')).registerStandaloneLogSink('seat-loop');
+      const { runSeatLoopTurn } = await import('./seat-loop/seat-loop.js');
+      const result = await runSeatLoopTurn(opts.seat);
+      if (opts.json) await writeStdoutJson(`${JSON.stringify(result)}\n`);
+      else console.log(`seat loop ${opts.seat}: ${result.status}${'runId' in result && result.runId ? ` ${result.runId}` : ''}`);
+    } catch (error) { console.error(`seat loop: ${error instanceof Error ? error.message : String(error)}`); process.exitCode = 1; }
+  });
+seatCmd.command('report').requiredOption('--seat <SEAT>', 'MK|OP|TC|UX')
+  .option('--post', '설정된 채널에 게시')
+  .option('--json', 'JSON 출력')
+  .action(async (opts: { seat: string; post?: boolean; json?: boolean }) => {
+    try {
+      const { seatReport } = await import('./seat-loop/seat-report.js');
+      const result = await seatReport(opts.seat, { post: opts.post });
+      if (opts.json) await writeStdoutJson(`${JSON.stringify(result)}\n`);
+      else console.log(result.body);
+    } catch (error) { console.error(`seat report: ${error instanceof Error ? error.message : String(error)}`); process.exitCode = 1; }
+  });
 registerModelWatchCommand(program);
 registerDoctorCommand(program);
 // runCli() → main() → program.parseAsync() dispatches control serve and resources where|list.
@@ -888,6 +916,7 @@ registerCardCommand(program);
 registerLaunchHeadCommands(program);
 registerA2ACommands(program);
 registerPluginCommands(program);
+registerMakeCommand(program);
 registerSkillsCommands(program);
 registerConnectCommand(program);
 registerImportCommand(program);
@@ -986,6 +1015,18 @@ linearCmd.command('set-key').description('Read Linear API key from stdin and sto
     catch { console.error('connector.linear.apiKey: could not save key'); process.exitCode = 1; }
   });
 
+const storyboardCmd = program.command('storyboard').description('스토리보드 정본 검사 · MD 생성');
+storyboardCmd.command('lint').description('스토리보드 검사').argument('[files...]').option('--json', 'JSON 출력')
+  .action(async (paths: string[], opts: { json?: boolean }) => {
+    const { runStoryboard } = await import('./cli/storyboard-cli.js');
+    process.exitCode = runStoryboard('lint', paths, opts.json);
+  });
+storyboardCmd.command('render').description('스토리보드 검사 후 MD 생성').argument('[files...]')
+  .action(async (paths: string[]) => {
+    const { runStoryboard } = await import('./cli/storyboard-cli.js');
+    process.exitCode = runStoryboard('render', paths);
+  });
+
 const pythonCmd = program.command('python').description('elanous 가 쓰는 파이썬(해석 · 점검 · elanous venv 셋업) — RFC-doctor-fix-build-toolchain-and-python-by-distro');
 pythonCmd.command('where').description('어느 파이썬을 쓰나(ELANOUS_PYTHON > elanous venv > pyenv .python-version > PATH)').option('--json').option('--path', '경로만 한 줄(스크립트·스킬용)').action(async (o: { json?: boolean; path?: boolean }) => {
   const { runPythonWhere } = await import('./cli/python-cli.js'); process.exitCode = runPythonWhere(console, o.json, o.path);
@@ -1050,7 +1091,8 @@ program
   .option(
     '--test',
     '격리 테스트 인스턴스로 실행 — cwd 의 git 트리(worktree 포함)에서 `<트리>/.elanous-test` 를 루트로 잡고 state·config 두 축을 함께 격리한다. config 사본이 없으면 자동 물질화. `--test=<dir>` 로 루트 직접 지정 가능(값 문법은 `=` 형태 하나 — 모호함 없음). ELANOUS_STATE_DIR/--config-dir 을 손으로 줄 필요가 없다.',
-  );
+  )
+  .option('--help-all', '시스템 명령을 제외한 모든 최상위 명령 표시');
 program.addHelpText('after', acpServerHelpText());
 
 program
@@ -2120,13 +2162,13 @@ harnessCmd
   .option('--json', 'JSON 출력')
   .option('--dry-run', '프로세스 후보만 보고 신호·Pod Job 삭제는 하지 않는다')
   .action(async (runId: string, opts: { context?: string[]; json?: boolean; dryRun?: boolean }) => {
-    const { stopHarnessRun, defaultHarnessStopDeps, formatHarnessStop } = await import('./harness/harness-stop.js');
+    const { stopHarnessRun, defaultHarnessStopDeps, formatHarnessStop, AmbiguousHarnessStopRunIdError } = await import('./harness/harness-stop.js');
     try {
       const result = await stopHarnessRun(runId, defaultHarnessStopDeps(), opts.context, opts.dryRun === true);
       process.stdout.write(`${opts.json ? JSON.stringify(result) : formatHarnessStop(result)}\n`);
     } catch (error) {
       process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
-      process.exitCode = 2;
+      process.exitCode = error instanceof AmbiguousHarnessStopRunIdError ? 1 : 2;
     }
   });
 harnessCmd
@@ -2556,11 +2598,18 @@ harnessCmd
       const { verifyDeployedPage, formatVerifyUrlReport } = await import('./harness/browser-verify.js');
       const { writeFileSync } = await import('node:fs');
       let shotWritten = false;
+      let shotWriteError: string | undefined;
       const r = await verifyDeployedPage(url, {
         backend: opts.backend,
         ...(opts.port ? { port: Number(opts.port) } : {}),
         // ⛔ 「썼다」를 «셋»으로 — 안 시켰다 / 썼다 / 못 썼다. 뭉치면 없는 파일을 있다고 말한다.
-        ...(opts.shot ? { onScreenshot: (b: Buffer) => { writeFileSync(opts.shot!, b); shotWritten = true; } } : {}),
+        ...(opts.shot ? { onScreenshot: (b: Buffer) => {
+          try { writeFileSync(opts.shot!, b); shotWritten = true; }
+          catch (error) {
+            shotWriteError = error instanceof Error ? error.message : String(error);
+            if (opts.backend === 'aside') throw error;
+          }
+        } } : {}),
       });
       if (r.skipped === 'no-cdp') {
         console.log(`⚠️ CDP 엔드포인트 없음(9222) — 검증 skip. browser-debug 스킬로 브라우저를 9222 에 먼저 띄우세요.`);
@@ -2571,8 +2620,11 @@ harnessCmd
         return;
       }
       const L = formatVerifyUrlReport(url, r, opts.shot === undefined ? undefined : { path: opts.shot, written: shotWritten });
+      if (opts.shot && !shotWritten && !r.skipped) {
+        L.push(`  - 스크린샷을 ${opts.shot} 에 못 썼다 — ${shotWriteError ?? (r.unmeasured?.includes('screenshot') ? '스크린샷을 못 쟀다' : '스크린샷 데이터가 오지 않았다')}`);
+      }
       console.log(L.join('\n'));
-      if (!r.ok) process.exitCode = 1;
+      if (!r.ok || (opts.shot && !shotWritten && !r.skipped)) process.exitCode = 1;
     } catch (e: any) {
       ui.error(`harness verify-url 실패: ${String(e?.message ?? e).slice(0, 200)}`);
       process.exitCode = 1;
@@ -2976,6 +3028,46 @@ const harnessOrchestrateCmd = registerHarnessOrchestrateCapabilityOptions(
     await runHarnessOrchestrateExecution(plan, parts);
   });
 
+const contextCmd = program.command('context').description('외부 에이전트 맥락 이벤트');
+contextCmd.command('hooks').description('Claude Code 맥락 훅 설정').command('install')
+  .requiredOption('--print', '설정 조각만 출력하고 설정 파일은 수정하지 않음')
+  .action(async () => {
+    const { claudeHooksSettings } = await import('./context-bus/claude-hooks-install.js');
+    console.log(claudeHooksSettings(REPOSITORY_ROOT));
+  });
+contextCmd.command('emit')
+  .requiredOption('--kind <kind>', 'claimed|done|asked|guide-changed')
+  .requiredOption('--summary <line>', '한 줄 요약')
+  .requiredOption('--source <link>', '출처 링크')
+  .action(async (opts: { kind: string; summary: string; source: string }) => {
+    if (!['claimed', 'done', 'asked', 'guide-changed'].includes(opts.kind)) throw new Error('context emit --kind must be claimed|done|asked|guide-changed');
+    const { recordExternalEvent } = await import('./context-bus/external-events.js');
+    recordExternalEvent({ origin: 'claude-code', kind: opts.kind as import('./context-bus/external-events.js').ContextHookKind,
+      summary: opts.summary, source: opts.source });
+  });
+
+const coordCmd = program.command('coord').description('조율 채널 맥락 원장');
+coordCmd.command('event').command('record')
+  .requiredOption('--seat <ID>', '발신 자리')
+  .requiredOption('--header <line>', '채널 글 첫 줄')
+  .option('--url <url>', '채널 코멘트 URL')
+  .action(async (opts: { seat: string; header: string; url?: string }) => {
+    const { parseCoordHeader, recordCoordEvent } = await import('./context-bus/coord-events.js');
+    recordCoordEvent({ ...parseCoordHeader(opts.seat, opts.header), url: opts.url || null });
+  });
+coordCmd.command('events')
+  .option('--since <ISO|2h>', '조회 시작', '2h')
+  .option('--seat <ID>', '발신 자리')
+  .option('--json', 'JSON 출력')
+  .action(async (opts: { since: string; seat?: string; json?: boolean }) => {
+    const { listCoordEvents } = await import('./context-bus/coord-events.js');
+    const relative = /^(\d+)h$/.exec(opts.since);
+    const since = relative ? new Date(Date.now() - Number(relative[1]) * 3_600_000).toISOString() : new Date(opts.since).toISOString();
+    const rows = listCoordEvents({ since, ...(opts.seat ? { seat: opts.seat } : {}) });
+    if (opts.json) await writeStdoutJson(JSON.stringify(rows) + '\n');
+    else for (const row of rows) console.log(`${row.at} [${row.refs.seat}] ${row.text}`);
+  });
+
 const selfCmd = program.command('self').description('Self-awareness memory — 외부 도구(Claude Code/Codex)가 구현/변경 이력을 elanous 기억에 주입·회상');
 
 // M12 Claude Code 의존도 계기판 — `elanous self dependence [--since] [--until] [--json]`(읽기만).
@@ -3905,11 +3997,12 @@ selfCmd
   .option('--changed', '변경 파일 범위 게이트임을 명시한다')
   .option('--base <ref>', '커밋됐지만 PR 없는 변경의 비교 기준(ref...HEAD)')
   .option('--pr <number>', '열린 PR 번호에서 gh pr view files로 변경 파일을 읽는다')
-  .action((opts: { changed?: boolean; base?: string; pr?: string }) => {
-    if (!opts.changed) { ui.error('self gate requires --changed'); process.exitCode = 2; return; }
+  .option('--shards [number]', '메모리 예산에 맞춰 시험을 별도 프로세스로 분할한다 (기본 2)')
+  .action((opts: { changed?: boolean; base?: string; pr?: string; shards?: string | boolean }) => {
+    if (!opts.changed && opts.shards === undefined) { ui.error('self gate requires --changed or --shards'); process.exitCode = 2; return; }
     try {
       const { runSelfGateCli } = require('./self-implement/gate-cli.js') as typeof import('./self-implement/gate-cli.js');
-      const result = runSelfGateCli(process.cwd(), { base: opts.base, pr: opts.pr });
+      const result = runSelfGateCli(process.cwd(), { base: opts.base, pr: opts.pr, shards: opts.shards === undefined ? undefined : opts.shards === true ? 2 : Number(opts.shards) });
       console.log(result.lines.join('\n'));
       process.exitCode = result.exitCode;
     } catch (error) {
@@ -3941,7 +4034,8 @@ selfCmd
 // runSelfImplement(내부 SelfImplement 툴과 동일 코어)를 감싼다: fork→worktree→헤드리스 goal-loop
 // (+클린빌드 앵커)→gate(bun test)→PR(HITL). PR-open 은 --open-pr(명시 승인)일 때만·기본 fail-closed.
 selfCmd
-  .command('implement <feature...>')
+  .command('implement [feature...]')
+  .option('--feature-file <path>', 'feature 문면을 파일에서 읽는다 (문면을 argv 에 싣지 않음)')
   .description('자율 구현(self-build) — feature 를 격리 worktree 에서 goal-loop + 클린빌드 앵커로 끝까지 구현하고 gate(bun test) 통과까지. --config-dir 의 provider 로 모델 선택(gemma 등). PR-open 은 --open-pr(HITL 명시승인)일 때만. 수분 소요.')
   .option('--base <branch>', 'PR base 브랜치(생략 시 provider 기본)')
   .option('--no-draft', 'non-draft PR (기본 draft)')
@@ -3959,8 +4053,11 @@ selfCmd
   .option('--no-supervise', '⛔ 런 슈퍼바이저를 «끈다»(대표 2026-08-22: ***기본 ON***) — 켜져 있으면 실행이 끝나면 실패를 «트리아지»해서 다시 걸 수 있으면 스스로 재개한다(끝까지). 정지 사유는 converged|needs-human|max-rounds|no-progress 로 각각 «다른 값». 관측=elanous logs --category self-dev.supervisor')
   .option('--supervise-rounds <n>', '슈퍼바이저 재개 라운드 상한 (기본 3 · 끄려면 --no-supervise)')
   .option('--json', '구조화 출력 {stage, ok, branch, worktree, prUrl?, merged?}')
-  .action(async (parts: string[], opts: { base?: string; draft?: boolean; openPr?: boolean; autoMerge?: boolean; autoReview?: boolean; maxWait?: string; json?: boolean; plan?: boolean; enhance?: boolean; ground?: boolean; observeOnly?: boolean }) => {
-    const feature = parts.join(' ').trim();
+  .action(async (parts: string[], opts: { featureFile?: string; base?: string; draft?: boolean; openPr?: boolean; autoMerge?: boolean; autoReview?: boolean; maxWait?: string; json?: boolean; plan?: boolean; enhance?: boolean; ground?: boolean; observeOnly?: boolean }) => {
+    if (opts.featureFile && parts.length > 0) { ui.error('--feature-file 과 위치 인자 feature 는 함께 줄 수 없다'); process.exit(2); }
+    let feature: string;
+    try { feature = (opts.featureFile ? readFileSync(opts.featureFile, 'utf8') : parts.join(' ')).trim(); }
+    catch (error) { ui.error(`--feature-file 읽기 실패: ${String(error)}`); process.exit(2); return; }
     if (!feature) { ui.error('feature 필요: elanous self implement "<무엇을 구현할지>"'); process.exit(2); }
     // Retired entry points must fail before run identity or log-sink setup creates observable execution state.
     if (opts.plan) { ui.error('self implement --plan is retired and rejected'); process.exit(1); return; }
@@ -4058,8 +4155,14 @@ export function setSelfOrchestrateSpawnForTesting(spawn: typeof selfOrchestrateS
   selfOrchestrateSpawnForTesting = spawn;
 }
 
+export function readSelfOrchestrateGoals(parts: string[], goalFiles: readonly string[] = []): { request: string; goals: string[] } {
+  const fileGoals = goalFiles.map((path) => readFileSync(path, 'utf8'));
+  return { request: [...parts, ...fileGoals].join(' '), goals: [...splitOrchestrateGoalTexts(parts), ...fileGoals] };
+}
+
 const selfOrchestrateCmd = selfCmd
   .command('orchestrate [goals...]')
+  .option('--goal-file <path>', '골 문면을 파일에서 읽는다 (반복 가능)', (value: string, acc: string[]) => [...acc, value], [] as string[])
   .description('병렬 self-dev — 여러 goal 을 각자 격리 worktree self-implement 서브프로세스로 동시성캡 병렬 실행. goal 은 `;;` 로 구분(또는 각 인자 1 goal). --concurrency 로 동시 잡 수(기본 2).')
   .option('--concurrency <n>', '동시 실행 잡 수 (기본 2)')
   .option('--auto-merge', '각 잡: 리뷰 clean 시 자동 병합(각 self-implement 에 --auto-merge 전달·리뷰노드 경유)')
@@ -4068,7 +4171,7 @@ const selfOrchestrateCmd = selfCmd
   .option('--base <branch>', '각 잡 PR base 브랜치')
   .option('--decompose', 'S2 — goal 1개를 LLM 으로 의존성 서브-DAG(위상 병렬 + hot-file 직렬)로 분해 후 실행')
   .addOption(new Option('--pod-skill-env', 'pod: 필수 스킬(설정 pod-skills.txt)의 키(.env)를 이 런의 Secret 으로 넘긴다 — 명시 opt-in(유료 크레딧) · 이미지엔 안 들어간다').hideHelp())
-  .addOption(new Option('--pod-pool <spec>', 'pod 풀 — 컨텍스트[@ssh호스트][:상한] 을 쉼표로, 앞이 우선(예 pool-node-b@node-b:12,pool-node-c@node-c:3) · 없으면 ELANOUS_POD_POOL · 그것도 없으면 현재 컨텍스트 하나').hideHelp())
+  .addOption(new Option('--pod-pool <spec>', 'pod 풀 — 컨텍스트[@ssh호스트][:상한][#k3d-레지스트리:포트] 쉼표, 앞이 우선(예 pool-node-b@node-b:12#k3d-elanous-registry:5051,pool-node-c@node-c:3#k3d-elanous-registry:5052) · 없으면 ELANOUS_POD_POOL · 그것도 없으면 현재 컨텍스트 하나').hideHelp())
   .addOption(new Option('--reduce', '끝에 PR 을 연 조각들을 통합 브랜치 하나로 모아(게이트 한 번) PR 하나 — `--open-pr` 과 짝 · `--auto-merge` 와는 함께 못 쓴다(elanous self reduce)').hideHelp())
   .option('--substrate <kind>', '실행 칸: local(기본 · 격리 워크트리) | pod(k8s Job · docker/harness 이미지 · MANUAL-pods-for-elanous-ops-and-dev)')
   .option('--pod-account <name>', 'pod: codex 계정(~/.elanous/auth.json openai-codex:<name> · refresh 제외 사본) · 없으면 브로커가 Job 마다 잔량 많은 계정을 돌려 준다')
@@ -4076,11 +4179,14 @@ const selfOrchestrateCmd = selfCmd
   .option('--pod-pass-env <keys>', 'pod: 호스트 env 에서 Pod 로 넘길 키(쉼표) — 예 OPENROUTER_API_KEY,ANTHROPIC_API_KEY(벤치마크 과금 경로)')
   .option('--bench-arms <spec>', 'pod 벤치마크: 골 1개를 팔마다 «라벨 한 줄만 다르게» 복제해 동시에 — "id=provider[:model][@KEY+KEY];…" (예 codex=openai-codex;or-kimi=openrouter:openrouter/moonshotai/kimi-k3@OPENROUTER_API_KEY) · --auto-merge 거부 · RFC fleet 슈퍼바이저 §A3')
   .option('--help-all', '모든 orchestrate 옵션 표시')
-  .action(function (this: Command, parts: string[], opts: { concurrency?: string; autoMerge?: boolean; autoReview?: boolean; openPr?: boolean; base?: string; teardown?: boolean; resume?: string; board?: boolean; decompose?: boolean; fabricDecompose?: boolean; maxTasks?: string; supervise?: boolean; superviseRounds?: string; json?: boolean }) {
+  .action(function (this: Command, parts: string[], opts: { goalFile?: string[]; concurrency?: string; autoMerge?: boolean; autoReview?: boolean; openPr?: boolean; base?: string; teardown?: boolean; resume?: string; board?: boolean; decompose?: boolean; fabricDecompose?: boolean; maxTasks?: string; supervise?: boolean; superviseRounds?: string; json?: boolean }) {
     return (async () => {
-    // goal 분리: 단일 인자에 `;;` 가 있으면 그걸로 split, 아니면 각 positional = 1 goal.
-    const joined = parts.join(' ');
-    let goalTexts = splitOrchestrateGoalTexts(parts);
+    // 위치 인자는 종전처럼 분리하고 파일 입력은 파일당 한 골이다.
+    let inputGoals: ReturnType<typeof readSelfOrchestrateGoals>;
+    try { inputGoals = readSelfOrchestrateGoals(parts, opts.goalFile); }
+    catch (error) { ui.error(`--goal-file 읽기 실패: ${String(error)}`); process.exit(2); return; }
+    const joined = inputGoals.request;
+    let goalTexts = inputGoals.goals;
     if ((opts as { reduce?: boolean }).reduce && opts.autoMerge) { ui.error('--reduce 는 --auto-merge 와 함께 못 쓴다 — 조각을 하나씩 main 에 병합하는 것과 하나로 모으는 것은 반대다(--open-pr 과 짝)'); process.exit(2); }
     // ☸️ 벤치 팔 — 골 1개를 팔마다 라벨 한 줄만 다르게(A/B 매뉴얼 ②) · pod 전용 · 자동 머지 금지(한 팔이 머지되면 다른 팔의 밑 땅이 바뀐다).
     const benchSpec = (opts as { benchArms?: string }).benchArms;
@@ -6228,7 +6334,7 @@ const selfDevCmd = program
   //   `drive --help` 에도 그대로 보이고 자식이 그것을 계약으로 읽는다.
   //   ⇒ 별칭을 없애지 않는다([[RFC-two-command-convergence-dev-and-pty-2026-07-28]] §6-2 = 층이 다르니
   //     `drive` 는 프리미티브로 **유지**한다) — 대신 **도움말이 그 갈림을 먼저 말하게** 한다.
-  .description('⛔ `drive` 별칭으로 부르면 옵션은 여덟뿐 (--goal · --attach · --max-steps · --poll-ms · --model · --cwd · --worktree · --json) — `--attach <ref>` 는 이미 있는 PTY 를 몬다(생략하면 셸 명령을 새로 띄운다). 나머지는 전부 `dev` 전용이고 `drive` 에서는 거부된다. dev 와 drive 는 한 명령이라 이 도움말을 공유하므로, 아래 목록은 `dev` 기준이다. ⚠️ 실험 — 통합 self-dev 파이프라인 runDevPipeline. --backend self(디폴트·elanous-chat 자체구현)|codex/claude/gemini/grok(외부). --transport pty(디폴트·worktree·--branch 필수)|acp(cwd 세션·U6·capability 미검증). 미배선 조합은 NotYetUnified 명시 거부. ★self 는 무인 완결이 기본(PR 개설→auto-review 라벨→리뷰 clean 시 병합) — 끄려면 --no-open-pr/--no-auto-review/--no-auto-merge. 관측=elanous logs --category dev-pipeline · 상세=docs/manual/MANUAL-frontdoor-selfdev-dogfood-mechanism-2026-07-25.md')
+  .description('⛔ `drive` 별칭으로 부르면 옵션은 아홉뿐 (--goal · --attach · --max-steps · --poll-ms · --model · --cwd · --worktree · --json · --jail-home) — `--attach <ref>` 는 이미 있는 PTY 를 몬다(생략하면 셸 명령을 새로 띄운다). 나머지는 전부 `dev` 전용이고 `drive` 에서는 거부된다. dev 와 drive 는 한 명령이라 이 도움말을 공유하므로, 아래 목록은 `dev` 기준이다. ⚠️ 실험 — 통합 self-dev 파이프라인 runDevPipeline. --backend self(디폴트·elanous-chat 자체구현)|codex/claude/gemini/grok(외부). --transport pty(디폴트·worktree·--branch 필수)|acp(cwd 세션·U6·capability 미검증). 미배선 조합은 NotYetUnified 명시 거부. ★self 는 무인 완결이 기본(PR 개설→auto-review 라벨→리뷰 clean 시 병합) — 끄려면 --no-open-pr/--no-auto-review/--no-auto-merge. 관측=elanous logs --category dev-pipeline · 상세=docs/manual/MANUAL-frontdoor-selfdev-dogfood-mechanism-2026-07-25.md')
   .option('--file <path>', 'input 파일(verbatim 바이트·<text...> 대신)')
   // ⭐ 대표 2026-08-11 — 발사 절차 «넷»을 한 명령으로. ask 파일을 주면 ⑴저작 → ⑵열린 PR ⊕ ⑶도는 런 검사 → ⑷발사.
   //   ⛔ 걸리면 «이름을 대며» 멈춘다(조용히 진행하지 않는다). 우회는 --force-preflight 이고 그 사실이 관측에 남는다.
@@ -6254,6 +6360,7 @@ const selfDevCmd = program
   .option('-n, --max-steps <n>', 'elanous 또는 셸 drive: 최대 제어 스텝(기본 30)')
   .option('-p, --poll-ms <ms>', 'elanous 또는 셸 drive: 제어 스텝 간 폴 간격(ms·0 허용·기본 800)')
   .option('--attach <ref>', 'drive: 이미 있는 PTY 를 몬다(생략하면 셸 명령을 새로 띄운다·pty auto 와 같은 루프)')
+  .option('--jail-home <dir>', 'drive: DRIVE-JAIL — 두뇌 입력에 이 디렉터리 밖 경로가 있으면 PTY 로 보내지 않는다')
   .option('-m, --model <id>', 'elanous 또는 셸 drive: 제어 brain LLM 모델(기본 config)')
   .option('--observe-only', 'elanous: child boot부터 SelfImplement 호출을 기록만 한다')
   .option('--isolated-root <path>', 'elanous: child config/state 격리 루트(설정 실패 시 fail-closed)')
@@ -6498,8 +6605,21 @@ const selfDevCmd = program
       if (devAskSubstrate?.substrate === 'pod') {
         const { dispatchHarnessOnPod } = await import('./harness/harness-pod-dispatch.js');
         const { devAskPodDispatchInput } = await import('./harness/harness-substrate-default.js');
-        const status = await dispatchHarnessOnPod(devAskPodDispatchInput(opts, askAuthoredFile!, devAskSubstrate.pool!));
-        if (status !== 0) console.error('Pod 실행에 닿지 못했다 — 풀·컨텍스트·SSH 연결을 확인하거나 `--substrate local` 로 명시하라');
+        const { classifyHarnessPodExit, harnessPodRunId, recordClassifiedHarnessPodExit, warnRecentIncidentBurst } = await import('./harness/harness-cli-command.js');
+        warnRecentIncidentBurst();
+        let podOutput = '';
+        let podRunId: string | undefined;
+        const status = await dispatchHarnessOnPod(devAskPodDispatchInput(opts, askAuthoredFile!, devAskSubstrate.pool!), {
+          onOutput: (text) => {
+            podRunId ??= harnessPodRunId(podOutput + text);
+            podOutput = (podOutput + text).slice(-16_000);
+          },
+        });
+        if (status !== 0) {
+          const classified = classifyHarnessPodExit({ status }, podOutput, { ...(podRunId ? { runId: podRunId } : {}) });
+          recordClassifiedHarnessPodExit(podRunId ?? harnessPodRunId(podOutput), classified.reason, status);
+          for (const line of classified.lines) console.error(line);
+        }
         completionGuard.conclude();
         process.exit(status);
       }
@@ -6537,6 +6657,7 @@ const selfDevCmd = program
           ...(devOpts.worktree === true ? { worktree: true } : {}),
           ...(opts.json === true ? { json: true } : {}),
           attach: devOpts.attach,
+          ...(devOpts.jailHome ? { jailHome: devOpts.jailHome } : {}),
         }, {
           exit: ((code: number): never => {
             completionGuard.conclude();
@@ -7499,6 +7620,10 @@ sessionCmd
     const s = ensureCliSession(cfg);
     setActiveSessionId(s.id);
     ui.info(`Created session ${s.id.slice(0, 8)} (marked active).`);
+    try {
+      const project = suggestProjectForFolder(process.cwd());
+      if (project) ui.info(`Project suggestion: ${project.name} (${project.id})`);
+    } catch { /* suggestions must not interrupt session creation */ }
   });
 
 sessionCmd
@@ -7929,7 +8054,7 @@ sessionCmd
   });
 
 async function runFirstSetupForCli(cfg: ReturnType<typeof getUserConfig>, announceFallback = false): Promise<boolean> {
-  if (cfg.onboarding.webFirst === true) {
+  if (cfg.onboarding.webFirst !== false) {
     const { runWebFirstSetup } = await import('./onboarding/web-first.js');
     if (await runWebFirstSetup({ config: cfg }) === 'link-shown') return false;
     if (announceFallback) ui.info('No config yet — launching setup wizard first.');
@@ -7972,7 +8097,7 @@ program
     if (opts.tools) announceChatToolsCompatibility();
     const cfg = getUserConfig();
     if (needsOnboarding(cfg)) {
-      if (cfg.onboarding.webFirst !== true) ui.info('No config yet — launching setup wizard first.');
+      if (cfg.onboarding.webFirst === false) ui.info('No config yet — launching setup wizard first.');
       if (!await runFirstSetupForCli(cfg, true)) return;
     }
     const refreshed = reloadUserConfig();
@@ -8039,7 +8164,7 @@ program
     }
     const cfg = getUserConfig();
     if (needsOnboarding(cfg)) {
-      if (cfg.onboarding.webFirst !== true) ui.info('No config yet — launching setup wizard first.');
+      if (cfg.onboarding.webFirst === false) ui.info('No config yet — launching setup wizard first.');
       if (!await runFirstSetupForCli(cfg, true)) return;
     }
     const refreshed = reloadUserConfig();
@@ -9281,24 +9406,50 @@ const nexusRunCmd = nexusCmd
         process.once('exit', () => releaseTestPort(resolvedPort, process.pid));
       }
       const { runNexus } = await import('./nexus/index.js');
-      await runNexus({
-        headless: true,
-        tools: toolsKind ?? 'webterm',
-        autoMountShare: !bgChild,
-        // bg-launch child reads `--watch` from forwardArgs (set by
-        // runPwaStart). External !TTY launches (launchd / Docker /
-        // nohup) get watch only when the user explicitly didn't disable
-        // it — service-manager production posture stays watch-off.
-        ...((bgChild ? opts.watch === true : watchOn) ? { pwaWatch: true } : {}),
-        ...(opts.mcp === false ? { mcpEnabled: false } : {}),
-        ...(opts.auth === false ? { noAuth: true } : {}),
-        ...(opts.force ? { force: true } : {}),
-        ...(opts.dispatch ? { dispatch: true } : {}),
-        ...(opts.toolCwd ? { toolCwd: opts.toolCwd } : {}),
-        ...(opts.historyDir ? { historyDir: opts.historyDir } : {}),
-        ...(resolvedHttpHost ? { httpHost: resolvedHttpHost } : {}),
-        ...(resolvedPort !== undefined ? { httpStartPort: resolvedPort } : {}),
-      });
+      // Only isolated daemons force exit after SIGINT cleanup; production and
+      // SIGTERM keep their existing service-manager lifecycle contracts.
+      const isolatedDaemon = (await import('./instance/current.js')).resolveCurrentInstance().kind === 'test';
+      let stoppedBySigint = false;
+      let cleanupTimer: ReturnType<typeof setTimeout> | undefined;
+      const onStop = () => {
+        if (!isolatedDaemon) return;
+        stoppedBySigint = true;
+        cleanupTimer = setTimeout(() => {
+          console.error('elanous nexus: SIGINT cleanup exceeded 8s; exiting');
+          process.exit(1);
+        }, 8_000);
+      };
+      if (isolatedDaemon) process.once('SIGINT', onStop);
+      try {
+        await runNexus({
+          headless: true,
+          tools: toolsKind ?? 'webterm',
+          autoMountShare: !bgChild,
+          // bg-launch child reads `--watch` from forwardArgs (set by
+          // runPwaStart). External !TTY launches (launchd / Docker /
+          // nohup) get watch only when the user explicitly didn't disable
+          // it — service-manager production posture stays watch-off.
+          ...((bgChild ? opts.watch === true : watchOn) ? { pwaWatch: true } : {}),
+          ...(opts.mcp === false ? { mcpEnabled: false } : {}),
+          ...(opts.auth === false ? { noAuth: true } : {}),
+          ...(opts.force ? { force: true } : {}),
+          ...(opts.dispatch ? { dispatch: true } : {}),
+          ...(opts.toolCwd ? { toolCwd: opts.toolCwd } : {}),
+          ...(opts.historyDir ? { historyDir: opts.historyDir } : {}),
+          ...(resolvedHttpHost ? { httpHost: resolvedHttpHost } : {}),
+          ...(resolvedPort !== undefined ? { httpStartPort: resolvedPort } : {}),
+        });
+      } catch (error) {
+        if (stoppedBySigint) {
+          console.error(`elanous nexus: SIGINT cleanup failed: ${error instanceof Error ? error.message : String(error)}`);
+          process.exit(1);
+        }
+        throw error;
+      } finally {
+        process.removeListener('SIGINT', onStop);
+        if (cleanupTimer) clearTimeout(cleanupTimer);
+      }
+      if (stoppedBySigint) process.exit(0);
       return;
     }
 
@@ -10739,18 +10890,24 @@ async function main(): Promise<void> {
       program.error(`error: unknown command '${firstCommand}'`);
       return;
     }
-    await program.parseAsync(['node', 'elanous', ...args]);
+    const showAll = args[0] === '--help-all';
+    const role = getUserConfig().cli?.helpRole ?? 'owner';
+    const { shown, hidden } = filterCliRootHelp(program.commands, role, showAll);
+    debug.log('cli.maturity', 'help-filtered', { role, shown, hidden });
+    await program.parseAsync(['node', 'elanous', ...(showAll ? ['--help'] : args)]);
     return;
   }
 
-  // First-run: trigger the onboarding wizard before dropping into the
-  // dashboard so we don't need to handle half-configured state in the
-  // TUI chrome. Subsequent launches skip straight to the dashboard.
-  // (Bare `elanous` always lands on the dashboard now, so the wizard just
-  // gates on config completeness — no entry-mode branch.)
+  // Bare entry only requires an LLM; detailed setup stays behind `eln setup`.
+  const firstRunStartedAt = Date.now();
   const cfg = getUserConfig();
-  if (needsOnboarding(cfg)) {
-    if (!await runFirstSetupForCli(cfg)) return;
+  if (needsFirstRun(cfg)) {
+    if (cfg.onboarding.webFirst !== false) {
+      const { runWebFirstSetup } = await import('./onboarding/web-first.js');
+      if (await runWebFirstSetup({ config: cfg, startedAt: firstRunStartedAt }) === 'link-shown') return;
+    }
+    const { runFirstRun } = await import('./onboarding/first-run.js');
+    if ((await runFirstRun({ config: cfg })).outcome !== 'ready') return;
   }
 
   // Active-provider banner so users know WHICH model/auth is about to