elanous 0.2.4 → 0.2.6

package/skills/explainer-video/engine/vo.ts

@@ -0,0 +1,79 @@
+// Explainer VO — one voice file per beat plus per-character times; the times drive caption & highlight timing.
+// Usage: ELEVENLABS_API_KEY=… bun vo.ts <project>/script.json      (ElevenLabs /with-timestamps — exact word times)
+//        bun vo.ts <project>/script.json                            (no key → macOS `say`, times spread evenly — a draft voice)
+// Writes source/vo/<key>.mp3 ⊕ <key>.json (alignment ⊕ text hash ⊕ engine). Skips a beat whose hash is unchanged. Never prints the key.
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { createHash } from 'node:crypto';
+import { spawnSync } from 'node:child_process';
+import { join, dirname, resolve } from 'node:path';
+
+const KEY = process.env.ELEVENLABS_API_KEY?.trim();
+const scriptPath = resolve(process.argv[2] ?? 'script.json');
+const script = JSON.parse(readFileSync(scriptPath, 'utf8'));
+const dir = join(dirname(scriptPath), 'source', 'vo');
+mkdirSync(dir, { recursive: true });
+
+export function beatKeys(s: any): { key: string; vo: string }[] {
+  const out: { key: string; vo: string }[] = [];
+  s.intro.beats.forEach((b: any, i: number) => out.push({ key: `i-${i}`, vo: b.vo }));
+  s.chapters.forEach((c: any, ci: number) => c.beats.forEach((b: any, i: number) => out.push({ key: `c${ci + 1}-${i}`, vo: b.vo })));
+  s.outro.beats.forEach((b: any, i: number) => out.push({ key: `o-${i}`, vo: b.vo }));
+  return out;
+}
+
+type Alignment = { characters: string[]; character_start_times_seconds: number[]; character_end_times_seconds: number[] };
+
+async function elevenlabs(vo: string): Promise<{ mp3: Buffer; alignment: Alignment }> {
+  const res = await fetch(`https://api.elevenlabs.io/v1/text-to-speech/${script.voice.id}/with-timestamps?output_format=mp3_44100_192`, {
+    method: 'POST',
+    headers: { 'xi-api-key': KEY!, 'content-type': 'application/json' },
+    body: JSON.stringify({ text: vo, model_id: script.voice.model, language_code: 'ko' }),
+  });
+  if (!res.ok) throw new Error(`ElevenLabs HTTP ${res.status} ${(await res.text()).slice(0, 200)}`);
+  const data = await res.json() as { audio_base64: string; alignment: Alignment };
+  return { mp3: Buffer.from(data.audio_base64, 'base64'), alignment: data.alignment };
+}
+
+/** Keyless draft voice: macOS `say` → mp3 · character times spread in proportion over the measured length. */
+function sayVoice(): string {
+  const want = process.env.EXPLAINER_SAY_VOICE;
+  if (want) return want;
+  const list = spawnSync('say', ['-v', '?'], { encoding: 'utf8' });
+  if (list.status !== 0) throw new Error('no ELEVENLABS_API_KEY and `say` is unavailable (macOS only) — set the key via the plugin connector');
+  const ko = list.stdout.split('\n').filter((l) => /\bko_KR\b/.test(l)).map((l) => l.split(/\s{2,}|\s+\(/)[0].trim());
+  const pick = ko.find((v) => /^Yuna/.test(v)) ?? ko[0];
+  if (!pick) throw new Error('no Korean `say` voice installed — System Settings › Accessibility › Spoken Content, or set ELEVENLABS_API_KEY');
+  return pick;
+}
+function say(vo: string, key: string): { mp3: Buffer; alignment: Alignment } {
+  const voice = sayVoice();
+  const aiff = join(dir, `${key}.tmp.aiff`), mp3 = join(dir, `${key}.tmp.mp3`);
+  const r = spawnSync('say', ['-v', voice, '-o', aiff, vo], { encoding: 'utf8' });
+  if (r.status !== 0) throw new Error(`say failed: ${r.stderr.slice(0, 200)}`);
+  const f = spawnSync('ffmpeg', ['-v', 'error', '-y', '-i', aiff, '-ar', '44100', '-b:a', '192k', mp3], { encoding: 'utf8' });
+  if (f.status !== 0) throw new Error(`ffmpeg failed: ${f.stderr.slice(0, 200)}`);
+  const p = spawnSync('ffprobe', ['-v', 'error', '-show_entries', 'format=duration', '-of', 'csv=p=0', mp3], { encoding: 'utf8' });
+  const dur = Number(p.stdout.trim());
+  if (!(dur > 0)) throw new Error('ffprobe could not measure the say output');
+  const chars = [...vo];
+  const weight = chars.map((c) => (/\s/.test(c) ? 0.3 : /[,.·!?]/.test(c) ? 0.8 : 1));
+  const total = weight.reduce((a, b) => a + b, 0);
+  const starts: number[] = [], ends: number[] = [];
+  let t = 0;
+  for (const w of weight) { starts.push(+t.toFixed(3)); t += (w / total) * dur; ends.push(+t.toFixed(3)); }
+  const out = readFileSync(mp3);
+  rmSync(aiff, { force: true }); rmSync(mp3, { force: true });
+  return { mp3: out, alignment: { characters: chars, character_start_times_seconds: starts, character_end_times_seconds: ends } };
+}
+
+const engine = KEY ? 'elevenlabs' : 'say';
+if (!KEY) console.log('no ELEVENLABS_API_KEY — draft voice with macOS `say` (caption times are estimates)');
+for (const { key, vo } of beatKeys(script)) {
+  const hash = createHash('sha256').update(`${engine === 'say' ? 'say|' : ''}${script.voice.id}|${script.voice.model}|${vo}`).digest('hex').slice(0, 16);
+  const jf = join(dir, `${key}.json`);
+  if (existsSync(jf) && JSON.parse(readFileSync(jf, 'utf8')).hash === hash) { console.log(`${key} cached`); continue; }
+  const { mp3, alignment } = KEY ? await elevenlabs(vo) : say(vo, key);
+  writeFileSync(join(dir, `${key}.mp3`), mp3);
+  writeFileSync(jf, JSON.stringify({ hash, engine, vo, alignment }));
+  console.log(`${key} ${(alignment.character_end_times_seconds.at(-1) ?? 0).toFixed(2)}s  ${engine}  ${vo}`);
+}

package/skills/explainer-video/examples/elanous-0.2.5/script.json

@@ -0,0 +1,155 @@
+{
+  "title": "엘라누스 0.2.5 — 다섯 가지 한 번에",
+  "voice": {
+    "id": "ksaI0TCD9BstzEzlxj4q",
+    "name": "Seulki",
+    "model": "eleven_v3"
+  },
+  "sources": "docs/marketing (LAUNCH-0.2.5 초안) · PR #21849 #21887 #21878 #21855 #22054 #21908 #21995 #22001 — 전부 컷 e24cb6e 안 MERGED",
+  "intro": {
+    "beats": [
+      {
+        "vo": "엘라누스 0.2.5, 다섯 가지로 정리해 드립니다.",
+        "cap": "엘라누스 0.2.5, **다섯 가지**로 정리합니다"
+      }
+    ]
+  },
+  "chapters": [
+    {
+      "title": "미션 전 플러그인 자기 설치",
+      "sub": "모자란 것을 먼저 따진다",
+      "diagram": "mission",
+      "beats": [
+        {
+          "vo": "첫 번째는 플러그인 자기 설치입니다.",
+          "cap": "첫 번째, **플러그인 자기 설치**"
+        },
+        {
+          "vo": "미션을 보내기 전에, 엘라누스가 무엇이 모자란지 먼저 따집니다.",
+          "cap": "보내기 전에 **무엇이 모자란지** 먼저 따진다"
+        },
+        {
+          "vo": "실제 첫 판에서는 플러그인 이름을 주지 않았는데, 엘라누스 베이직스를 골라 코딩 에이전트 화면 안에서 설치했습니다.",
+          "cap": "이름을 안 줬는데 **elanous-basics**를 골라 설치",
+          "hl": [
+            [
+              "elanous-basics",
+              "베이직스"
+            ]
+          ]
+        },
+        {
+          "vo": "사람이 챙겨 주던 도구를, 에이전트가 먼저 챙기는 거죠.",
+          "cap": "도구를 **에이전트가 먼저** 챙긴다"
+        }
+      ]
+    },
+    {
+      "title": "plugin add",
+      "sub": "이름@마켓 한 줄",
+      "diagram": "terminal",
+      "beats": [
+        {
+          "vo": "두 번째는 플러그인 애드 명령입니다.",
+          "cap": "두 번째, **plugin add**",
+          "hl": [
+            [
+              "plugin add",
+              "애드"
+            ]
+          ]
+        },
+        {
+          "vo": "이름과 마켓만 적으면 됩니다.",
+          "cap": "**이름@마켓**만 적는다",
+          "hl": [
+            [
+              "이름@마켓",
+              "마켓"
+            ]
+          ]
+        },
+        {
+          "vo": "색인 서명과 패키지 해시를 확인한 뒤에만 설치합니다.",
+          "cap": "**서명**과 **해시**를 확인한 뒤에만 설치"
+        }
+      ]
+    },
+    {
+      "title": "편집기 플러그인 노드",
+      "sub": "입력 폼이 저절로",
+      "diagram": "nodes",
+      "beats": [
+        {
+          "vo": "세 번째는 워크플로 편집기의 플러그인 노드입니다.",
+          "cap": "세 번째, **플러그인 노드**"
+        },
+        {
+          "vo": "플러그인이 노드를 더하고,",
+          "cap": "플러그인이 **노드를 더하고**"
+        },
+        {
+          "vo": "입력 폼은 노드의 입력 정의에서 저절로 만들어집니다.",
+          "cap": "입력 폼은 **저절로** 만들어진다"
+        }
+      ]
+    },
+    {
+      "title": "플러그인별 자격 키",
+      "sub": "키는 그 플러그인에게만",
+      "diagram": "keys",
+      "beats": [
+        {
+          "vo": "네 번째는 플러그인별 자격 키입니다.",
+          "cap": "네 번째, **플러그인별 자격 키**"
+        },
+        {
+          "vo": "키를 넣을 문이 생겼고,",
+          "cap": "키를 **넣을 문**이 생겼고"
+        },
+        {
+          "vo": "그 키는 그 플러그인에게만 전달됩니다.",
+          "cap": "키는 **그 플러그인에게만** 간다"
+        }
+      ]
+    },
+    {
+      "title": "승인 화면",
+      "sub": "웹 앱에서 승인·거절",
+      "diagram": "approve",
+      "beats": [
+        {
+          "vo": "다섯 번째는 웹 앱의 승인 화면입니다.",
+          "cap": "다섯 번째, **승인 화면**"
+        },
+        {
+          "vo": "릴리스나 공지처럼 사람의 승인에서 멈춘 런을,",
+          "cap": "사람의 승인에서 **멈춘 런**을"
+        },
+        {
+          "vo": "웹 앱에서 바로 승인하거나 거절합니다.",
+          "cap": "웹 앱에서 바로 **승인·거절**"
+        }
+      ]
+    }
+  ],
+  "outro": {
+    "beats": [
+      {
+        "vo": "정리하면, 이번 판의 핵심은 이것입니다.",
+        "cap": "이번 판의 **핵심**"
+      },
+      {
+        "vo": "필요한 도구는 에이전트가 스스로 챙기고, 사람은 승인합니다.",
+        "cap": "도구는 **에이전트가 스스로**, 사람은 **승인**"
+      }
+    ],
+    "cta": {
+      "line": "Elanous by Elanvital AI",
+      "links": [
+        "elanous.ai",
+        "github.com/ElanvitalAI/elanous"
+      ]
+    }
+  }
+}

package/src/agent/nested-agent-env.ts

@@ -1,6 +1,7 @@
 /** Parent-only markers that make a spawned coding agent reject nested execution. */
 export const NESTED_AGENT_ENV_BLOCKLIST = new Set<string>([
   'CLAUDECODE',
+  'CLAUDE_CODE_CHILD_SESSION',
   'ELANOUS_SESSION_ID',
   'ELANOUS_UNDO_REF',
   'ELANOUS_GUARDIAN',

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