elanous 0.2.4 → 0.2.5

package/src/agent-mission/driver.ts

@@ -9,7 +9,7 @@
 // 재사용: startPty(Bun 네이티브 PTY)·createWorktree·streamLLM·worktreeHasChanges·commitWorktree.
 import { execFileSync, spawnSync, spawn as spawnChild } from 'node:child_process';
 import { homedir } from 'node:os';
-import { existsSync, writeFileSync, mkdirSync, readdirSync, readFileSync, statSync, readlinkSync, realpathSync, lstatSync } from 'node:fs';
+import { existsSync, writeFileSync, mkdirSync, readdirSync, readFileSync, statSync, readlinkSync, realpathSync, lstatSync, unlinkSync } from 'node:fs';
 import { createHash } from 'node:crypto';
 import { join, relative, resolve, isAbsolute, sep } from 'node:path';
 import { startPty, mintPtyId, onPtyEvent, type PtyHandle, type StartOpts } from '../pty-shell/registry.js';
@@ -34,8 +34,10 @@ import { runWithControlObserve } from '../capture/control-observe-adapter.js';
 import { buildMissionProvision, sanitizeForPtyInput, type ProvisionRequest, type ProvisionResult } from './provision.js';
 import { checkClaudeSubscription } from './claude-subscription.js';
 import { handoffMission, waitForHumanLogin, type HandoffOperations } from './handoff.js';
+import { dispatchOpenPullRequest } from '../tool-runtime/git-pr-runtime.js';
 import { runClaudeHeadless } from './claude-headless.js';
 import { installPluginInsideAgent, type PluginRequest, type PluginDeps } from './in-agent-plugin.js';
+import { planMissionResources, type ResourceLadderDeps, type ResourcePlan } from './resource-ladder.js';
 import { ensureRunId } from '../harness/harness-space.js';
 import { recordHarnessWorktreeProvenance } from '../harness/harness-worktree-add.js';
 import { resolveInstanceName } from '../instance-identity.js';
@@ -459,6 +461,10 @@ export interface AgentMissionSpec {
   headless?: boolean;
   /** Install in the agent's own UI before sending the mission. */
   plugin?: Pick<PluginRequest, 'plugin' | 'marketplace'>;
+  /** Pre-mission resource judgment; off skips it. */
+  resources?: 'on' | 'off';
+  /** Only the caller's explicit backend selection, not the resolved default. */
+  backendExplicit?: string;
   /** Explicit backend sequence; transitions use the same handoff coordinator as brain decisions. */
   chain?: readonly ('codex' | 'claude' | 'elanous')[];
   /**
@@ -496,7 +502,8 @@ export interface AgentMissionResult {
   ok: boolean;
   worktree: string;
   branch: string | null;
-  reason?: 'aborted' | 'outside-write';
+  reason?: 'aborted' | 'outside-write' | 'origin-not-github';
+  pr?: 'skipped';
   paths?: string[];
   rounds: number;
   evidencePath: string | null;
@@ -526,6 +533,7 @@ export interface AgentMissionDeps {
   runClaudeHeadless?: typeof runClaudeHeadless;
   checkEvidence?: typeof checkEvidence;
   commitWorktree?: typeof commitWorktree;
+  dispatchOpenPullRequest?: typeof dispatchOpenPullRequest;
   terminateProcessTree?: typeof terminateMissionProcessTree;
   repoStatus?: (repo: string) => string | Promise<string>;
   emitDecision?: typeof emitDecision;
@@ -546,6 +554,8 @@ export interface AgentMissionDeps {
   initialTsc?: ReturnType<typeof collectTscDiagnostics> | null;
   installPlugin?: typeof installPluginInsideAgent;
   pluginDeps?: PluginDeps;
+  resourceLadder?: ResourceLadderDeps;
+  planMissionResources?: typeof planMissionResources;
 }
 
 const DEFAULT_OMNI = `${process.env.HOME}/.claude/skills/omni-crawl/scripts/main.ts`;
@@ -1644,16 +1654,55 @@ async function runAgentMissionBody(spec: AgentMissionSpec, deps: AgentMissionDep
     screen = await (deps.awaitMission ? deps.awaitMission(trusted) : trusted);
   }
 
-  if (spec.plugin) {
-    const plugin = await (deps.installPlugin ?? installPluginInsideAgent)(
-      { agent: backend.name as 'codex' | 'claude', ...spec.plugin }, h,
-      { ...(backend.handleTrust ? { handleTrust: backend.handleTrust } : {}), ...deps.pluginDeps, write: drive },
-    );
-    if (plugin.outcome !== 'installed') {
-      stopLive();
-      try { h.kill(); } catch { /* already exited */ }
-      return { ok: false, worktree: wt.path, branch: wt.branch, rounds: 0, evidencePath: null,
-        committed: false, usedOmniCrawl: false, detail: `플러그인 설치 ESCALATE (${plugin.reason}) — 미션은 전송하지 않았다` };
+  let resourcePlan: ResourcePlan | undefined;
+  // Only an explicit `on` runs the ladder (the CLI passes `on` by default). Library callers and fake-PTY
+  // tests that leave it unset keep the pre-ladder behaviour — 09-29 #21849 made them wait on a real LLM.
+  if (spec.resources === 'on') {
+    let timer: ReturnType<typeof setTimeout> | undefined;
+    try {
+      resourcePlan = await Promise.race([
+        (deps.planMissionResources ?? planMissionResources)(spec.mission, deps.resourceLadder ?? {}, {
+          backend: spec.backendExplicit,
+          plugin: spec.plugin ? `${spec.plugin.plugin}@${spec.plugin.marketplace}` : undefined,
+          resources: spec.resources,
+          deadlineMs: 20_000,
+        }),
+        new Promise<never>((_resolve, reject) => { timer = setTimeout(() => reject(new Error('resource ladder timeout (20s)')), 20_000); }),
+      ]);
+      debug.log('agent-mission.resources', 'planned', {
+        have: resourcePlan.have.length, gaps: resourcePlan.gaps.length,
+        suggestedPlugin: resourcePlan.plugin?.plugin, suggestedBackend: resourcePlan.backend?.name,
+        executedBackend: backend.name,
+      });
+    } catch (error) {
+      debug.log('agent-mission.resources', 'plan-failed', { reason: error instanceof Error ? error.message : String(error) }, { level: 'warn' });
+    } finally { if (timer) clearTimeout(timer); }
+  }
+  const suggestedPlugin = resourcePlan?.plugin?.source === 'official-index' && !spec.plugin
+    && !spec.headless && (backend.name === 'codex' || backend.name === 'claude')
+    && resourcePlan.plugin.marketplace === 'elanous'
+    && /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/.test(resourcePlan.plugin.plugin)
+    ? { plugin: resourcePlan.plugin.plugin, marketplace: resourcePlan.plugin.marketplace } : undefined;
+  const requestedPlugin = spec.plugin ?? suggestedPlugin;
+  let installedPlugin: typeof requestedPlugin;
+  if (requestedPlugin) {
+    try {
+      const plugin = await (deps.installPlugin ?? installPluginInsideAgent)(
+        { agent: backend.name as 'codex' | 'claude', ...requestedPlugin }, h,
+        { ...(backend.handleTrust ? { handleTrust: backend.handleTrust } : {}), ...deps.pluginDeps, write: drive },
+      );
+      if (plugin.outcome !== 'installed') {
+        if (spec.plugin) {
+          stopLive();
+          try { h.kill(); } catch { /* already exited */ }
+          return { ok: false, worktree: wt.path, branch: wt.branch, rounds: 0, evidencePath: null,
+            committed: false, usedOmniCrawl: false, detail: `플러그인 설치 ESCALATE (${plugin.reason}) — 미션은 전송하지 않았다` };
+        }
+        debug.log('agent-mission.resources', 'install-failed', { plugin: requestedPlugin.plugin, reason: plugin.reason }, { level: 'warn' });
+      } else installedPlugin = requestedPlugin;
+    } catch (error) {
+      if (spec.plugin) throw error;
+      debug.log('agent-mission.resources', 'install-failed', { plugin: requestedPlugin.plugin, reason: 'installer-error' }, { level: 'warn' });
     }
   }
 
@@ -1683,7 +1732,15 @@ async function runAgentMissionBody(spec: AgentMissionSpec, deps: AgentMissionDep
     else debug.log('agent-mission', 'memory', { injected: false });
   }
 
-  if (spec.plugin) missionText = `${missionText}\n\n설치된 ${spec.plugin.plugin} 플러그인에서 실제 스킬을 확인하고 ${spec.plugin.plugin}:<skill> 형식으로 해당 스킬을 사용하라.`;
+  if (installedPlugin) missionText = `${missionText}\n\n설치된 ${installedPlugin.plugin} 플러그인에서 실제 스킬을 확인하고 ${installedPlugin.plugin}:<skill> 형식으로 해당 스킬을 사용하라.`;
+  if (resourcePlan) {
+    const safeName = (name: string) => sanitizeForPtyInput(name, 80)
+      .replace(/\b(?:bearer|secret|password|token|api.?key|authorization)\s*[:=]\s*\S+|(?:sk-[\w-]+|gh[pousr]_[\w-]+|github_pat_[\w-]+|AIza[\w-]+|xox[baprs]-[\w-]+)/gi, '[redacted]')
+      .replace(/https?:\/\/\S+/gi, '[redacted]');
+    const have = resourcePlan.have.slice(0, 5).map(safeName);
+    const gaps = resourcePlan.gaps.slice(0, 5).map(gap => safeName(gap.need));
+    missionText = `${missionText}\n\n[elanous 자원]\n보유: ${have.join(', ') || '없음'}\n설치: ${installedPlugin ? `${installedPlugin.plugin}@${installedPlugin.marketplace}` : '없음'}\n미충족: ${gaps.join(', ') || '없음'}`;
+  }
   if (deps.isMissionAborted?.()) throw new Error('MISSION_ABORTED');
   // 미션 전송 — 인핸싱/기억으로 가공됐으면(멀티라인) 파일로 떨궈 read 지시(TUI 멀티라인 위험·verbatim 보존).
   //   원문 그대로면(단문) 타이핑.
@@ -1738,6 +1795,7 @@ async function runAgentMissionBody(spec: AgentMissionSpec, deps: AgentMissionDep
   };
   let pendingHandoff: { to: 'codex' | 'claude'; mission: string; summary: string } | undefined;
   let gatedHandoff = false;
+  let handoffPrSkipped = false;
   let transitionFailure: string | undefined;
   const handoffOps: HandoffOperations = {
     start: async (to, mission) => { pendingHandoff = { to, mission, summary: controllerSummary }; },
@@ -1765,11 +1823,30 @@ async function runAgentMissionBody(spec: AgentMissionSpec, deps: AgentMissionDep
       if (spec.commit === false) throw new Error('elanous PR handoff requires commit authorization');
       const ev = (deps.checkEvidence ?? evidenceCheck)(worktree, spec.evidence);
       if (!ev.ok) throw new Error(`handoff evidence gate failed: ${ev.retry ?? 'missing evidence'}`);
+      const promptFile = join(worktree, '.mission-prompt.md');
+      let promptExisted = false;
+      try { lstatSync(promptFile); promptExisted = true; } catch (error) {
+        if ((error as NodeJS.ErrnoException).code !== 'ENOENT') throw error;
+      }
+      if (promptExisted) unlinkSync(promptFile);
+      debug.log('agent-mission', 'handoff-prompt-file-removed', { existed: promptExisted });
+      const stagedPrompt = execFileSync('git', ['ls-files', '--cached', '--', '.mission-prompt.md'], { cwd: worktree, encoding: 'utf8' });
+      if (stagedPrompt.trim()) {
+        execFileSync('git', ['rm', '-f', '--cached', '--', '.mission-prompt.md'], { cwd: worktree, encoding: 'utf8' });
+      }
+      if (execFileSync('git', ['ls-files', '--cached', '--', '.mission-prompt.md'], { cwd: worktree, encoding: 'utf8' }).trim()) {
+        throw new Error('handoff prompt file remains in commit index');
+      }
       const commit = (deps.commitWorktree ?? commitWorktree)(worktree, `chore(agent-mission): ${spec.branch} handoff`);
       if (!commit.ok) throw new Error(`handoff commit failed: ${commit.out}`);
       execFileSync('git', ['push', '-u', 'origin', `HEAD:${spec.branch}`], { cwd: worktree, encoding: 'utf8', timeout: 120_000 });
-      const { dispatchOpenPullRequest } = await import('../tool-runtime/git-pr-runtime.js');
-      dispatchOpenPullRequest({ title: `agent-mission: ${spec.branch}`, body: deps.originalMission ?? spec.mission, head: spec.branch, base: spec.base ?? 'main' }, { cwd: worktree });
+      const pushUrls = execFileSync('git', ['remote', 'get-url', '--push', '--all', 'origin'], { cwd: worktree, encoding: 'utf8' }).trim().split('\n');
+      if (!pushUrls.length || !pushUrls.every((url) => /^(?:https:\/\/github\.com\/|ssh:\/\/git@github\.com\/|git@github\.com:)[^/]+\/[^/]+\/?$/i.test(url))) {
+        handoffPrSkipped = true;
+        debug.log('agent-mission', 'handoff-pr-skipped', { reason: 'origin-not-github' });
+      } else {
+        (deps.dispatchOpenPullRequest ?? dispatchOpenPullRequest)({ title: `agent-mission: ${spec.branch}`, body: deps.originalMission ?? spec.mission, head: spec.branch, base: spec.base ?? 'main' }, { cwd: worktree });
+      }
       gatedHandoff = true;
     },
     ...deps.handoffOperations,
@@ -1879,7 +1956,9 @@ async function runAgentMissionBody(spec: AgentMissionSpec, deps: AgentMissionDep
   if (gatedHandoff && control.termination.kind !== 'error') {
     stopLive();
     try { h.kill(); } catch { /* noop */ }
-    return { ok: true, worktree: wt.path, branch: wt.branch, rounds: control.steps, evidencePath: wt.path, committed: true, usedOmniCrawl: usedOmni, detail: '완료(증거 게이트·PR)' };
+    return { ok: true, worktree: wt.path, branch: wt.branch, rounds: control.steps, evidencePath: wt.path, committed: true, usedOmniCrawl: usedOmni,
+      ...(handoffPrSkipped ? { pr: 'skipped' as const, reason: 'origin-not-github' as const } : {}),
+      detail: handoffPrSkipped ? '완료(증거 게이트·push·PR 생략)' : '완료(증거 게이트·PR)' };
   }
   const done = control.termination.kind === 'success';
   const round = control.steps;

package/src/agent-mission/mission-cli.ts

@@ -18,6 +18,7 @@ export interface MissionCliOpts {
   chain?: string;
   headless?: boolean;
   plugin?: string;
+  resources?: 'on' | 'off';
   evidence?: string; // 'doc' | 'tsc' | 'test'
   docDir?: string;
   docGlob?: string;
@@ -61,6 +62,9 @@ export async function runAgentMissionCliCommand(
   if (opts.plugin !== undefined && (!plugin || !['codex', 'claude'].includes(agentBackend.name) || opts.headless)) {
     return { ok: false, message: '--plugin 은 codex/claude 대화형 backend 에서 <name>@<market> 형식이어야 합니다', exitCode: 1 };
   }
+  if (opts.resources !== undefined && opts.resources !== 'on' && opts.resources !== 'off') {
+    return { ok: false, message: '--resources 는 on|off 여야 합니다', exitCode: 1 };
+  }
 
   // ── mission 텍스트(verbatim: --mission-file 우선) ──
   const readFile = deps.readFile ?? ((p: string) => readFileSync(p, 'utf8'));
@@ -97,6 +101,8 @@ export async function runAgentMissionCliCommand(
     backend: agentBackend.name,
     ...(chain ? { chain: chain as ('codex' | 'claude' | 'elanous')[] } : {}),
     ...(plugin ? { plugin } : {}),
+    resources: opts.resources ?? 'on',
+    ...(opts.backend ? { backendExplicit: opts.backend } : {}),
     ...(opts.headless ? { headless: true } : {}),
     branch: opts.branch,
     ...(opts.base ? { base: opts.base } : {}),

package/src/agent-mission/resource-ladder.ts

@@ -15,6 +15,7 @@ import { ELANOUS_MARKET_URL } from '../plugins/install/market-fetch.js';
 const MARKETPLACE = 'elanous';
 const INDEX_URL = new URL('marketplace.json', ELANOUS_MARKET_URL).href; // one source of truth for the official market
 const MAX_NEEDS = 5;
+const MAX_VOCABULARY = 200;
 
 export interface ResourcePlan {
   needs: string[];
@@ -29,11 +30,13 @@ export interface MissionResources {
   readonly backend?: string;
   readonly plugin?: string;
   readonly resources?: 'off' | 'on';
+  /** Total planner budget in milliseconds; discovery uses only the remaining time. */
+  readonly deadlineMs?: number;
 }
 
 export interface ResourceLadderDeps extends MissionResources {
   /** One JSON-producing LLM call; the raw mission is never sent to logs. */
-  readonly inferNeeds?: (safeMission: string) => Promise<string>;
+  readonly inferNeeds?: (safeMission: string, vocabulary: readonly string[]) => Promise<string>;
   readonly readers?: CapabilityReaders;
   /** Read the official index and its detached signature as a pair; no other market is consulted. */
   readonly readOfficialIndex?: () => Promise<{ marketplaceBytes: Uint8Array; signatureText: string }>;
@@ -60,22 +63,25 @@ function safeNeed(value: unknown): string | null {
   return need;
 }
 
-function parseNeeds(raw: string): string[] {
+function parseNeeds(raw: string, vocabulary: readonly string[]): string[] {
   let parsed: unknown;
   try { parsed = JSON.parse(raw); } catch { return []; }
   if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed) || !Array.isArray((parsed as { needs?: unknown }).needs)) return [];
   const needs: string[] = [];
   for (const item of (parsed as { needs: unknown[] }).needs) {
-    const need = safeNeed(item);
-    if (need && !needs.some(existing => normalizeServiceName(existing) === normalizeServiceName(need))) needs.push(need);
+    const label = typeof item === 'string' ? vocabulary.find(value => value === item) : undefined;
+    const need = label ?? safeNeed(item);
+    if (need && !needs.some(existing => normalizeServiceName(existing) === normalizeServiceName(need))) {
+      needs.push(label ?? vocabulary.find(value => normalizeServiceName(value) === normalizeServiceName(need)) ?? need);
+    }
     if (needs.length === MAX_NEEDS) break;
   }
   return needs;
 }
 
-async function inferNeeds(mission: string): Promise<string> {
+async function inferNeeds(mission: string, vocabulary: readonly string[]): Promise<string> {
   return streamLLM([
-    { role: 'system', content: 'Identify at most five concrete tool/service/skill capabilities required for this mission. Reply ONLY with JSON {"needs":["capability"]}. No credentials, tokens, URLs, or mission text in the output. If uncertain, return an empty list.' },
+    { role: 'system', content: `Identify at most five concrete tool/service/skill capabilities required for this mission. Reply ONLY with JSON {"needs":["capability"]}. No credentials, tokens, URLs, or mission text in the output. If a relevant label appears in this verified official marketplace vocabulary, use that exact label; otherwise use a concrete capability. If uncertain, return an empty list.\nVerified labels: ${JSON.stringify(vocabulary)}` },
     { role: 'user', content: mission },
   ], () => {}, { maxTokens: 200, temperature: 0 });
 }
@@ -104,20 +110,60 @@ function pluginLabels(plugin: MarketplaceIndex['plugins'][number]): string[] {
   return [plugin.name, plugin.description ?? '', ...plugin['ai.elanous'].capabilities, ...(plugin['ai.elanous'].vocab ?? [])];
 }
 
+function officialVocabulary(index: MarketplaceIndex): string[] {
+  const labels: string[] = [];
+  for (const entry of index.plugins) {
+    for (const label of [entry.name, ...entry['ai.elanous'].capabilities, ...(entry['ai.elanous'].vocab ?? [])]) {
+      const safe = typeof label === 'string' && label === label.trim() && label.length <= 80
+        && !/[\n\r{}<>@=/\\]/.test(label) && (safeMissionText(label) === label || /^secret:[a-zA-Z0-9._-]+$/.test(label)) ? label : null;
+      if (safe && !labels.includes(safe)) labels.push(safe);
+      if (labels.length === MAX_VOCABULARY) return labels;
+    }
+  }
+  return labels;
+}
+
+function mentionedPluginNames(mission: string, index: MarketplaceIndex): string[] {
+  return index.plugins.map(entry => entry.name).filter(name => {
+    if (!safeNeed(name) || safeMissionText(name) !== name || !/^[a-zA-Z0-9][a-zA-Z0-9._-]*$/.test(name)) return false;
+    const escaped = name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    return new RegExp(`(^|[^\\p{L}\\p{N}_.-])${escaped}(?=$|[^\\p{L}\\p{N}_.-])`, 'iu').test(mission);
+  }).slice(0, MAX_NEEDS);
+}
+
 /** Pre-mission resource judgment. Only the optional, injected installer can cause installation. */
 export async function planMissionResources(mission: string, deps: ResourceLadderDeps = {}, options: MissionResources = {}): Promise<ResourcePlan> {
   const plan: ResourcePlan = { needs: [], have: [], gaps: [], decisions: [] };
   if (options.resources === 'off' || deps.resources === 'off') return plan;
   const backend = options.backend ?? deps.backend;
   const plugin = options.plugin ?? deps.plugin;
+  const budgetMs = options.deadlineMs ?? deps.deadlineMs;
+  const deadline = budgetMs === undefined ? undefined : Date.now() + budgetMs;
   const decide = (step: string, kind: DecisionEvent['kind'], what: string, why: string) => {
     plan.decisions.push(`${step}: ${what} — ${why}`);
     (deps.decide ?? emitDecision)({ kind, what, reason: why, purpose: 'pre-mission resource selection', target: 'agent-mission', phase: 'dispatch' });
     (deps.log ?? ((event, data) => debug.log('agent-mission.resources', event, data)))(step, { kind, what, why });
   };
 
-  try { plan.needs = parseNeeds(await (deps.inferNeeds ?? inferNeeds)(safeMissionText(mission))); }
+  let index: MarketplaceIndex | undefined;
+  try {
+    const pair = await (deps.readOfficialIndex ?? readOfficialIndex)();
+    const checked = verifyIndex({ ...pair, trustedKeys: OFFICIAL_INDEX_KEYS });
+    if (checked.ok && checked.index.name === MARKETPLACE) index = checked.index;
+    else decide('official-index', 'ESCALATE', '공식 마켓 거부', '서명 또는 마켓 이름 검증 실패');
+  } catch { decide('official-index', 'ESCALATE', '공식 마켓 조회 실패', '서명 검증 가능한 원본 인덱스 없음'); }
+  const safeMission = safeMissionText(mission);
+  const vocabulary = index ? officialVocabulary(index) : [];
+  try { plan.needs = parseNeeds(await (deps.inferNeeds ?? inferNeeds)(safeMission, vocabulary), vocabulary); }
   catch { decide('needs', 'ESCALATE', '능력 판정 불가', 'LLM 응답 실패 — 추측하지 않음'); }
+  const mentioned = index ? mentionedPluginNames(safeMission, index) : [];
+  for (const name of mentioned) {
+    if (!plan.needs.some(need => matches(need, [name]))) {
+      if (plan.needs.length === MAX_NEEDS) plan.needs.pop();
+      plan.needs.push(name);
+    }
+    decide('needs', 'VERIFY', name, '이름 언급');
+  }
   decide('needs', 'VERIFY', '필요 능력 판정', `${plan.needs.length}개 확인`);
   if (!plan.needs.length) return plan;
 
@@ -132,16 +178,7 @@ export async function planMissionResources(mission: string, deps: ResourceLadder
   });
   decide('have', 'VERIFY', 'ready 서비스 대조', `${plan.have.length}개 확인`);
 
-  let index: MarketplaceIndex | undefined;
-  if (remaining.length) {
-    try {
-      const pair = await (deps.readOfficialIndex ?? readOfficialIndex)();
-      const checked = verifyIndex({ ...pair, trustedKeys: OFFICIAL_INDEX_KEYS });
-      if (checked.ok && checked.index.name === MARKETPLACE) index = checked.index;
-      else decide('official-index', 'ESCALATE', '공식 마켓 거부', '서명 또는 마켓 이름 검증 실패');
-    } catch { decide('official-index', 'ESCALATE', '공식 마켓 조회 실패', '서명 검증 가능한 원본 인덱스 없음'); }
-  }
-  if (index) {
+  if (index && remaining.length) {
     let installed: readonly { name: string; market: string }[] = [];
     try { installed = (deps.readInstalledPlugins ?? installedPlugins)(); }
     catch { decide('have', 'ESCALATE', '설치 원장 읽기 실패', '설치된 스킬을 보유로 간주하지 않음'); }
@@ -153,7 +190,8 @@ export async function planMissionResources(mission: string, deps: ResourceLadder
     });
     decide('have', 'VERIFY', '설치된 플러그인 스킬 대조', `${plan.have.length}개 확인`);
     if (!plugin) {
-      const choices = index.plugins.filter(entry => remaining.some(need => matches(need, pluginLabels(entry))));
+      const named = index.plugins.filter(entry => mentioned.includes(entry.name) && remaining.some(need => matches(need, [entry.name])));
+      const choices = named.length ? named : index.plugins.filter(entry => remaining.some(need => matches(need, pluginLabels(entry))));
       if (choices.length === 1) {
         plan.plugin = { plugin: choices[0]!.name, marketplace: MARKETPLACE, source: 'official-index' };
         decide('official-index', 'ROUTE', '공식 플러그인 선택', '서명 검증된 인덱스에서 일치하는 플러그인 한 개');
@@ -169,13 +207,6 @@ export async function planMissionResources(mission: string, deps: ResourceLadder
     } else decide('official-index', 'ROUTE', '명시 플러그인 보존', '호출자 선택을 덮지 않음');
   }
 
-  for (const need of remaining) {
-    let candidates: CapabilityCandidate[] = [];
-    try { candidates = await (deps.discover ?? discoverCapability)(need, { community: false }); }
-    catch { decide('discover', 'ESCALATE', '발굴 실패', '후보 없음 — 자동 설치하지 않음'); }
-    plan.gaps.push({ need, candidates });
-    decide('discover', 'ESCALATE', '미충족 능력 후보', `${candidates.length}개 후보 제안만 함`);
-  }
   if (!backend) {
     const chosen = plan.needs.map(need => ({ need, name: pickBackend(matrix, need) })).find(row => row.name);
     if (chosen?.name) {
@@ -183,5 +214,22 @@ export async function planMissionResources(mission: string, deps: ResourceLadder
       decide('backend', 'ROUTE', 'ready 에이전트 선택', plan.backend.why);
     } else decide('backend', 'ESCALATE', '에이전트 자동 선택 보류', '필요 서비스의 ready 관측 없음');
   } else decide('backend', 'ROUTE', '명시 에이전트 보존', '호출자 backend 를 덮지 않음');
+  plan.gaps = await Promise.all(remaining.map(async need => {
+    let candidates: CapabilityCandidate[] = [];
+    let timer: ReturnType<typeof setTimeout> | undefined;
+    const controller = new AbortController();
+    try {
+      const remainingMs = deadline === undefined ? undefined : Math.max(0, deadline - Date.now() - 50);
+      if (remainingMs === 0) throw new Error('discovery deadline');
+      const discovery = (deps.discover ?? discoverCapability)(need, { community: false, signal: controller.signal });
+      candidates = remainingMs === undefined ? await discovery : await Promise.race([
+        discovery,
+        new Promise<CapabilityCandidate[]>((_resolve, reject) => { timer = setTimeout(() => reject(new Error('discovery deadline')), remainingMs); }),
+      ]);
+    } catch { controller.abort(); decide('discover', 'ESCALATE', '발굴 실패', '후보 없음 — 자동 설치하지 않음'); }
+    finally { if (timer) clearTimeout(timer); }
+    decide('discover', 'ESCALATE', '미충족 능력 후보', `${candidates.length}개 후보 제안만 함`);
+    return { need, candidates };
+  }));
   return plan;
 }

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;
+  }
+}