elanous 0.2.4 → 0.2.6

package/src/auth/acp-token.ts

@@ -0,0 +1,16 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { generateAuthToken } from '../acp/transport/index.js';
+import { getElanousConfigDir } from '../elanous-config-dir.js';
+
+/** Load the persistent ACP bearer token, creating it on first boot. */
+export function ensureAuthToken(configDir: string = getElanousConfigDir()): { token: string; path: string } {
+  const path = join(configDir, 'acp-token');
+  mkdirSync(configDir, { recursive: true });
+  if (existsSync(path)) {
+    return { token: readFileSync(path, 'utf-8').trim(), path };
+  }
+  const token = generateAuthToken();
+  writeFileSync(path, token, { mode: 0o600 });
+  return { token, path };
+}

package/src/auth/github-app-token.ts

@@ -0,0 +1,112 @@
+import { createHash, createSign } from 'node:crypto';
+import { spawnSync } from 'node:child_process';
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, isAbsolute, join } from 'node:path';
+import { getElanousConfigDir, getElanousConfigDirOverride } from '../elanous-config-dir.js';
+import { prodInstanceRoot } from '../instance/resolve.js';
+import { debug } from '../debug/log.js';
+
+interface AppConfig { id: number; installation_id: number; pem: string }
+interface TokenResponse { token?: unknown; expires_at?: unknown }
+export interface GithubInstallationTokenScope { repository: string }
+interface InstallationTokenRequest {
+  repositories: [string];
+  permissions: { contents: 'write'; pull_requests: 'write' };
+}
+
+/** Synchronous HTTP seam: CmdRunner must remain synchronous for existing callers. */
+export interface GithubAutomationTokenDeps {
+  configPath?: string;
+  now?: () => number;
+  scope?: GithubInstallationTokenScope;
+  fetch?: (url: string, jwt: string, body?: InstallationTokenRequest) => TokenResponse;
+}
+
+const REFRESH_MARGIN_MS = 10 * 60_000;
+const JWT_LIFETIME_SECONDS = 9 * 60;
+let cached: { fingerprint: string; token: string; expiresAt: number } | undefined;
+
+function requestToken(url: string, jwt: string, body?: InstallationTokenRequest): TokenResponse {
+  const response = spawnSync('curl', [
+    '--silent', '--show-error', '--fail', '--max-time', '30', '--request', 'POST',
+    '--header', 'Accept: application/vnd.github+json',
+    '--header', '@-',
+    '--header', 'X-GitHub-Api-Version: 2022-11-28',
+    ...(body ? ['--header', 'Content-Type: application/json', '--data-raw', JSON.stringify(body)] : []),
+    url,
+  ], { encoding: 'utf8', timeout: 35_000, input: `Authorization: Bearer ${jwt}\n`, env: process.env });
+  // Never expose curl's stderr: it may contain request credentials.
+  if (response.error || response.status !== 0) throw new Error('http-failed');
+  return JSON.parse(response.stdout) as TokenResponse;
+}
+
+/** Missing App config is a no-op; an unusable configured App falls back to the caller's gh credentials. */
+export function githubAutomationToken(deps: GithubAutomationTokenDeps = {}): string | null {
+  return githubInstallationCredential(deps)?.token ?? null;
+}
+
+/** Scoped requests always mint anew; the returned expiry comes from GitHub's response. */
+export function githubInstallationCredential(deps: GithubAutomationTokenDeps = {}): { token: string; expires_at: string } | null {
+  let path: string;
+  // The App credential is machine-level (like `gh auth` in ~/.config/gh), not per universe: a tree-derived test
+  // universe resolves its config dir to `<tree>/.elanous-test`, where the file never is — 09-29 #21879 was inert there.
+  // Order: explicit path → this universe's config dir → the prod root `~/.elanous`.
+  try {
+    const rel = join('secrets', 'github-app', 'app.json');
+    const own = join(getElanousConfigDir(), rel);
+    // An explicit config-dir override (tests · `--config-dir`) is a deliberate boundary — never reach past it.
+    path = deps.configPath ?? (existsSync(own) || getElanousConfigDirOverride() ? own : join(prodInstanceRoot(), rel));
+  }
+  catch {
+    try { debug.log('auth.github-app', 'token-failed', { reason: 'config-path-failed' }); } catch { /* fail open */ }
+    return null;
+  }
+  let configText: string;
+  try { configText = readFileSync(path, 'utf8'); }
+  catch (error) {
+    cached = undefined;
+    if ((error as NodeJS.ErrnoException).code === 'ENOENT') return null;
+    try { debug.log('auth.github-app', 'token-failed', { reason: 'config-read-failed' }); } catch { /* fail open */ }
+    return null;
+  }
+  try {
+    const now = (deps.now ?? Date.now)();
+    const config = JSON.parse(configText) as AppConfig;
+    if (!config || !Number.isSafeInteger(config.id) || config.id <= 0 ||
+        !Number.isSafeInteger(config.installation_id) || config.installation_id <= 0 ||
+        typeof config.pem !== 'string' || !config.pem) throw new Error('invalid-config');
+    const pem = isAbsolute(config.pem) ? readFileSync(config.pem, 'utf8')
+      : config.pem.includes('-----BEGIN') ? config.pem
+      : readFileSync(join(dirname(path), config.pem), 'utf8');
+    const repository = deps.scope?.repository;
+    if (deps.scope && (typeof repository !== 'string' || !/^[a-zA-Z0-9_.-]+$/.test(repository) || repository === '.' || repository === '..')) {
+      throw new Error('invalid-repository');
+    }
+    const request: InstallationTokenRequest | undefined = repository
+      ? { repositories: [repository], permissions: { contents: 'write', pull_requests: 'write' } }
+      : undefined;
+    const fingerprint = createHash('sha256').update(JSON.stringify([path, config.id, config.installation_id, pem])).digest('hex');
+    if (!request && cached?.fingerprint === fingerprint && now < cached.expiresAt - REFRESH_MARGIN_MS) return { token: cached.token, expires_at: new Date(cached.expiresAt).toISOString() };
+    if (!request) cached = undefined;
+    const issuedAt = Math.floor(now / 1000) - 60;
+    const encode = (value: object) => Buffer.from(JSON.stringify(value)).toString('base64url');
+    const unsigned = `${encode({ alg: 'RS256', typ: 'JWT' })}.${encode({ iat: issuedAt, exp: issuedAt + JWT_LIFETIME_SECONDS, iss: String(config.id) })}`;
+    const signer = createSign('RSA-SHA256');
+    signer.update(unsigned);
+    const jwt = `${unsigned}.${signer.sign(pem, 'base64url')}`;
+    const url = `https://api.github.com/app/installations/${config.installation_id}/access_tokens`;
+    const response = (deps.fetch ?? requestToken)(url, jwt, request);
+    const expiresAt = typeof response.expires_at === 'string' ? Date.parse(response.expires_at) : NaN;
+    if (typeof response.token !== 'string' || !response.token || !Number.isFinite(expiresAt) ||
+        expiresAt <= now + REFRESH_MARGIN_MS) throw new Error('invalid-response');
+    if (!request) cached = { fingerprint, token: response.token, expiresAt };
+    try { debug.log('auth.github-app', 'token-minted', { installationId: config.installation_id, expiresAt: new Date(expiresAt).toISOString() }); }
+    catch { /* logging must not undo a valid token */ }
+    return { token: response.token, expires_at: response.expires_at as string };
+  } catch {
+    if (!deps.scope) cached = undefined;
+    // Do not log exceptions: crypto/HTTP failures can include key or bearer material.
+    try { debug.log('auth.github-app', 'token-failed', { reason: 'mint-failed' }); } catch { /* fail open */ }
+    return null;
+  }
+}

package/src/autopilot/gh-rest-fallback.ts

@@ -0,0 +1,177 @@
+import { debug } from '../debug/log.js';
+import type { CmdResult, CmdRunner } from './pr-manager.js';
+
+type Pull = Record<string, unknown>;
+
+function flag(args: readonly string[], name: string): string | undefined {
+  const index = args.indexOf(name);
+  return index >= 0 ? args[index + 1] : undefined;
+}
+
+function hasOnlyFlags(args: readonly string[], start: number, valued: readonly string[], bare: readonly string[] = []): boolean {
+  for (let i = start; i < args.length; i++) {
+    if (bare.includes(args[i]!)) continue;
+    if (!valued.includes(args[i]!) || args[++i] === undefined) return false;
+  }
+  return true;
+}
+
+function repoFromOrigin(run: CmdRunner, opts?: { cwd?: string }): { owner: string; repo: string } | null {
+  const remote = run('git', ['remote', 'get-url', 'origin'], opts);
+  if (!remote.ok) return null;
+  const value = remote.out.trim();
+  let path: string;
+  try {
+    const url = new URL(value);
+    if (!['https:', 'ssh:'].includes(url.protocol) || url.hostname.toLowerCase() !== 'github.com') return null;
+    path = url.pathname;
+  } catch {
+    const scp = /^(?:[^@/]+@)?github\.com:([^\s]+)$/.exec(value);
+    if (!scp) return null;
+    path = scp[1]!;
+  }
+  const match = /^\/?([\w.-]+)\/([\w.-]+?)(?:\.git)?\/?$/.exec(path);
+  return match ? { owner: match[1]!, repo: match[2]! } : null;
+}
+
+function prNumber(value: string, owner: string, repo: string): string | null {
+  if (/^[1-9]\d*$/.test(value)) return value;
+  const match = /^https:\/\/github\.com\/([^/]+)\/([^/]+)\/pull\/([1-9]\d*)\/?$/.exec(value);
+  return match && match[1] === owner && match[2] === repo ? match[3]! : null;
+}
+
+function readPull(result: CmdResult): Pull | null {
+  if (!result.ok) return null;
+  try {
+    const value: unknown = JSON.parse(result.out);
+    return value && typeof value === 'object' && !Array.isArray(value) ? value as Pull : null;
+  } catch { return null; }
+}
+
+function pullField(pull: Pull, field: string): unknown {
+  switch (field) {
+    case 'state': return pull.merged_at ? 'MERGED' : pull.state === 'open' ? 'OPEN' : pull.state === 'closed' && pull.merged_at === null ? 'CLOSED' : undefined;
+    case 'isDraft': return pull.draft;
+    case 'baseRefName': return (pull.base as Pull | undefined)?.ref;
+    case 'headRefName': return (pull.head as Pull | undefined)?.ref;
+    case 'headRepository': {
+      const nameWithOwner = ((pull.head as Pull | undefined)?.repo as Pull | undefined)?.full_name;
+      return typeof nameWithOwner === 'string' ? { nameWithOwner } : undefined;
+    }
+    case 'mergeable': return pull.mergeable === true ? 'MERGEABLE' : pull.mergeable === false ? 'CONFLICTING' : pull.mergeable === null ? 'UNKNOWN' : undefined;
+    case 'mergeStateStatus': {
+      const state = pull.mergeable_state;
+      return typeof state === 'string' && ['behind', 'blocked', 'clean', 'dirty', 'draft', 'has_hooks', 'unknown', 'unstable'].includes(state)
+        ? state.toUpperCase() : undefined;
+    }
+    default: return undefined;
+  }
+}
+
+function restCall(run: CmdRunner, args: string[], opts?: { cwd?: string }): CmdResult {
+  return run('gh', ['api', ...args], opts);
+}
+
+/** Retry exactly once via REST after the secondary GraphQL limit; unsupported shapes fail closed. */
+export function withGhRestFallback(run: CmdRunner): CmdRunner {
+  return (cmd, args, opts) => {
+    const original = run(cmd, args, opts);
+    if (cmd !== 'gh' || args[0] !== 'pr' || original.ok ||
+        !/GraphQL/i.test(`${original.out}\n${original.err ?? ''}`) ||
+        !/API rate limit/i.test(`${original.out}\n${original.err ?? ''}`)) return original;
+    const sub = args[1];
+    if (!['list', 'view', 'create', 'edit', 'merge', 'comment'].includes(sub ?? '')) return original;
+    if (sub === 'list' && !args.includes('--json')) return original;
+    const location = repoFromOrigin(run, opts);
+    if (!location) return original;
+    const { owner, repo } = location;
+    const path = `repos/${owner}/${repo}`;
+    let result: CmdResult | null = null;
+
+    if (sub === 'list' && args[2] === '--head' && args[3] && args[4] === '--state' && args[5] === 'open' &&
+        args[6] === '--json' && args[7] === 'url' &&
+        (args.length === 8 || (args.length === 10 && args[8] === '--jq' && args[9] === '.[0].url // ""'))) {
+      const listed = restCall(run, [`${path}/pulls?head=${encodeURIComponent(`${owner}:${args[3]}`)}&state=open`], opts);
+      if (listed.ok) {
+        try {
+          const items: unknown = JSON.parse(listed.out);
+          if (Array.isArray(items) && items.every((item) => item && typeof item.html_url === 'string')) {
+            const urls = items.map((item) => ({ url: item.html_url as string }));
+            result = { ok: true, out: args[8] === '--jq' ? (urls[0]?.url ?? '') : JSON.stringify(urls) };
+          }
+        } catch { /* malformed REST response */ }
+      } else result = listed;
+    } else if (sub === 'view' && args[2] && args[3] === '--json' && args[4] &&
+        hasOnlyFlags(args, 5, ['--jq', '-q'])) {
+      const number = prNumber(args[2], owner, repo);
+      const fields = args[4].split(',');
+      const jq = flag(args, '--jq') ?? flag(args, '-q');
+      if (number && fields.every((field) => ['state', 'isDraft', 'mergeable', 'baseRefName', 'mergeStateStatus', 'headRefName', 'headRepository'].includes(field)) &&
+          (!jq || (fields.length === 1 && jq === `.${fields[0]}`))) {
+        const response = restCall(run, [`${path}/pulls/${number}`], opts);
+        const pull = readPull(response);
+        if (pull) {
+          const mapped = Object.fromEntries(fields.map((field) => [field, pullField(pull, field)]));
+          if (Object.values(mapped).every((value) => value !== undefined)) {
+            const selected = mapped[fields[0]!];
+            result = { ok: true, out: jq
+              ? typeof selected === 'string' ? selected : JSON.stringify(selected)
+              : JSON.stringify(mapped) };
+          }
+        } else if (!response.ok) result = response;
+      }
+    } else if (sub === 'create' && hasOnlyFlags(args, 2, ['--head', '--title', '--body', '--base'], ['--draft']) &&
+        flag(args, '--head') && flag(args, '--title') !== undefined && flag(args, '--body') !== undefined) {
+      let base = flag(args, '--base');
+      if (!base) {
+        const repository = restCall(run, [path], opts);
+        if (!repository.ok) result = repository;
+        else {
+          const defaultBranch = readPull(repository)?.default_branch;
+          if (typeof defaultBranch === 'string' && defaultBranch) base = defaultBranch;
+        }
+      }
+      if (base) {
+        const parameters = ['-f', `head=${flag(args, '--head')}`, '-f', `title=${flag(args, '--title')}`, '-f', `body=${flag(args, '--body')}`, '-f', `base=${base}`];
+        if (args.includes('--draft')) parameters.push('-F', 'draft=true');
+        const response = restCall(run, ['--method', 'POST', `${path}/pulls`, ...parameters], opts);
+        const pull = readPull(response);
+        if (pull && typeof pull.html_url === 'string') result = { ok: true, out: pull.html_url };
+        else if (!response.ok) result = response;
+      }
+    } else if (sub === 'edit' && args[2] && hasOnlyFlags(args, 3, ['--title', '--body', '--base']) &&
+        flag(args, '--title') !== undefined && flag(args, '--body') !== undefined) {
+      const number = prNumber(args[2], owner, repo);
+      if (number) {
+        const parameters = ['-f', `title=${flag(args, '--title')}`, '-f', `body=${flag(args, '--body')}`];
+        if (flag(args, '--base')) parameters.push('-f', `base=${flag(args, '--base')}`);
+        const response = restCall(run, ['--method', 'PATCH', `${path}/pulls/${number}`, ...parameters], opts);
+        if (readPull(response)) result = { ok: true, out: '' };
+        else if (!response.ok) result = response;
+      }
+    } else if (sub === 'merge' && args[2] && args[3] === '--squash' && args.length === 4) {
+      const number = prNumber(args[2], owner, repo);
+      if (number) {
+        const head = restCall(run, [`${path}/pulls/${number}`], opts);
+        const sha = (readPull(head)?.head as Pull | undefined)?.sha;
+        if (typeof sha === 'string' && /^[a-f0-9]{40}$/.test(sha)) {
+          const response = restCall(run, ['--method', 'PUT', `${path}/pulls/${number}/merge`, '-f', 'merge_method=squash', '-f', `sha=${sha}`], opts);
+          const body = readPull(response);
+          if (body?.merged === true) result = { ok: true, out: '' };
+          else if (!response.ok) result = response;
+        } else if (!head.ok) result = head;
+      }
+    } else if (sub === 'comment' && args[2] && args[3] === '--body' && args[4] !== undefined && args.length === 5) {
+      const number = prNumber(args[2], owner, repo);
+      if (number) {
+        const response = restCall(run, ['--method', 'POST', `${path}/issues/${number}/comments`, '-f', `body=${args[4]}`], opts);
+        if (readPull(response)) result = { ok: true, out: '' };
+        else if (!response.ok) result = response;
+      }
+    }
+    if (!result) return original;
+    debug.log('autopilot.pr', 'rest-fallback', { sub, ok: result.ok });
+    process.stderr.write(`[gh] REST 폴백: pr ${sub}\n`);
+    return result;
+  };
+}

package/src/autopilot/mission-origin.ts

@@ -13,20 +13,36 @@ import { getUserConfig } from '../user-config.js';
 import { resolveChannelBotToken } from '../channel-bot-token.js';
 import { join } from 'node:path';
 
-export interface MissionOrigin {
-  channel: 'telegram' | 'pwa' | 'voice' | 'cli' | 'api' | 'tui';
+interface MissionOriginBase {
   /** 텔레그램: 답장할 chat id. */
   chatId?: number;
   /** 텔레그램: 수신 봇 식별(botId=토큰 prefix). 발송 시 config 에서 토큰 해석. */
   botId?: string;
-  /** 텔레그램 스레드(포럼) — 있으면 답장에 붙임. */
-  threadId?: number;
   /** HITL 승인/거절 버튼을 단 알림 메시지의 message_id. 크로스서피스 싱크용 —
    *  PWA/텔레그램 어느 쪽에서 해소돼도 이 좌표(chatId+botId+이 id)로 텔레그램 메시지를
    *  edit("승인됨/거절됨")하고 버튼을 제거한다. 버튼 발송 성공 시에만 기록. */
   hitlMessageId?: number;
 }
 
+export type MissionOrigin = MissionOriginBase & (
+  | {
+      channel: 'telegram' | 'pwa' | 'voice' | 'cli' | 'api' | 'tui';
+      /** 텔레그램 스레드(포럼) — 있으면 답장에 붙임. */
+      threadId?: number;
+      channelId?: never;
+    }
+  | {
+      channel: 'discord';
+      /** Discord origin channel (snowflake). */
+      channelId: string;
+      /** Discord thread (snowflake), if the request came from a thread.
+       *  ⛔ `threadId` 가 아니다 — 텔레그램 `threadId?: number` 와 같은 이름이면 유니온에서 `string|number` 로 넓어져
+       *  텔레그램 발송부 20여 곳의 타입이 깨진다(2026-10-01 PWA 빌드 실패 · #22246). */
+      discordThreadId?: string;
+      threadId?: never;
+    }
+);
+
 function originDir(): string {
   // core 미션 fabric = autopilot/ (conatus/ 는 투자 customer 네임스페이스·대표 정정 2026-07-11).
   // [ISO-3] ELANOUS_STATE_DIR 존중 — 격리 테스트 데몬은 운영 origin 을 못 본다.

package/src/autopilot/mission-phase-track.ts

@@ -1,7 +1,17 @@
 import { readFileSync } from 'node:fs';
 import { resolve } from 'node:path';
 
-type TrackEntry = { id: string; mark: string; owns: string[] };
+type TrackEntry = { id: string; mark: string; owns: string[]; alias?: string };
+
+// Seat ids became two letters on 09-30 (#22085) with the old one-letter id kept as `alias`.
+// A track named either way is the same seat — posts and inputs still carry the old letter during the switch.
+export function findTrack(idOrAlias: string, registry: TrackEntry[] = loadTrackRegistry()): TrackEntry | undefined {
+  return registry.find((track) => track.id === idOrAlias || track.alias === idOrAlias);
+}
+export function trackPostIds(idOrAlias: string, registry: TrackEntry[] = loadTrackRegistry()): string[] {
+  const track = findTrack(idOrAlias, registry);
+  return [...new Set([idOrAlias, ...(track ? [track.id, ...(track.alias ? [track.alias] : [])] : [])])];
+}
 
 export function loadTrackRegistry(path = resolve(import.meta.dir, '../../scripts/coord-tracks.json')): TrackEntry[] {
   try {

package/src/autopilot/pr-manager.ts

@@ -9,11 +9,14 @@
 // 구현을 교체(누적 아님). 기존 PR 없으면 새로 생성.
 
 import { spawnSync } from 'node:child_process';
+import { githubAutomationToken } from '../auth/github-app-token.js';
 import { debug } from '../debug/log.js';
+import { POD_GITHUB_CREDENTIAL_TOKEN_ENV, POD_GITHUB_CREDENTIAL_URL_ENV } from '../nexus/api/pod-credential-api.js';
 import { runGitWithRetry } from '../git-fs/retry.js';
 import { DEFAULT_BRANCH_WORKTREE_BASE } from '../git-fs/worktree.js';
 import { isElanousRuntimeArtifactPath } from '../self-implement/gate-scope.js';
 import { isTransientExecutionFailure } from '../self-dev/execution-transient.js';
+import { withGhRestFallback } from './gh-rest-fallback.js';
 
 /** ★ stderr 캡처(대표 2026-07-21·관측 갭) — 종전엔 stdout 만 담아 git/gh 실패 사유가 소실됐다
  *  (705308: makePr 실패가 bare null 로 뭉뚱그려져 triage 가 "인증·네트워크"로 환각 오라우팅).
@@ -22,12 +25,55 @@ export interface CmdResult { ok: boolean; out: string; err?: string }
 /** 명령 실행 추상화(주입형·테스트 스텁) — git/gh 를 실제로 돌리지 않고 로직 검증. */
 export type CmdRunner = (cmd: string, args: readonly string[], opts?: { cwd?: string }) => CmdResult;
 
+const GH_TOKEN_REFRESH_WINDOW_MS = 10 * 60_000;
+let cachedRelayToken: { url: string; bearer: string; original: string | undefined; token: string; expiresAt: number } | undefined;
+
+/** The runner is synchronous; ask the host relay synchronously before starting gh. */
+function relayGhToken(env: NodeJS.ProcessEnv): string | null {
+  const url = env[POD_GITHUB_CREDENTIAL_URL_ENV];
+  const bearer = env[POD_GITHUB_CREDENTIAL_TOKEN_ENV];
+  if (!url || !bearer) return null;
+  const now = Date.now();
+  const original = env.GH_TOKEN;
+  if (cachedRelayToken?.url === url && cachedRelayToken.bearer === bearer && cachedRelayToken.original === original
+    && now + GH_TOKEN_REFRESH_WINDOW_MS < cachedRelayToken.expiresAt) return cachedRelayToken.token;
+  try {
+    const response = spawnSync('curl', [
+      '--silent', '--show-error', '--fail', '--noproxy', '*', '--max-time', '10',
+      '--request', 'POST', '--header', '@-', url,
+    ], { input: `Authorization: Bearer ${bearer}\n`, encoding: 'utf8', timeout: 12_000, maxBuffer: 64 * 1024, env });
+    if (response.error || response.status !== 0) throw new Error('request-failed');
+    const body: unknown = JSON.parse(response.stdout);
+    const token = body && typeof body === 'object' ? (body as { token?: unknown }).token : undefined;
+    const expiry = body && typeof body === 'object' ? (body as { expires_at?: unknown }).expires_at : undefined;
+    const expiresAt = typeof expiry === 'string' ? Date.parse(expiry) : NaN;
+    if (typeof token !== 'string' || !token || !Number.isFinite(expiresAt) || expiresAt <= now + GH_TOKEN_REFRESH_WINDOW_MS) throw new Error('invalid-response');
+    cachedRelayToken = { url, bearer, original, token, expiresAt };
+    return token;
+  } catch {
+    debug.log('pr-manager', 'gh-token', { reason: 'refresh-failed' }, { level: 'warn' });
+    return cachedRelayToken?.url === url && cachedRelayToken.bearer === bearer && cachedRelayToken.original === original
+      && now < cachedRelayToken.expiresAt ? cachedRelayToken.token : null;
+  }
+}
+
+/** Environment for a `gh` call made by automation: the Pod relay token, else the GitHub App token when the
+ *  caller set no GH_TOKEN — so PRs, merges and PR comments all act as the App, not the person logged into `gh`. */
+export function ghAutomationEnv(env: NodeJS.ProcessEnv = process.env, appToken: () => string | null = githubAutomationToken): NodeJS.ProcessEnv {
+  const token = relayGhToken(env) ?? (!Object.hasOwn(env, 'GH_TOKEN') ? appToken() : null);
+  return token ? { ...env, GH_TOKEN: token } : env;
+}
+
 /** 기본 러너 — spawnSync(dep-free). 실패/예외는 ok=false. stdout·stderr 모두 캡처. */
 export const defaultCmdRunner: CmdRunner = (cmd, args, opts) => {
   try {
-    // env: process.env — 최소 PATH(cron)에서도 ensure-bin-path 보강 PATH 로 gh 를 찾도록 명시 전달.
-    const r = spawnSync(cmd, [...args], { encoding: 'utf-8', timeout: 120_000, env: process.env, ...(opts?.cwd ? { cwd: opts.cwd } : {}) });
-    return { ok: r.status === 0, out: (r.stdout ?? '').trim(), err: (r.stderr ?? '').trim() };
+    // Relay only applies to gh; without it, retain caller GH_TOKEN and the existing App fallback.
+    const env = cmd === 'gh' ? ghAutomationEnv(process.env) : process.env;
+    // bun ≥1.4 applies Node's 1MB default maxBuffer and silently truncates (`gh pr diff`, file lists) — raise it and
+    // never read an overflow as success.
+    const r = spawnSync(cmd, [...args], { encoding: 'utf-8', timeout: 120_000, maxBuffer: 256 * 1024 * 1024, env, ...(opts?.cwd ? { cwd: opts.cwd } : {}) });
+    const overflow = (r.error as NodeJS.ErrnoException | undefined)?.code === 'ENOBUFS';
+    return { ok: r.status === 0 && !overflow, out: (r.stdout ?? '').trim(), err: [(r.stderr ?? '').trim(), overflow ? 'output exceeded 256MiB (ENOBUFS)' : ''].filter(Boolean).join('\n') };
   } catch (e) { return { ok: false, out: '', err: e instanceof Error ? e.message : String(e) }; }
 };
 
@@ -259,7 +305,8 @@ function isTransientPushFailure(detail: string): boolean {
 }
 
 /** ★ PR 매니저 팩토리(대표 2026-07-12) — CmdRunner 주입(테스트 스텁). 실 배선은 기본 러너. */
-export function makePrManager(run: CmdRunner = defaultCmdRunner): PrManager {
+export function makePrManager(runner: CmdRunner = defaultCmdRunner): PrManager {
+  const run = withGhRestFallback(runner);
   const findPrForBranchOutcome = (branch: string, cwd?: string): FindPrForBranchOutcome => {
     // ⛔ 표식은 base 를 「생략했다」는 뜻이지 브랜치 이름이 아니다. 그대로 `gh --head` 로 넘기면
     //    gh 가 `no pull requests found for branch "elanous:default-branch"` 를 stderr 로 뱉는다.

package/src/autopilot/track-agent.ts

@@ -6,7 +6,7 @@ import { debug, redactSecretText } from '../debug/log.js';
 import { getOrCreatePersonaSession } from '../session/index.js';
 import { getUserConfig } from '../user-config.js';
 import { decideBudget, readBudgetInputsLive } from '../self-implement/budget-gate.js';
-import { loadTrackRegistry } from './mission-phase-track.js';
+import { findTrack } from './mission-phase-track.js';
 import { effectiveInstanceRoot } from '../instance/resolve.js';
 
 export type TrackAgentInput = { missionId: string; taskId: string; title: string; prompt: string; track: string };
@@ -45,7 +45,7 @@ const forbidden = /\b(?:delete|remove|deploy|publish|release|restart|reboot|merg
 let running = 0;
 
 function context(input: TrackAgentInput, repo: string): string {
-  const track = loadTrackRegistry().find(({ id }) => id === input.track);
+  const track = findTrack(input.track);
   if (!track) throw new Error('unknown track');
   const docs = resolve(repo, 'docs');
   let handoff = '';
@@ -94,7 +94,7 @@ export async function decideTrackAction(input: TrackAgentInput, deps: RunnerDeps
 export async function executeTrackAction(decision: TrackAgentDecision, input: TrackAgentInput, deps: RunnerDeps = {}): Promise<TrackAgentResult> {
   if (decision.action !== 'say') return { status: 'held', detail: decision.reason ?? '사람 확인' };
   if (forbidden.test(`${input.title}\n${input.prompt}`)) return { status: 'held', detail: '금지 작업 — 사람 확인' };
-  if (!loadTrackRegistry().some(({ id }) => id === input.track)) return { status: 'held', detail: '트랙 미정 — 사람 확인' };
+  if (!findTrack(input.track)) return { status: 'held', detail: '트랙 미정 — 사람 확인' };
   try {
     const checkBudget = deps.checkBudget ?? (async () => {
       const action = decideBudget(await readBudgetInputsLive()).action;

package/src/autopilot/track-courier.ts

@@ -6,7 +6,7 @@ import { join, resolve } from 'node:path';
 import { debug, redactSecretText } from '../debug/log.js';
 import { TaskStore } from '../task-orchestrator/store.js';
 import { getUserConfig, type UserConfig } from '../user-config.js';
-import { inferPhaseTrack, loadTrackRegistry } from './mission-phase-track.js';
+import { inferPhaseTrack, loadTrackRegistry, trackPostIds } from './mission-phase-track.js';
 import type { TrackAgentInput, TrackAgentRunner } from './track-agent.js';
 
 type CourierConfig = NonNullable<NonNullable<UserConfig['autopilot']>['trackCourier']>;
@@ -66,7 +66,7 @@ export async function trackAlive(track: string, deps: CourierDeps = {}): Promise
     const comments = await (deps.listComments ?? (() => defaultComments(config.channelPr!, now, minutesFor(config))))();
     if (!Array.isArray(comments)) throw new Error('comments response is not an array');
     const timestamps = comments
-      .filter((c) => c && typeof c.body === 'string' && c.body.startsWith(`**[${track}]**`))
+      .filter((c) => c && typeof c.body === 'string' && trackPostIds(track).some((id) => c.body.startsWith(`**[${id}]**`)))
       .map((c) => Date.parse(c.created_at))
       .filter((at) => Number.isFinite(at) && at <= now);
     if (!timestamps.length) return { alive: false, lastPostAt: null, reason: 'no-post' };

package/src/boot/acp-server.ts

@@ -24,14 +24,14 @@
 // no dashboard, no tui-client — verified by the expanded guard
 // test.
 
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { mkdirSync } from 'node:fs';
 import { getElanousConfigDir } from '../elanous-config-dir.js';
 import { dirname, join as joinPath } from 'node:path';
+import { ensureAuthToken } from '../auth/acp-token.js';
 
 import {
   listenUnixSocket,
   listenWebSocket,
-  generateAuthToken,
   createAuthVerifier,
 } from '../acp/transport/index.js';
 import { runAcpServer, type AcpServerOptions } from '../acp/server.js';
@@ -110,20 +110,6 @@ export function parseAcpBootArgs(argv: readonly string[]): AcpBootOptions {
   return opts;
 }
 
-/** Load or mint a persistent auth token for websocket boot. Stored
- *  at `~/.elanous/acp-token` with 0600 perms so the socket-holding
- *  user can bind-mount it into a parent client config. */
-function ensureAuthToken(): { token: string; path: string } {
-  const tokenPath = joinPath(getElanousConfigDir(), 'acp-token');
-  mkdirSync(dirname(tokenPath), { recursive: true });
-  if (existsSync(tokenPath)) {
-    return { token: readFileSync(tokenPath, 'utf-8').trim(), path: tokenPath };
-  }
-  const token = generateAuthToken();
-  writeFileSync(tokenPath, token, { mode: 0o600 });
-  return { token, path: tokenPath };
-}
-
 /** Resolved daemon-runtime status surfaced in the startup banner.
  *  Matches the shape returned by `createDaemonRuntime()` so callers
  *  can spread it directly. Lets every transport (stdio / unix-socket

package/src/boot/daemon-tools/web-search.ts

@@ -39,7 +39,8 @@ export function buildWebSearchTool(): LLMToolSpec {
     name: 'WebSearch',
     description:
       'Search the public web via the daemon\'s configured provider (Grok / ' +
-      'Firecrawl / etc.). Returns a ranked list of URLs + titles + snippets. ' +
+      'Firecrawl / etc.). When no key is available, falls back to keyless DuckDuckGo. ' +
+      'Returns a ranked list of URLs + titles + snippets. ' +
       'Pair with a follow-up Read or external WebFetch when the model needs ' +
       'the full article body.',
     parameters: {

package/src/boot/ws-bridge.ts

@@ -26,6 +26,7 @@ import type {
   PwaVoiceSession,
 } from '../voice/channel-adapters/pwa-voice-adapter.js';
 import { PWA_VOICE_FRAME_KIND } from '../voice/channel-adapters/pwa-voice-adapter.js';
+import { isSameOriginRequest } from './check-same-origin.js';
 import {
   buildDevProxyWsUrl,
   closeDevProxyUpstream,
@@ -47,6 +48,8 @@ export type WsLike = {
 
 export type BunServerLike = {
   upgrade: (req: Request, opts?: { data?: unknown; headers?: HeadersInit }) => boolean;
+  /** Bun's transport peer — used only for the same-origin exemption (HTTP 과 같은 규칙). */
+  requestIP?: (req: Request) => { address: string } | null;
 };
 
 export type WsHandlers = {
@@ -246,6 +249,14 @@ export function createWsBridge(opts: WsBridgeOpts): WsBridge {
             });
           }
           authed = true;
+        } else if (isSameOriginRequest(req, server.requestIP?.(req)?.address)) {
+          // ⭐ HTTP 의 same-origin 면제(`meta-api.ts` decideAuth)와 «같은» 규칙 — 루프백 직결 ⊕ 프록시 표지 없음 ⊕
+          //   Sec-Fetch-Site/Origin 이 같은 출처. 이 데몬이 내준 PWA 페이지가 토큰 없이 연 소켓이다.
+          // 🩸 2026-09-30 0.2.5 회귀: #21937 이 토큰을 «늘» 만들게 되면서 WS 검증기가 늘 켜졌고, 토큰을
+          //   저장하지 않은 PWA(새 설치 · 격리 넥서스)의 ACP 가 첫 `initialize` 에서 1008 auth_failed 로 닫혔다
+          //   — HTTP 는 이 면제로 살아 있어 «목록은 뜨는데 채팅·터미널만 죽는» 모양이 됐다.
+          authed = true;
+          trace('acp.ws.same-origin', { path: url.pathname });
         }
       }
       const acpState: AcpPerSocketState = {