elanous 0.2.10 → 0.2.11

package/src/hooks/providers.ts

@@ -1,11 +1,20 @@
 import { createHmac, timingSafeEqual } from 'node:crypto';
 
-export type HookProvider = 'linear' | 'asana';
+export type HookProvider = 'linear' | 'asana' | 'github';
+export const PUBLIC_GITHUB_REPO = 'ElanvitalAI/elanous';
+/** Links to documentation and reproductions are not spam signals. */
+export function isGithubSpamText(value: string): boolean {
+  return /\b(?:casino|crypto giveaway|free money|seo backlinks|airdrop)\b/i.test(value);
+}
 export interface ExternalTask {
   eventId: string;
   title: string;
   description?: string;
   external: { provider: HookProvider; ref: string; url?: string };
+  /** Linear issue assignee ID, resolved by the configured seat mapping; events.routes takes precedence. */
+  assigneeId?: string;
+  /** L14: an opened PR/issue on the public repository — shadow intake only, never dispatched to seats. */
+  github?: { repository: string; number: number; type: 'pull_request' | 'issue'; spamSignal?: boolean };
 }
 export type Verification = { ok: true; body: unknown; eventIds: string[]; ignored?: string } | { ok: false; reason: 'bad-signature' | 'stale' | 'invalid-body' };
 
@@ -29,7 +38,9 @@ export function asanaEventId(event: unknown): string | undefined {
 }
 
 export function verifyWebhook(provider: HookProvider, raw: Buffer, headers: Headers, secret: string, now = Date.now()): Verification {
-  if (!equalSignature(raw, secret, headers.get(provider === 'linear' ? 'linear-signature' : 'x-hook-signature')))
+  const signature = headers.get(provider === 'linear' ? 'linear-signature' : provider === 'github' ? 'x-hub-signature-256' : 'x-hook-signature');
+  const digest = provider === 'github' ? (signature?.startsWith('sha256=') ? signature.slice(7) : null) : signature;
+  if (!equalSignature(raw, secret, digest))
     return { ok: false, reason: 'bad-signature' };
   let parsed: unknown;
   try { parsed = JSON.parse(raw.toString('utf8')); } catch { return { ok: false, reason: 'invalid-body' }; }
@@ -39,15 +50,45 @@ export function verifyWebhook(provider: HookProvider, raw: Buffer, headers: Head
     const timestamp = body.webhookTimestamp;
     if (typeof timestamp !== 'number' || !Number.isFinite(timestamp) || Math.abs(now - timestamp) > 60_000)
       return { ok: false, reason: 'stale' };
-    // Linear 은 실패 응답이 쌓이면 웹훅을 꺼 버린다 — 서명이 맞는 «대상 아닌» 이벤트(댓글·수정 등)는
-    // 거절하지 않고 받아서 버린다. 지금 태스크로 만드는 것은 이슈 생성뿐이다.
-    if (body.type !== 'Issue' || body.action !== 'create')
+    // Acknowledge signed, out-of-scope events so Linear does not disable the webhook.
+    const previous = object(body.updatedFrom);
+    const relevantUpdate = body.action === 'update' && previous &&
+      ('assigneeId' in previous || 'stateId' in previous);
+    if (body.type !== 'Issue' || (body.action !== 'create' && !relevantUpdate))
       return { ok: true, body, eventIds: [], ignored: `${String(body.type)}:${String(body.action)}` };
     const eventId = text(headers.get('linear-delivery')) ?? (text(body.webhookId) && text(body.createdAt) ? `${body.webhookId}:${body.createdAt}` : undefined);
     if (!eventId || !object(body.data) || !text(object(body.data)?.id) || !text(object(body.data)?.title))
       return { ok: false, reason: 'invalid-body' };
     return { ok: true, body, eventIds: [eventId] };
   }
+  if (provider === 'github' && object(body.repository)?.full_name === PUBLIC_GITHUB_REPO) {
+    // L14: the public repository's newly opened PRs/issues go to the shadow intake (no seat dispatch, no outside writes).
+    const kind = headers.get('x-github-event');
+    if (!['pull_request', 'issues'].includes(kind ?? '') || body.action !== 'opened')
+      return { ok: true, body, eventIds: [], ignored: `${kind ?? 'unknown'}:${String(body.action)}` };
+    const item = object(body[kind === 'pull_request' ? 'pull_request' : 'issue']);
+    const delivery = headers.get('x-github-delivery');
+    if (!delivery || !/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(delivery) || !Number.isSafeInteger(body.number) ||
+        (body.number as number) < 1 || !item || item.number !== body.number || !text(item.title) ||
+        !text(item.html_url) || !text(object(item.user)?.login) ||
+        item.html_url !== `https://github.com/${PUBLIC_GITHUB_REPO}/${kind === 'pull_request' ? 'pull' : 'issues'}/${body.number}`)
+      return { ok: false, reason: 'invalid-body' };
+    return { ok: true, body: { ...body, githubEvent: kind, publicIntake: true }, eventIds: [delivery] };
+  }
+  if (provider === 'github') {
+    const event = headers.get('x-github-event');
+    const action = text(body.action);
+    if (!((event === 'pull_request' && action === 'review_requested') ||
+      (event === 'check_run' && action === 'completed' && object(body.check_run)?.conclusion === 'failure') ||
+      (event === 'check_suite' && action === 'completed' && object(body.check_suite)?.conclusion === 'failure')))
+      return { ok: true, body, eventIds: [], ignored: `${String(event)}:${String(action)}` };
+    const delivery = text(headers.get('x-github-delivery'));
+    const resource = object(event === 'pull_request' ? body.pull_request : event === 'check_run' ? body.check_run : body.check_suite);
+    if (!delivery || !resource || typeof resource.id !== 'number' ||
+      !(text(resource.html_url) ?? text(resource.details_url) ?? text(object(body.repository)?.html_url)))
+      return { ok: false, reason: 'invalid-body' };
+    return { ok: true, body: { ...body, githubEvent: event }, eventIds: [delivery] };
+  }
   if (!Array.isArray(body.events)) return { ok: false, reason: 'invalid-body' };
   const ids = body.events.map(asanaEventId);
   if (ids.some(id => !id)) return { ok: false, reason: 'invalid-body' };
@@ -63,9 +104,34 @@ export function toExternalTask(provider: HookProvider, body: unknown): ExternalT
     const title = text(issue?.title);
     const eventId = text(row.eventId) ?? (text(row.webhookId) && text(row.createdAt) ? `${row.webhookId}:${row.createdAt}` : undefined);
     if (!ref || !title || !eventId) throw new Error('invalid linear issue');
+    const assigneeId = text(issue?.assigneeId) ?? text(object(issue?.assignee)?.id);
     return { eventId, title, ...(text(issue?.description) ? { description: text(issue?.description) } : {}),
+      ...(assigneeId ? { assigneeId } : {}),
       external: { provider, ref, ...(text(issue?.url) ? { url: text(issue?.url) } : {}) } };
   }
+  if (provider === 'github' && row.publicIntake === true) {
+    const type = row.githubEvent === 'pull_request' ? 'pull_request' : 'issue';
+    const item = object(type === 'pull_request' ? row.pull_request : row.issue);
+    const number = row.number;
+    const eventId = text(row.eventId);
+    if (!Number.isSafeInteger(number) || !item || !eventId || !text(item.title) || !text(item.html_url))
+      throw new Error('invalid github event');
+    return { eventId, title: item.title as string,
+      external: { provider, ref: `${PUBLIC_GITHUB_REPO}#${number}`, url: item.html_url as string },
+      github: { repository: PUBLIC_GITHUB_REPO, number: number as number, type,
+        spamSignal: typeof item.body === 'string' && isGithubSpamText(item.body) } };
+  }
+  if (provider === 'github') {
+    const event = text(row.githubEvent);
+    const resource = object(event === 'pull_request' ? row.pull_request : event === 'check_run' ? row.check_run : row.check_suite);
+    const ref = resource?.id;
+    const eventId = text(row.eventId);
+    const url = text(resource?.html_url) ?? text(resource?.details_url) ?? text(object(row.repository)?.html_url);
+    if (typeof ref !== 'number' || !eventId || !url) throw new Error('invalid github event');
+    const title = event === 'pull_request' ? `PR review requested: ${text(resource?.title) ?? url}`
+      : `Check failed: ${text(resource?.name) ?? text(resource?.head_branch) ?? url}`;
+    return { eventId, title, external: { provider, ref: String(ref), url } };
+  }
   const event = object(row.event);
   const task = object(row.task);
   const ref = text(object(event?.resource)?.gid);

package/src/hooks/queue.ts

@@ -4,7 +4,7 @@ import { dirname, join } from 'node:path';
 import { effectiveInstanceRoot } from '../instance/resolve.js';
 import type { ExternalTask } from './providers.js';
 
-export interface QueuedHook { provider: ExternalTask['external']['provider']; eventId: string; task: ExternalTask }
+export interface QueuedHook { provider: ExternalTask['external']['provider']; eventId: string; kind?: string; task: ExternalTask }
 
 export class HookQueue {
   readonly directory: string;

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';
@@ -873,8 +874,10 @@ seatCmd.command('loop').requiredOption('--seat <SEAT>', 'MK|OP|TC|UX')
   .option('--json', 'JSON 출력')
   .action(async (opts: { seat: string; once: boolean; json?: boolean }) => {
     try {
-      const { runSeatLoopOnce } = await import('./seat-loop/seat-loop.js');
-      const result = await runSeatLoopOnce(opts.seat);
+      // 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; }
@@ -913,6 +916,7 @@ registerCardCommand(program);
 registerLaunchHeadCommands(program);
 registerA2ACommands(program);
 registerPluginCommands(program);
+registerMakeCommand(program);
 registerSkillsCommands(program);
 registerConnectCommand(program);
 registerImportCommand(program);
@@ -3024,6 +3028,24 @@ 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>', '발신 자리')
@@ -3975,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) {
@@ -4011,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)')
@@ -4029,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; }
@@ -4128,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 전달·리뷰노드 경유)')
@@ -4138,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 마다 잔량 많은 계정을 돌려 준다')
@@ -4146,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;
@@ -6298,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 이고 그 사실이 관측에 남는다.
@@ -6324,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)')
@@ -6620,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();

package/src/intake-plane/categorize.ts

@@ -25,6 +25,7 @@ import type {
 } from './enrich.js';
 import { summariseContext } from './enrich.js';
 import { buildResponseFormatHeader } from './prompt-format.js';
+import { judge } from '../llm/judge-layer.js';
 
 // ──────────────────── Closed sets ──────────────────────────────────────
 
@@ -69,7 +70,7 @@ export interface CategorizeResult {
 }
 
 export interface CategorizeCallable {
-  (args: { prompt: string; signal?: AbortSignal }): Promise<{
+  (args: { prompt: string; signal?: AbortSignal; provider?: string; model?: string }): Promise<{
     text: string;
     promptTokens?: number;
     completionTokens?: number;
@@ -219,26 +220,6 @@ export function buildCategorizePrompt(decomposition: EnrichedDecomposition): str
 
 // ──────────────────── Parse + coerce ──────────────────────────────────
 
-function extractJsonBlock(text: string): unknown | null {
-  const trimmed = text.trim();
-  const fence = trimmed.match(/```(?:json)?\n([\s\S]*?)```/);
-  const candidate = fence ? fence[1]! : trimmed;
-  try {
-    return JSON.parse(candidate);
-  } catch {
-    const open = candidate.indexOf('{');
-    const close = candidate.lastIndexOf('}');
-    if (open >= 0 && close > open) {
-      try {
-        return JSON.parse(candidate.slice(open, close + 1));
-      } catch {
-        return null;
-      }
-    }
-    return null;
-  }
-}
-
 function coerceConfidence(v: unknown): 'high' | 'medium' | 'low' {
   if (v === 'high' || v === 'medium' || v === 'low') return v;
   return 'medium';
@@ -306,27 +287,18 @@ export async function categorizeDecomposition(
 
   const prompt = buildCategorizePrompt(decomposition);
 
-  let raw;
-  try {
-    raw = await opts.callable({ prompt, signal: opts.signal });
-  } catch (err) {
-    if (opts.strict) {
-      throw new CategorizeError(
-        'LLM_CALL_FAILED',
-        err instanceof Error ? err.message : String(err),
-      );
-    }
-    return {
-      categorizations: Object.fromEntries(tasks.map((t) => [t.key, fallbackRow(t.key)])),
-      fallback: true,
-    };
-  }
-
-  const parsed = extractJsonBlock(raw.text);
-  const coerced = parsed ? coerceCategorizations(parsed, validKeys) : null;
-  if (coerced === null) {
+  const decision = await judge({
+    site: 'intake.categorize', prompt, signal: opts.signal,
+    call: ({ prompt, signal, provider, model }) => opts.callable({ prompt, signal, provider, model }),
+    schema: (parsed) => coerceCategorizations(parsed, validKeys),
+  });
+  if (!decision.ok) {
     if (opts.strict) {
-      throw new CategorizeError('PARSE_FAILED', 'no usable categorizations', raw.text);
+      if (decision.reason === 'call') {
+        throw new CategorizeError('LLM_CALL_FAILED',
+          decision.error instanceof Error ? decision.error.message : String(decision.error));
+      }
+      throw new CategorizeError('PARSE_FAILED', 'no usable categorizations', decision.rawText);
     }
     return {
       categorizations: Object.fromEntries(tasks.map((t) => [t.key, fallbackRow(t.key)])),
@@ -336,7 +308,7 @@ export async function categorizeDecomposition(
 
   // Backfill any missing tasks with the fallback shape so callers can
   // index by key without null checks.
-  const filled: Record<string, TaskCategorization> = { ...coerced };
+  const filled: Record<string, TaskCategorization> = { ...decision.value };
   for (const t of tasks) {
     if (!filled[t.key]) filled[t.key] = fallbackRow(t.key);
   }
@@ -344,10 +316,10 @@ export async function categorizeDecomposition(
     categorizations: filled,
     fallback: false,
     usage: {
-      promptTokens: raw.promptTokens,
-      completionTokens: raw.completionTokens,
-      costUsd: raw.costUsd,
-      modelId: raw.modelId,
+      promptTokens: decision.reply.promptTokens,
+      completionTokens: decision.reply.completionTokens,
+      costUsd: decision.reply.costUsd,
+      modelId: decision.reply.modelId,
     },
   };
 }

package/src/intake-plane/discord-seat-work.ts

@@ -3,6 +3,7 @@ import { discordDecisionOwner } from '../decisions/discord-decision-cards.js';
 import { canonicalSeatId } from '../msg/msg-store.js';
 import { dispatchCeoTask, type CeoCommandDeps } from '../seat-dispatch/ceo-commands.js';
 import { ceoTaskDeps, classifyCeoIntent } from '../seat-dispatch/ceo-intent.js';
+import { askSeat, parseSeatAsk, type SeatAskDeps } from '../seat-dispatch/seat-ask.js';
 import { parseSeatAddress, resolveSeat } from '../seat-address/seat-address.js';
 import { getUserConfig, type UserConfig } from '../user-config.js';
 import { answerAsSeat } from './seat-answer.js';
@@ -25,6 +26,7 @@ export interface DiscordSeatWorkDeps extends SubmitIntakeWorkDeps {
   answer?: typeof answerAsSeat;
   dispatch?: typeof dispatchCeoTask;
   commandDeps?: CeoCommandDeps;
+  askDeps?: SeatAskDeps;
 }
 
 /** Addressed work preserves graph intake except for one owner's private seat request. */
@@ -44,6 +46,14 @@ export async function handleDiscordSeatWork(
     debug.log('seat.dispatch', 'intent', { seat, intent: 'task', via: 'discord', outcome: result.channel });
     return result.reply;
   };
+  if (parseSeatAsk(text)) {
+    const auth = owner();
+    if (!auth) return null;
+    if (!deps.askDeps) throw new Error('seat ask delivery unavailable');
+    return askSeat(text, { channel: 'discord', channelId: msg.channelId, messageId: msg.messageId,
+      ...(msg.threadId ? { threadId: msg.threadId } : {}) },
+    deps.commandDeps ?? ceoTaskDeps(auth.cfg, auth.id), deps.askDeps);
+  }
   const address = parseSeatAddress(text);
   if (!address) {
     if (!text.trim() || /^\s*[/@＠]/.test(text)) return null;

package/src/intake-plane/front-route-classifier.ts

@@ -1,7 +1,6 @@
 import { debug } from '../debug/log.js';
-import type { ModelRole } from '../user-config.js';
-import type { ResolveRoleProviderFn, StreamLlmFn, ProviderRegistry } from './runtime-callables.js';
-import { extractJsonBlock } from './decompose.js';
+import type { ResolveRoleProviderFn, StreamLlmFn } from './runtime-callables.js';
+import { judge } from '../llm/judge-layer.js';
 import {
   INTAKE_FRONT_ROUTE_TRACKS,
   type IntakeFrontRouteDecision,
@@ -14,17 +13,6 @@ interface ClassifierDeps {
   minConfidence?: number;
 }
 
-function loadRoleProvider(): ResolveRoleProviderFn {
-  const { resolveRoleLlm } = require('../user-config.js') as {
-    resolveRoleLlm: (role: ModelRole) => { provider: string; model: string };
-  };
-  const { PROVIDERS } = require('../llm.js') as { PROVIDERS: ProviderRegistry };
-  return (role) => {
-    const resolved = resolveRoleLlm(role);
-    return { provider: PROVIDERS[resolved.provider] ?? { name: resolved.provider }, model: resolved.model };
-  };
-}
-
 /** Classify only after the deterministic front-route rules return rule-unknown. */
 export async function classifyIntakeFrontRoute(
   text: string,
@@ -43,32 +31,38 @@ export async function classifyIntakeFrontRoute(
   const failed = (cause: string) => finish('ask-human', 0, `classifier-failed:${cause}`, 'failed');
 
   try {
-    const rolePick = (deps.resolveRoleProvider ?? loadRoleProvider())('classify');
-    provider = rolePick.provider.name;
-    const streamLLM = deps.streamLLM ?? (require('../llm.js') as { streamLLM: StreamLlmFn }).streamLLM;
-    const response = await streamLLM([
-      { role: 'system', content: [
-        'Classify the intake text into exactly one track:',
-        'absorb: read, save, or summarize external material.',
-        'tasks: a list of independent to-dos.',
-        'graph: an implementation or multi-step workflow request.',
-        'ask-human: ambiguous intent requiring human choice.',
-        'Return only one JSON object: {"track":"...","confidence":0.0,"reason":"..."}. Confidence must be between 0 and 1.',
-      ].join('\n') },
-      { role: 'user', content: text },
-    ], () => {}, { provider: rolePick.provider, ...(rolePick.model ? { model: rolePick.model } : {}), usageRole: 'classify' });
-
-    // 실제 모델은 JSON 을 ```json 펜스로 감싸거나 앞뒤에 말을 붙이곤 한다 — 같은 디렉토리의 다른 호출자와 같은 관대한 추출을 쓴다.
-    const parsed: unknown = extractJsonBlock(response);
-    if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) return failed('invalid-json');
-    const candidate = parsed as Record<string, unknown>;
-    if (typeof candidate.track !== 'string' ||
-      !(INTAKE_FRONT_ROUTE_TRACKS as readonly string[]).includes(candidate.track)) return failed('invalid-track');
-    if (typeof candidate.confidence !== 'number' || !Number.isFinite(candidate.confidence) ||
-      candidate.confidence < 0 || candidate.confidence > 1) return failed('invalid-confidence');
-    if (typeof candidate.reason !== 'string') return failed('invalid-reason');
+    const decision = await judge({
+      site: 'intake.front-route',
+      prompt: text,
+      messages: [
+        { role: 'system', content: [
+          'Classify the intake text into exactly one track:',
+          'absorb: read, save, or summarize external material.',
+          'tasks: a list of independent to-dos.',
+          'graph: an implementation or multi-step workflow request.',
+          'ask-human: ambiguous intent requiring human choice.',
+          'Return only one JSON object: {"track":"...","confidence":0.0,"reason":"..."}. Confidence must be between 0 and 1.',
+        ].join('\n') },
+        { role: 'user', content: text },
+      ],
+      streamLLM: deps.streamLLM,
+      resolveRoleProvider: deps.resolveRoleProvider,
+      schema: (parsed) => {
+        if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) return null;
+        const candidate = parsed as Record<string, unknown>;
+        if (typeof candidate.track !== 'string' ||
+          !(INTAKE_FRONT_ROUTE_TRACKS as readonly string[]).includes(candidate.track)) return null;
+        if (typeof candidate.confidence !== 'number' || !Number.isFinite(candidate.confidence) ||
+          candidate.confidence < 0 || candidate.confidence > 1) return null;
+        if (typeof candidate.reason !== 'string') return null;
+        return { track: candidate.track as IntakeFrontRouteTrack, confidence: candidate.confidence, reason: candidate.reason };
+      },
+    });
+    provider = decision.ok ? decision.provider : provider;
+    if (!decision.ok) return failed(decision.reason === 'schema' ? 'invalid-json' : 'llm-error');
+    const candidate = decision.value;
 
-    const track = candidate.track as IntakeFrontRouteTrack;
+    const track = candidate.track;
     const confidence = candidate.confidence;
     if (confidence < (deps.minConfidence ?? 0.6)) {
       return finish('ask-human', confidence, `classifier-low-confidence:${track}`, 'low-confidence');