elanous 0.2.17 → 0.2.19

package/src/index.ts

@@ -51,6 +51,7 @@ import { registerRoleCommands } from './cli/role-cli.js';
 import { registerMachineCommands } from './cli/machine-cli.js';
 import { registerAgentEnvCommands } from './cli/agent-env-cli.js';
 import { registerScheduleCommands } from './cli/schedule-cli.js';
+import { registerGuardianCommands } from './cli/guardian-cli.js';
 export { runSchedule, scheduleCreatePlan } from './cli/schedule-cli.js';
 export type { ScheduleDispatch } from './cli/schedule-cli.js';
 import { registerReviewLoopOptions, buildReviewLoopOpts } from './agent-mission/review-loop-cli.js';
@@ -74,6 +75,8 @@ import { registerModelWatchCommand } from './cli/model-watch-cli.js';
 import { registerIntakeCommands } from './cli/intake-cli.js';
 import { registerTasksCommands } from './cli/tasks-cli.js';
 import { registerBriefCommands } from './cli/brief-cli.js';
+import { registerNotifyCommand } from './cli/notify-cli.js';
+import { registerAwayCommand } from './cli/away-cli.js';
 import { registerLabelsCommands } from './cli/labels-cli.js';
 import { registerMsgCommands } from './cli/msg-cli.js';
 import { registerDoctorCommand } from './cli/doctor-cli.js';
@@ -135,6 +138,7 @@ 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, needsFirstRun, handleOnboardingRefusal, type OnboardingStepId } from './onboarding.js';
+import { firstChatGate } from './onboarding/first-chat-gate.js';
 import {
   getUserConfig, reloadUserConfig, userConfigPath, saveUserConfig,
   backupUserConfig, backupConfigPath, addRotationEntry, type RotationEntry,
@@ -213,6 +217,23 @@ export { cliVersion, setInstallMetadataRootForTesting };
 export const program = new Command();
 program.enablePositionalOptions();
 
+program.command('preview <target>')
+  .description('Isolated PR/branch-head TUI + PWA preview; publish the TUI-COMFORT friction table to a PR')
+  .option('--scenario <id>', 'TUI-COMFORT scenario (default S2)', 'S2')
+  .option('--flag <path>', 'Enable an existing config feature flag in main-based preview (repeatable)', (value: string, all: string[]) => [...all, value], [] as string[])
+  .option('--comment-pr <number>', 'PR to receive a branch/main preview report', (value: string) => Number(value))
+  .action(async (target: string, opts: { scenario: string; flag: string[]; commentPr?: number }) => {
+    try {
+      const { runPrPreview } = await import('./self-dev/pr-preview.js');
+      const result = await runPrPreview({ target, repoRoot: process.cwd(), scenario: opts.scenario, flags: opts.flag, ...(opts.commentPr === undefined ? {} : { commentPr: opts.commentPr }) });
+      console.log(`preview ${result.status} · ${result.head} · PR #${result.prNumber} · comment posted`);
+      if (result.status !== 'passed') process.exitCode = 1;
+    } catch (error) {
+      console.error(error instanceof Error ? error.message : String(error));
+      process.exitCode = 1;
+    }
+  });
+
 export { SELF_SEND_RECENT_FRAME_WINDOW_MS, SELF_SEND_STALE_HEARTBEAT_MS, formatSelfSendCandidateDisplay } from './harness/self-send-decide.js';
 export type { SelfSendCandidate, SelfSendCandidateDisplay } from './harness/self-send-decide.js';
 import { decideSelfSend, type SelfSendCandidate } from './harness/self-send-decide.js';
@@ -888,6 +909,8 @@ registerLiveCommands(program);
 registerResearchCommand(program);
 registerReleaseCommands(program);
 registerKnowCommand(program);
+registerNotifyCommand(program);
+registerAwayCommand(program);
 registerFreezeCommands(program);
 registerFlowCommands(program);
 // HQ-HB · HQ-FENCE (10-04): one writer across mbp · node-b · cloud-vm — lease on the arbiter, 2-of-3 quorum, generation fencing.
@@ -985,6 +1008,37 @@ hqCmd.command('seen').description('이 호스트가 본 가장 높은 임대 세
     process.exitCode = result.seen ? 0 : 3;
   });
 registerHqMovePlanCommand(hqCmd);
+hqCmd.command('init').description('한 저장소의 bare 미러와 집 원장을 만들고 5분 fetch 크론 줄만 출력')
+  .option('--root <dir>', 'HQ 폴더 (기본 ~/elanous-hq)')
+  .action(async (opts: { root?: string }) => {
+    try {
+      const { hqInit } = await import('./hq/seats.js');
+      const { getElanousConfigDir } = await import('./elanous-config-dir.js');
+      const result = hqInit({ ...opts, home: getElanousConfigDir() });
+      console.log(`hq init: ${result.created ? 'created' : 'already exists'} ${result.root}\n# OP installs this line; nothing was installed:\n${result.cron}`);
+    } catch (error) { console.error(`hq init: ${error instanceof Error ? error.message : String(error)}`); process.exitCode = 1; }
+  });
+hqCmd.command('seat <role>').description('OP|MK|TC|UX 자리 워크트리 (깨끗할 때만 갱신)')
+  .option('--refresh', 'origin/main으로 깨끗한 자리만 최신화')
+  .option('--root <dir>', 'HQ 폴더')
+  .action(async (role: string, opts: { refresh?: boolean; root?: string }) => {
+    try {
+      const { hqSeat } = await import('./hq/seats.js');
+      const result = hqSeat(role, opts);
+      if (result.outcome === 'dirty') console.warn(`hq seat ${role}: dirty — refresh skipped; move edits to hq work new`);
+      else console.log(`hq seat ${role}: ${result.outcome} ${result.path}`);
+    } catch (error) { console.error(`hq seat: ${error instanceof Error ? error.message : String(error)}`); process.exitCode = 1; }
+  });
+const hqWorkCmd = hqCmd.command('work').description('고칠 때만 작업 워크트리를 만들고 병합 후 회수');
+for (const action of ['new', 'done'] as const) hqWorkCmd.command(`${action} <role> <name>`)
+  .option('--root <dir>', 'HQ 폴더')
+  .action(async (role: string, name: string, opts: { root?: string }) => {
+    try {
+      const { hqWork } = await import('./hq/seats.js');
+      const result = hqWork(action, role, name, opts);
+      console.log(`hq work ${action}: ${result.outcome} ${result.path}`);
+    } catch (error) { console.error(`hq work ${action}: ${error instanceof Error ? error.message : String(error)}`); process.exitCode = 1; }
+  });
 const fenceWrapperCmd = hqCmd.command('fence-wrapper').description('설치본 HQ 울타리 크론 래퍼');
 fenceWrapperCmd.command('install').description('래퍼 제안 또는 백업 후 원자적 설치')
   .option('--dry-run', '변경 내용만 출력 (기본)')
@@ -1042,6 +1096,40 @@ hqCmd.command('fence').description('이 호스트가 임대를 쥐었을 때만
   });
 const seatCmd = program.command('seat').description('분배된 자리의 하루 루프와 보고');
 registerSeatRequestsCommands(seatCmd);
+seatCmd.command('asks').description('최근 CTO 되묻기 왕복과 10분 판정')
+  .option('--since <duration>', '조회 창 (예: 24h)', '24h')
+  .option('--json', 'JSON 출력')
+  .action(async (opts: { since: string; json?: boolean }) => {
+    try {
+      const duration = /^(\d+)([mhd])$/.exec(opts.since);
+      if (!duration || !Number.isSafeInteger(Number(duration[1]))) throw new Error('--since: 24h, 30m, 7d 형식 필요');
+      const ms = Number(duration[1]) * ({ m: 60_000, h: 3_600_000, d: 86_400_000 }[duration[2]!] ?? 0);
+      if (!Number.isSafeInteger(ms) || ms <= 0) throw new Error('--since: 양의 시간 필요');
+      const { defaultMsgStorePath } = await import('./msg/msg-store.js');
+      const path = defaultMsgStorePath();
+      if (!(await import('node:fs')).existsSync(path)) {
+        if (opts.json) await writeStdoutJson('[]\n');
+        else console.log(`원장 없음 — ${path}`);
+        return;
+      }
+      const { listSeatAskRoundTrips } = await import('./seat-dispatch/seat-ask.js');
+      const now = Date.now();
+      const rows = listSeatAskRoundTrips({ since: now - ms, now });
+      if (!rows.length) {
+        if (opts.json) await writeStdoutJson('[]\n');
+        else console.log('이 창에 되묻기 0건');
+        return;
+      }
+      if (opts.json) { await writeStdoutJson(`${JSON.stringify(rows)}\n`); return; }
+      const clock = (value: number | null) => value === null ? '-' : new Intl.DateTimeFormat('ko-KR', {
+        timeZone: 'Asia/Seoul', hour: '2-digit', minute: '2-digit', hourCycle: 'h23',
+      }).format(value);
+      console.log('id · 표면 · 물음 HH:MM KST · 답 · 도착 · 왕복 분 · 판정');
+      for (const row of rows) console.log(`${row.id} · ${row.surface} · ${clock(row.askedAt)} KST · ${clock(row.answeredAt)} · ${clock(row.deliveredAt)} · ${row.roundTripMs === null ? '-' : (row.roundTripMs / 60_000).toFixed(1)}분 · ${row.verdict}`);
+      const count = (verdict: string) => rows.filter(row => row.verdict === verdict).length;
+      console.log(`10분 안 ${count('10분 안')} / 넘음 ${count('10분 넘음')} / 미답 ${count('미답')} / 대기 ${count('답 대기') + count('전달 대기')} / 미상 ${count('시각 미상')}`);
+    } catch (error) { console.error(`seat asks: ${error instanceof Error ? error.message : String(error)}`); process.exitCode = 1; }
+  });
 seatCmd.command('answer <askId> <answer>').description('자리 질문에 답을 남기고 원래 표면으로 회신 예약')
   .action(async (askId: string, answer: string) => {
     try {
@@ -3299,11 +3387,20 @@ contextCmd.command('day')
   .description('자리 넷과 외부 세션의 최근 맥락 이벤트 수·마지막 시각 (읽기 전용)')
   .option('--since <hours>', '최근 시간 창 (예: 24h)', '24h')
   .option('--json', '구조화된 JSON 출력')
-  .action(async (opts: { since: string; json?: boolean }) => {
+  .option('--timeline', '시간순 사건 한 줄씩 (KST)')
+  .option('--seat <source>', '한 출처만 (OP|TC|MK|UX|claude-code|codex-agent-mission|harness-child)')
+  .action(async (opts: { since: string; json?: boolean; timeline?: boolean; seat?: string }) => {
     try {
-      const { contextDay, renderContextDay } = await import('./context-bus/context-day.js');
-      const report = contextDay(opts.since);
-      await writeStdoutJson(`${opts.json ? JSON.stringify(report) : renderContextDay(report)}\n`);
+      const { contextDay, contextDayTimeline, renderContextDay, renderContextDayTimeline, CONTEXT_DAY_SOURCES } = await import('./context-bus/context-day.js');
+      if (opts.seat && !CONTEXT_DAY_SOURCES.some(source => source === opts.seat)) throw new Error(`unknown --seat: ${opts.seat}`);
+      if (opts.seat && !opts.timeline) throw new Error('--seat requires --timeline');
+      if (opts.timeline) {
+        const report = contextDayTimeline(opts.since, { seat: opts.seat as typeof CONTEXT_DAY_SOURCES[number] | undefined });
+        await writeStdoutJson(`${opts.json ? JSON.stringify(report) : renderContextDayTimeline(report)}\n`);
+      } else {
+        const report = contextDay(opts.since);
+        await writeStdoutJson(`${opts.json ? JSON.stringify(report) : renderContextDay(report)}\n`);
+      }
     } catch (error) {
       console.error(`context day: ${error instanceof Error ? error.message : String(error)}`);
       process.exitCode = 2;
@@ -4337,16 +4434,52 @@ selfCmd
   .option('--base <ref>', '커밋됐지만 PR 없는 변경의 비교 기준(ref...HEAD)')
   .option('--pr <number>', '열린 PR 번호에서 gh pr view files로 변경 파일을 읽는다')
   .option('--shards [number]', '메모리 예산에 맞춰 시험을 별도 프로세스로 분할한다 (기본 2)')
-  .action((opts: { changed?: boolean; base?: string; pr?: string; shards?: string | boolean }) => {
+  .option('--remote [host]', 'GATE-REMOTE — 같은 커밋을 원격 호스트(기본 config gateRemote.host=node-b)에서 돌리고 결과만 가져온다(깨끗한 트리 · --pr 은 로컬)')
+  .option('--local', '원격 자동 분배(로컬 1분 부하 > gateRemote.loadThreshold=20)를 끄고 로컬에서 돌린다')
+  .action(async (opts: { changed?: boolean; base?: string; pr?: string; shards?: string | boolean; remote?: string | boolean; local?: boolean }) => {
     if (!opts.changed && opts.shards === undefined) { ui.error('self gate requires --changed or --shards'); process.exitCode = 2; return; }
+    // The root strips `--local` from argv anywhere (remote-bookmark attach · src/cli/remote-resolve.ts) before Commander
+    // sees it, so this subcommand reads it from the untouched process.argv.
+    opts.local = !!opts.local || process.argv.slice(2).includes('--local');
+    if (opts.remote !== undefined && opts.local) { ui.error('self gate: --remote and --local cannot be combined'); process.exitCode = 2; return; }
+    if (typeof opts.remote === 'string') {
+      const { isValidGateHost } = await import('./self-implement/gate-remote.js');
+      if (!isValidGateHost(opts.remote)) { ui.error(`self gate: invalid --remote host: ${opts.remote}`); process.exitCode = 2; return; }
+    }
+    const shards = opts.shards === undefined ? undefined : opts.shards === true ? 2 : Number(opts.shards);
+    const runLocal = () => {
+      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, shards });
+        console.log(result.lines.join('\n'));
+        return result.exitCode;
+      } catch (error) {
+        ui.error(`self gate failed: ${error instanceof Error ? error.message : String(error)}`);
+        return 1;
+      }
+    };
     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, shards: opts.shards === undefined ? undefined : opts.shards === true ? 2 : Number(opts.shards) });
-      console.log(result.lines.join('\n'));
-      process.exitCode = result.exitCode;
+      const { dispatchHeavyCheck } = await import('./self-implement/gate-remote.js');
+      const { execFileSync } = await import('node:child_process');
+      const repo = execFileSync('git', ['rev-parse', '--show-toplevel'], { encoding: 'utf8' }).trim();
+      // Only a committed --base range is reproducible on another host: the default mode measures uncommitted files, --pr
+      // reads files through gh on this host, and the remote checkout runs from the repository root — those stay local.
+      const { realpathSync } = await import('node:fs');
+      const localOnlyReason = opts.pr ? 'self gate --pr reads PR files through gh on this host'
+        : !opts.base ? 'self gate without --base measures uncommitted files on this host'
+        : realpathSync(repo) !== realpathSync(process.cwd()) ? 'self gate run from a sub-directory' : undefined;
+      // origin/main is pinned to this machine's origin/main on the host; any other base is passed as its resolved sha.
+      const remoteArgv = (sha: (ref: string) => string) => ['bun', 'bin/elanous.mjs', 'self', 'gate', '--local', ...(opts.changed ? ['--changed'] : []),
+        ...(opts.base ? ['--base', opts.base === 'origin/main' ? opts.base : sha(opts.base)] : []), ...(shards !== undefined ? ['--shards', String(shards)] : [])];
+      process.exitCode = await dispatchHeavyCheck({
+        tool: 'self-gate', repo, installPwa: true, remoteArgv, refs: opts.base ? [opts.base] : [],
+        localOnlyReason,
+        flags: { remote: typeof opts.remote === 'string' ? opts.remote : opts.remote ? true : undefined, local: !!opts.local },
+        runLocal,
+      });
     } catch (error) {
-      ui.error(`self gate failed: ${error instanceof Error ? error.message : String(error)}`);
-      process.exitCode = 1;
+      ui.error(`self gate dispatch failed: ${error instanceof Error ? error.message : String(error)}`);
+      process.exitCode = runLocal();
     }
   });
 
@@ -5866,6 +5999,7 @@ program
   });
 
 registerScheduleCommands(program);
+registerGuardianCommands(program);
 
 /** `elanous decide*` 공통 — 보낼 곳과 자격을 정한다(설정 decide.endpoint > ELANOUS_JEV_ENDPOINT > Typesafe). 없으면 안내하고 rc 2. */
 async function loadJevAccessOrExit(): Promise<import('./decide/jev.js').JevAccess> {
@@ -7060,7 +7194,7 @@ const selfDevCmd = program
             const members = parsePodPool(devAskSubstrate.pool!);
             const host = podPoolHostLease(members);
             while (!authoringLease) {
-              const status = recommendConcurrency(measurePoolLease(members), { capacity: members.reduce((n, m) => n + m.capacity, 0), accounts: 0, perAccount: 0 });
+              const status = recommendConcurrency(measurePoolLease(members, { measureUsage: true }), { capacity: members.reduce((n, m) => n + m.capacity, 0), accounts: 0, perAccount: 0 });
               if (status.recommended !== null && status.recommended > 0) {
                 const { leaseHasPendingPod } = await import('./pod-lease/host-lease.js');
                 const pendingJobs = status.pendingJobs ?? [];
@@ -7215,7 +7349,23 @@ const selfDevCmd = program
         if (hasExplicitReviewerContext && loaded.failed.length > 0) throw new DevPipelineError(contextStatus);
         if (loaded.items.length > 0) spec = { ...spec, reviewerContext: loaded.items };
       }
-      if (devOpts.worktree === true) {
+      // ⭐ TUI-ONE-WORD-LAUNCH — 명시 격리 우주에서 `--cwd`·`--worktree` 둘 다 없으면 «자동» 갈래로
+      //    같은 `prepareDevWorktree` 를 탄다(새 생성 경로 없음). 명시 `--cwd` 는 그대로 이긴다.
+      const autoWorktreeDecision = await (async () => {
+        if (!devOpts.elanous || devOpts.worktree === true || devOpts.cwd !== undefined) {
+          return devCli.decideAutoWorktree({ explicitlyIsolated: false, ...devOpts });
+        }
+        const [{ resolveCurrentInstance }, { isExplicitlyIsolated }] = await Promise.all([
+          import('./instance/current.js'),
+          import('./cli/pty-drive-cli.js'),
+        ]);
+        return devCli.decideAutoWorktree({
+          explicitlyIsolated: isExplicitlyIsolated(resolveCurrentInstance(), devOpts.isolatedRoot),
+          ...devOpts,
+        });
+      })();
+      debug.log('dev-pipeline', 'auto-worktree-decision', { runId: devRunId, decision: autoWorktreeDecision });
+      if (autoWorktreeDecision === 'requested' || autoWorktreeDecision === 'auto') {
         const { prepareDevWorktree, renderPreparedDevWorktree } = await import('./harness/harness-worktree-auto.js');
         const goal = 'file' in input
           ? await (async () => {
@@ -7225,13 +7375,25 @@ const selfDevCmd = program
               return { id: goalId, file: input.file };
             })()
           : undefined;
-        const prepared = prepareDevWorktree(process.cwd(), devRunId, invokedAsDrive ? 'drive' : 'dev', goal);
+        const prepared = (() => {
+          try {
+            return prepareDevWorktree(process.cwd(), devRunId, invokedAsDrive ? 'drive' : 'dev', goal);
+          } catch (error) {
+            if (autoWorktreeDecision !== 'auto') throw error;
+            debug.log('dev-pipeline', 'auto-worktree-failed', { runId: devRunId, cwd: process.cwd(), msg: error instanceof Error ? error.message : String(error) }, { level: 'warn' });
+            throw new DevPipelineError(devCli.formatAutoWorktreeFailure(error));
+          }
+        })();
         preparedWorktree = prepared;
         if (spec.elanous) spec = { ...spec, elanous: { ...spec.elanous, cwd: prepared.worktree.path } };
         else if (spec.drive) spec = { ...spec, drive: { ...spec.drive, cwd: prepared.worktree.path } };
         else throw new DevPipelineError('--worktree 는 elanous 또는 셸 drive child에만 유효');
         if (!opts.json) console.log(renderPreparedDevWorktree(prepared).join('\n'));
         debug.log('dev-pipeline', 'auto-worktree-prepared', { runId: devRunId, ...prepared.environment, worktree: prepared.worktree });
+        if (autoWorktreeDecision === 'auto') {
+          if (!opts.json) console.log(devCli.formatAutoWorktreeNotice(prepared.worktree.path));
+          debug.log('dev-pipeline', 'auto-worktree-implied', { runId: devRunId, worktree: prepared.worktree.path });
+        }
       }
       // ⛔ 종전의 `const plan = planDevPipeline(spec)` 를 지운다(무인 리뷰 must-fix) — 쓰이지 않는
       //    데다 **잔여 조회보다 먼저 던질 수 있어** 관측 자체를 건너뛰게 만든다. 계획은 어차피
@@ -8599,10 +8761,15 @@ program
     }
     if (opts.tools) announceChatToolsCompatibility();
     const cfg = getUserConfig();
-    if (needsOnboarding(cfg)) {
-      if (cfg.onboarding.webFirst === false) ui.info('No config yet — launching setup wizard first.');
-      if (!await runFirstSetupForCli(cfg, true)) return;
-    }
+    if (await firstChatGate(cfg, {
+      isTTY: process.stdin.isTTY === true,
+      runFirstRun: async (deps) => (await import('./onboarding/first-run.js')).runFirstRun(deps),
+      runInteractive: () => {
+        if (cfg.onboarding.webFirst === false) ui.info('No config yet — launching setup wizard first.');
+        return runFirstSetupForCli(cfg, true);
+      },
+      print: (line) => console.log(line),
+    }) === 'stop') return;
     const refreshed = reloadUserConfig();
     // ★ 관측갭 수리(2026-07-21·제1원칙·트랙A) — self-implement 자식 goal-loop(`chat --goal-loop`)은 데몬과
     //   별개 독립 프로세스라 nexus StoreSink 를 상속 안 한다. 부모 `self implement`(위 self 커맨드)는 sink 를

package/src/instance/test-write-guard-spy-first.fixture.ts

@@ -0,0 +1,13 @@
+// Child fixture for test-write-guard.test.ts: a bare spy installed BEFORE outbound-alert is imported must not
+// make the captured «real» curl look like a fake. Prints {refused, curlCalls}.
+import { spyOn } from 'bun:test';
+import * as childProcess from 'node:child_process';
+
+const bare = spyOn(childProcess, 'execFileSync');
+const { sendTelegramDirect } = await import('../domains/outbound-alert.js');
+const { getUserConfig } = await import('../user-config.js');
+const base = getUserConfig();
+const config = { ...base, telegram: { ...base.telegram, channels: undefined, botToken: '2:fake', homeChannel: 2 } } as typeof base;
+let refused = '';
+try { sendTelegramDirect('private-alert-body', 'ops-alert', { config }); } catch (e) { refused = e instanceof Error ? e.name : String(e); }
+console.log(JSON.stringify({ refused, curlCalls: bare.mock.calls.length }));

package/src/instance/test-write-guard.ts

@@ -0,0 +1,200 @@
+// Last line of defense: a test process never writes ops state or sends real alerts, even without the test preload.
+// 10-07 incident: the public-export tree ran `bun test` without bunfig.toml (#24629), so tests wrote the ops deferred
+// queue, ops logs.db and sent real Telegram messages. This guard does not depend on the preload or on HOME.
+import { lstatSync, readFileSync, readlinkSync } from 'node:fs';
+import { homedir, userInfo } from 'node:os';
+import { delimiter, dirname, isAbsolute, join, relative, resolve, sep } from 'node:path';
+import { debug } from '../debug/log.js';
+
+export class TestOpsWriteRefusedError extends Error {
+  constructor(what: string, path: string, signal: string) {
+    super(`[test-guard] refused: a test process (${signal}) tried to ${what} in the operational root (${path}). `
+      + 'Point the test at an isolated root (ELANOUS_STATE_DIR / --config-dir tmp) or inject a fake sender.');
+    this.name = 'TestOpsWriteRefusedError';
+  }
+}
+
+const TEST_FILE = /\.(test|spec)\.[cm]?[jt]sx?$/;
+
+/** Which signal marks this process as a test, or null for a real run.
+ *  Measured under bun 1.4.2: `bun test` sets NODE_ENV=test unless the caller set another value, and `Bun.main` is the
+ *  running test file (argv carries no «test» word). ELANOUS_TEST_HOME is set by the deterministic runner and inherited
+ *  by children it spawns. A real CLI/daemon has none of the three. */
+export function testProcessSignal(env: NodeJS.ProcessEnv = process.env, main: string | undefined = bunMain()): string | null {
+  if (env.NODE_ENV === 'test') return 'NODE_ENV=test';
+  if (env.ELANOUS_TEST_HOME?.trim()) return 'ELANOUS_TEST_HOME';
+  if (main && TEST_FILE.test(main)) return 'Bun.main=test-file';
+  return null;
+}
+
+function isTestProcess(): boolean { return testProcessSignal() !== null; }
+
+function bunMain(): string | undefined {
+  try { return (globalThis as { Bun?: { main?: string } }).Bun?.main; } catch { return undefined; }
+}
+
+/** Real path of `path` with the kernel's lookup order: components left to right, each symlink (live or dangling)
+ *  expanded before a later `..` applies — `alias/../x` with `alias → ops/child` is `ops/x`. Missing tails are kept. */
+export function physicalPath(path: string): string {
+  const pending = (isAbsolute(path) ? path : `${process.cwd()}/${path}`).split('/').filter(Boolean);
+  let current = '/';
+  let links = 0;
+  while (pending.length) {
+    const part = pending.shift()!;
+    if (part === '.') continue;
+    if (part === '..') { current = dirname(current); continue; }
+    const next = current === '/' ? `/${part}` : `${current}/${part}`;
+    let target: string | null = null;
+    try { if (lstatSync(next).isSymbolicLink()) target = readlinkSync(next); } catch { /* missing: keep the name */ }
+    if (target !== null && links++ < 40) {
+      pending.unshift(...target.split('/').filter(Boolean));
+      if (isAbsolute(target)) current = '/';
+      continue;
+    }
+    current = next;
+  }
+  return current;
+}
+
+type SpawnSync = (cmd: string[]) => { exitCode: number; stdout: { toString(): string } };
+
+/** The OS account's home from the account database, not HOME — test runners redirect HOME. Null when unresolvable. */
+function lookupAccountHome(): string | null {
+  try {
+    const spawnSync = (globalThis as { Bun?: { spawnSync: SpawnSync } }).Bun?.spawnSync;
+    const user = userInfo().username;
+    const uid = process.getuid?.();
+    const valid = (home: string | undefined): string | null => (home && isAbsolute(home) ? home : null);
+    if (process.platform === 'darwin' && spawnSync) {
+      const r = spawnSync(['/usr/bin/dscl', '.', '-read', `/Users/${user}`, 'NFSHomeDirectory']);
+      const home = valid(r.exitCode === 0 ? r.stdout.toString().trim().split(/\s+/).at(-1) : undefined);
+      if (home) return home;
+    }
+    if (process.platform !== 'darwin' && uid !== undefined) {
+      try {
+        const home = valid(readFileSync('/etc/passwd', 'utf8').split('\n')
+          .map((line) => line.split(':')).find((f) => Number(f[2]) === uid)?.[5]);
+        if (home) return home;
+      } catch { /* try getent */ }
+      if (spawnSync) {
+        const r = spawnSync(['getent', 'passwd', String(uid)]);
+        const home = valid(r.exitCode === 0 ? r.stdout.toString().trim().split(':')[5] : undefined);
+        if (home) return home;
+      }
+    }
+  } catch { /* unresolvable */ }
+  return null;
+}
+
+let accountHomeLookup: () => string | null = lookupAccountHome;
+let opsRootsOverride: string[] | null = null; // added roots, never a replacement
+let cachedOpsRoots: string[] | null = null;
+
+/** Tests add «ops-like» roots to prove the refusal; the real account root stays protected. null clears them. */
+export function setOpsRootsForTesting(roots: string[] | null): void { opsRootsOverride = roots ? roots.map(physicalPath) : null; }
+
+/** Tests inject a failing account lookup to prove the fallback; null restores the real one. Clears the cache. */
+export function setAccountHomeLookupForTesting(lookup: (() => string | null) | null): void {
+  accountHomeLookup = lookup ?? lookupAccountHome;
+  cachedOpsRoots = null;
+  accountHomeUnresolved = false;
+}
+
+/** The operational instance root(s) the guard protects — the account's real `~/.elanous`.
+ *  When the account database cannot be read, fail toward protection: every conventional home of this user plus HOME. */
+export function opsRoots(): string[] {
+  // Widening only: injected roots and the env list add to the real account root; nothing can remove it.
+  const extra = (process.env[EXTRA_OPS_ROOTS_ENV] ?? '').split(delimiter).filter((p) => isAbsolute(p)).map(physicalPath);
+  const added = [...(opsRootsOverride ?? []), ...extra];
+  return added.length ? [...new Set([...accountOpsRoots(), ...added])] : accountOpsRoots();
+}
+
+/** Extra roots the guard protects in this process (path-delimited). Used to prove the guard in a real child entry. */
+export const EXTRA_OPS_ROOTS_ENV = 'ELANOUS_TEST_GUARD_EXTRA_OPS_ROOTS';
+
+function accountOpsRoots(): string[] {
+  if (cachedOpsRoots) return cachedOpsRoots;
+  const home = accountHomeLookup();
+  let homes: string[];
+  if (home) homes = [home];
+  else {
+    let user = '';
+    try { user = userInfo().username; } catch { /* unknown user */ }
+    homes = [...(user ? [`/Users/${user}`, `/home/${user}`] : []), ...(process.getuid?.() === 0 ? ['/root'] : []), homedir()];
+    try { debug.log('test-guard', 'account-home-unresolved', { protected: homes.length }); } catch { /* observation only */ }
+  }
+  accountHomeUnresolved = !home;
+  cachedOpsRoots = [...new Set(homes.map((h) => physicalPath(join(h, '.elanous'))))];
+  return cachedOpsRoots;
+}
+
+let accountHomeUnresolved = false;
+
+export function isInsideOpsRoot(path: string, roots: string[] = opsRoots()): boolean {
+  const target = physicalPath(path);
+  // Unknown account home (non-standard, unreadable): any `<dir>/.elanous` tree may be the ops root — protect them all.
+  // Isolated test roots are temp dirs or `<root>/state`, never a directory named `.elanous` under a home.
+  // Both spellings: a `.elanous` that is itself a symlink to an oddly named directory is still that tree.
+  if (accountHomeUnresolved && [resolve(path), target].some((p) => p.split(sep).includes('.elanous'))) return true;
+  return roots.some((root) => {
+    const rel = relative(root, target);
+    return rel === '' || (rel !== '..' && !rel.startsWith(`..${sep}`) && !isAbsolute(rel));
+  });
+}
+
+function refuse(what: string, path: string, signal: string): never {
+  try { debug.log('test-guard', 'ops-write-refused', { what, path, signal }); } catch { /* the refusal stands */ }
+  throw new TestOpsWriteRefusedError(what, path, signal);
+}
+
+/** Throw when a test process is about to write `path` inside the operational root. No-op in real runs. */
+export function assertNotTestWritingOps(path: string, what: string): void {
+  const signal = testProcessSignal();
+  if (!signal) return;
+  if (path === ':memory:' || !isInsideOpsRoot(path)) return;
+  refuse(what, path, signal);
+}
+
+/** Throw when a test process is about to perform a network send it must not make.
+ *  - Routing (config dir · state root · conatus dir · acp-token dir) inside the ops root: always refused, faked or
+ *    not — a test that resolved the ops universe is the leak itself, whatever its transport does.
+ *  - `external` (a third-party bot API — Telegram, Discord): refused unless the transport is a test double that
+ *    replaces the real one (`transportFaked`), whatever root the credentials came from. A double that deliberately
+ *    calls the original is an explicit choice to send and is out of this guard's reach. */
+export function assertNoRealSendFromTest(what: string, opts: {
+  transportFaked: boolean; routingRoots: string[]; external?: boolean;
+}): void {
+  const signal = testProcessSignal();
+  if (!signal) return;
+  const opsRoot = opts.routingRoots.find((root) => root && isInsideOpsRoot(root));
+  if (opsRoot) refuse(what, opsRoot, signal);
+  if (opts.external && !opts.transportFaked) refuse(what, 'a real third-party bot API', signal);
+}
+
+/** True when `fn` is a bun:test/jest double whose behaviour replaces `real`. A bare `spyOn` keeps calling the
+ *  original (its implementation IS `real`), so it is not a fake. */
+export function isTestDouble(fn: unknown, real?: unknown): boolean {
+  if (!isMockFn(fn)) return false;
+  const impl = fn.getMockImplementation?.();
+  return real === undefined || impl !== unwrapMock(real);
+}
+
+type MockFn = { mock: object; getMockImplementation?: () => unknown };
+function isMockFn(fn: unknown): fn is MockFn {
+  return typeof fn === 'function' && typeof (fn as { mock?: unknown }).mock === 'object' && (fn as { mock?: unknown }).mock !== null;
+}
+
+/** The function under a chain of spies — a «real» captured after a bare spy was installed is the spy itself.
+ *  Unwrapping a fake yields the fake, so a capture taken under a fake refuses rather than allows. */
+function unwrapMock(fn: unknown): unknown {
+  let current = fn;
+  for (let i = 0; i < 8 && isMockFn(current); i++) {
+    const impl: unknown = current.getMockImplementation?.();
+    if (typeof impl !== 'function' || impl === (current as unknown)) break;
+    current = impl;
+  }
+  return current;
+}
+
+// Resolve the account home while no test has mocked anything yet; real runs never pay the lookup.
+try { if (typeof process !== 'undefined' && isTestProcess()) opsRoots(); } catch { /* resolved lazily */ }

package/src/intake-plane/adopt-gate.ts

@@ -0,0 +1,49 @@
+import { debug } from '../debug/log.js';
+
+export interface AdoptionCandidate {
+  readonly id: string;
+  readonly grade: 'P1' | 'P2' | 'P3' | 'P4';
+  readonly risk: number;
+  readonly money: number;
+  readonly security: number;
+  readonly license: string | null;
+  readonly touchesPatentCandidate: boolean;
+}
+
+export type AdoptShadowReason = 'grade' | 'risk' | 'money' | 'security' | 'license' | 'patent' | 'daily-cap';
+
+export interface AdoptShadowVerdict {
+  readonly id: string;
+  readonly adopt: boolean;
+  readonly reasons: readonly AdoptShadowReason[];
+}
+
+const ALLOWED_LICENSES: ReadonlySet<string> = new Set([
+  'MIT', 'Apache-2.0', 'BSD-2-Clause', 'BSD-3-Clause', 'ISC', 'MPL-2.0',
+]);
+
+export function judgeAdoption(candidate: AdoptionCandidate, adoptedToday: number): AdoptShadowVerdict {
+  const reasons: AdoptShadowReason[] = [];
+  if (candidate.grade !== 'P1' && candidate.grade !== 'P2') reasons.push('grade');
+  if (!(candidate.risk <= 1)) reasons.push('risk');
+  if (candidate.money !== 0) reasons.push('money');
+  if (candidate.security !== 0) reasons.push('security');
+  if (candidate.license === null || !ALLOWED_LICENSES.has(candidate.license)) reasons.push('license');
+  if (candidate.touchesPatentCandidate !== false) reasons.push('patent');
+  if (!(adoptedToday < 5)) reasons.push('daily-cap');
+  return { id: candidate.id, adopt: reasons.length === 0, reasons };
+}
+
+export function shadowAdopt(candidates: readonly AdoptionCandidate[]): AdoptShadowVerdict[] {
+  const verdicts: AdoptShadowVerdict[] = [];
+  let adoptedToday = 0;
+  for (const candidate of candidates) {
+    const verdict = judgeAdoption(candidate, adoptedToday);
+    if (verdict.adopt) adoptedToday++;
+    verdicts.push(verdict);
+    debug.log('intake.adopt', 'shadow-verdict', {
+      id: verdict.id, adopt: verdict.adopt, reasons: verdict.reasons,
+    });
+  }
+  return verdicts;
+}

package/src/intake-plane/check.ts

@@ -21,6 +21,7 @@ import { parse as parseYaml } from 'yaml';
 import { debug } from '../debug/log.js';
 import { openSurfaceEventsDb, recallEvents } from '../domains/surface-events.js';
 import { extractJsonBlock, skeletonFallback } from './decompose.js';
+import type { AdoptShadowVerdict } from './adopt-gate.js';
 
 export const INTAKE_CHECK_MODE = 'check' as const;
 
@@ -110,6 +111,7 @@ export interface IntakeCheckReport {
   /** 비교·시너지 제안 수(근거 없음 포함). */
   readonly proposalCount?: number;
   readonly proposals?: readonly IntakeCompareProposal[];
+  readonly adoptShadow?: readonly AdoptShadowVerdict[];
 }
 
 /** 선가공 렌즈 여섯. 🅞 원장 · PR #20009. */
@@ -1826,6 +1828,7 @@ export function intakeCheckReportJson(report: IntakeCheckReport): Record<string,
       proposalCount: report.proposalCount,
       proposals: report.proposals,
     } : {}),
+    ...(report.adoptShadow !== undefined ? { adoptShadow: report.adoptShadow } : {}),
   };
 }