elanous 0.2.41 → 0.2.43

package/src/skills/tools/agent.ts

@@ -245,8 +245,9 @@ const FALLBACK_GENERAL_PURPOSE: AgentDefinition = {
   systemPrompt:
     'You are a sub-agent spawned by a parent task. Run the work in the prompt to ' +
     'completion using the tools you have, then return ONE final message containing ' +
-    'the deliverable. Be terse — your output goes back into the parent\'s context.',
-  tools: ['Bash', 'Read', 'Edit', 'Grep', 'WebFetch'],
+    'the deliverable. The parent provides the available tool catalog; Agent recursion is removed ' +
+    'and all calls still pass through the parent dispatcher and its policy checks. ' +
+    'Be terse — your output goes back into the parent\'s context.',
 };
 
 export interface AgentToolArgs {
@@ -271,6 +272,10 @@ export interface AgentToolArgs {
    *  child keeps running; completion emits a task-notification
    *  (P2) which the parent sees in the next turn's user message. */
   run_in_background?: boolean;
+  /** How a background completion reaches an idle parent TUI. */
+  completion_delivery?: 'follow-up' | 'supplement';
+  /** Best-effort wall-clock budget for a research child, in minutes. */
+  budget_minutes?: number;
   /** When true, a background launch that hits the fan-out ceiling WAITS on
    *  the session's shared admission queue instead of being refused: it spawns
    *  as soon as a live background agent terminals (subagent waits are
@@ -349,8 +354,9 @@ export function buildAgentTool(): LLMToolSpec {
       'Delegate heavy multistep work that would overflow your context, fan out independent units in parallel, ' +
       'and hand off long investigations; use run_in_background for long-running work so you can keep coordinating ' +
       'and finish after the results arrive.\n' +
+      'For parallel research, prefer completion_delivery="supplement" and budget_minutes=8: ask each child for its best verified evidence within the budget; late results appear as one chat line without reopening a TUI turn.\n' +
       '\n' +
-      'The sub-agent gets its own tools (Bash/Read/Edit/Grep/WebFetch by default) and its own ' +
+      'The sub-agent inherits the parent-provided tool catalog by default (Agent recursion is removed) and its own ' +
       'turn budget (default 20). It returns ONE final message which becomes your tool_result. ' +
       'Pass everything the worker needs (data, persona, framing) inside `prompt` — the worker ' +
       'starts with no memory of your conversation.',
@@ -377,6 +383,17 @@ export function buildAgentTool(): LLMToolSpec {
           type: 'boolean',
           description: 'When true, returns the spawn handle immediately instead of waiting for completion. The child keeps running; its final message arrives in your next turn as a <task-notification> user message. Use for long-running explorations (multi-minute research, 10+ tool calls) so you can keep working in parallel.',
         },
+        completion_delivery: {
+          type: 'string',
+          enum: ['follow-up', 'supplement'],
+          description: 'Background-only routing. supplement adds one concise chat line when the child finishes and never opens a new TUI turn; follow-up keeps default result retrieval.',
+        },
+        budget_minutes: {
+          type: 'number',
+          minimum: 1,
+          maximum: 60,
+          description: 'Background-only best-effort wall-clock research budget. Ask the child to stop researching at this point and return currently verified evidence; default 8 minutes for supplement delivery.',
+        },
         wait_for_slot: {
           type: 'boolean',
           description: 'Only meaningful with run_in_background. When the per-session background fan-out ceiling is already full, this launch waits on the shared admission queue instead of being refused, and spawns as soon as one live background agent finishes. Waiting subagent spawns (ones that name a subagent_type) are admitted before general-purpose ones; launches with the same class keep arrival order. Omit it to get the immediate "NOT SPAWNED" refusal and re-issue later.',
@@ -423,6 +440,8 @@ export function buildAgentTool(): LLMToolSpec {
 }
 
 export interface DispatchAgentOpts {
+  /** Owning conversation session, copied to background completion receipts. */
+  parentSessionId?: string;
   /** Tools the host makes available — typically the same tool list the
    *  parent skill is using, MINUS the Agent tool itself (no recursion).
    *  When omitted, the sub-agent runs with no tools (text-only). */
@@ -439,6 +458,10 @@ export interface DispatchAgentOpts {
     dispatch: (name: string, args: Record<string, unknown>) => Promise<unknown>;
     workingDirectory: string;
   };
+  /** Allow the default general-purpose worker to inherit this host's catalog.
+   *  Opt-in for the TUI's policy-filtered catalog; CLI and MCP keep their
+   *  agent-definition allowlists unless they explicitly request inheritance. */
+  inheritGeneralPurposeToolCatalog?: boolean;
   /** Provider override (test stubs). When omitted, runner picks via
    *  agent definition's `model` field or parent default. */
   provider?: LLMProvider;
@@ -483,6 +506,8 @@ export interface DispatchAgentOpts {
   }) => void;
 }
 
+const BUILTIN_GENERAL_PURPOSE_DEFAULT_TOOLS = ['Bash', 'Read', 'Edit', 'Grep', 'WebFetch'] as const;
+
 export async function dispatchAgent(
   args: Record<string, unknown>,
   opts: DispatchAgentOpts = {},
@@ -507,6 +532,10 @@ export async function dispatchAgent(
 
   // PFC-S1 P1: new optional fields.
   const runInBackground = args.run_in_background === true;
+  const completionDelivery = args.completion_delivery === 'supplement' ? 'supplement' : 'follow-up';
+  const requestedBudgetMinutes = typeof args.budget_minutes === 'number' && Number.isFinite(args.budget_minutes)
+    ? Math.max(1, Math.min(60, Math.floor(args.budget_minutes)))
+    : (completionDelivery === 'supplement' ? 8 : undefined);
   const waitsForSlot = args.wait_for_slot === true;
   const spawnName = typeof args.name === 'string' && args.name.trim() ? args.name.trim() : undefined;
   const teamName = typeof args.team_name === 'string' && args.team_name.trim() ? args.team_name.trim() : undefined;
@@ -923,9 +952,12 @@ export async function dispatchAgent(
   }
 
   const hasNoTools = childTools.length === 0;
-  const childPrompt = hasNoTools
+  const budgetPrompt = runInBackground && completionDelivery === 'supplement' && requestedBudgetMinutes
+    ? `\n\n[Research time budget: ${requestedBudgetMinutes} minutes]\nReturn the best currently verified evidence within this budget. Do not wait for more sources or extend the research; state remaining uncertainty in the final message.`
+    : '';
+  const childPrompt = (hasNoTools
     ? `${prompt}\n\nNo tools are available; if a request requires reading files or executing commands, report that as unavailable rather than guessing.`
-    : prompt;
+    : prompt) + budgetPrompt;
 
   debug.log('agent.spawn', 'dispatch', {
     cid: debugCorrelationId,
@@ -935,14 +967,28 @@ export async function dispatchAgent(
     promptChars: childPrompt.length,
     model: definition.model || '(inherit)',
     maxTurns: requestedMaxTurns,
+    ...(runInBackground ? { completionDelivery, ...(requestedBudgetMinutes ? { researchBudgetMinutes: requestedBudgetMinutes } : {}) } : {}),
     tools: childTools.map(t => t.name),
     noTools: hasNoTools,
   });
 
+  // The built-in general-purpose definition's standard CLI allowlist is
+  // replaced only for TUI callers that explicitly opt into the already
+  // policy-filtered TUI catalog. MCP/CLI and user/project definitions keep
+  // their own allowlists.
+  const isBuiltinGeneralPurposeDefault = definition.name === 'general-purpose'
+    && definition.source === 'builtin'
+    && definition.tools?.length === BUILTIN_GENERAL_PURPOSE_DEFAULT_TOOLS.length
+    && BUILTIN_GENERAL_PURPOSE_DEFAULT_TOOLS.every((name, index) => definition.tools?.[index] === name);
+  const spawnDefinition = opts.inheritGeneralPurposeToolCatalog === true && isBuiltinGeneralPurposeDefault
+    ? { ...definition, tools: childTools.map(tool => tool.name) }
+    : definition;
+
   const startedAt = Date.now();
   const handle = globalAgentRegistry.spawn({
-    definition,
+    definition: spawnDefinition,
     prompt: childPrompt,
+    ...(opts.parentSessionId ? { parentSessionId: opts.parentSessionId } : {}),
     label: spawnName ?? description,   // PFC-S1 P1: explicit `name`
                           // wins, else fall back to the task label
                           // (kept for existing callers).
@@ -963,6 +1009,7 @@ export async function dispatchAgent(
     ...(teamName ? { teamName } : {}),
     ...(childCwd ? { cwd: childCwd } : {}),
     ...(runInBackground ? { background: true } : {}),
+    ...(runInBackground ? { completionDelivery } : {}),
   });
 
   // Terminal release for this dispatch's reserved fan-out slot: the

package/src/skills/tools/omni-search.ts

@@ -2,8 +2,8 @@
 //
 // Skill-essence extraction of ~/.claude/skills/omni-crawl/. Different
 // from WebSearch (cascade — first available wins): omni_search runs
-// EVERY available web-search provider in PARALLEL and merges their
-// hits, so the LLM gets a wider net for research-intent queries.
+// every selected provider in parallel and merges hits. Research dispatch
+// has a narrower Exa/Firecrawl allowlist; Grok is reserved for explicit X intent.
 //
 // Probe: at least 2 providers available. With only 1, plain WebSearch
 // is sufficient — no point paying the parallel-fan-out cost.
@@ -13,7 +13,7 @@
 //   by-engine   — group hits under per-provider headings
 
 import type { LLMToolSpec } from '../../llm.js';
-import { getAvailableWebSearchProviders } from '../../web-search/index.js';
+import { getAvailableResearchWebSearchProviders, getAvailableWebSearchProviders } from '../../web-search/index.js';
 import type { WebSearchHit } from '../../web-search/provider.js';
 
 export interface OmniSearchArgs {
@@ -43,6 +43,8 @@ export interface OmniSearchDispatchOpts {
   /** Observational only: callback failures must not interrupt a provider search. */
   onEngine?: (event: OmniSearchEngineEvent) => void;
   onSource?: (source: WebSearchHit & { engine: string }) => void;
+  /** Test seam for verifying that sequential research providers share one deadline. */
+  now?: () => number;
 }
 
 const DEFAULT_LIMIT = 5;
@@ -52,9 +54,9 @@ export function buildOmniSearchTool(): LLMToolSpec {
   return {
     name: 'OmniSearch',
     description:
-      'Multi-provider web search — fans out to every configured search provider in parallel and ' +
-      'merges hits. Wider coverage than WebSearch (cascade). Use for research-intent queries ' +
-      'where you want triangulation across Grok / Firecrawl / etc. Probe-gated: requires at ' +
+      'Multi-provider web search — fans out to configured search providers in parallel and ' +
+      'merges hits. Wider coverage than WebSearch (cascade). Research searches use bounded ' +
+      'Exa / Firecrawl routes; Grok is reserved for explicit X/Twitter intent. Probe-gated: requires at ' +
       'least 2 available providers (otherwise WebSearch already covers it).',
     parameters: {
       type: 'object',
@@ -73,16 +75,133 @@ export function buildOmniSearchTool(): LLMToolSpec {
   };
 }
 
+const RESEARCH_SEARCH_BUDGET_MS = 14_500;
+const RESEARCH_WEB_FALLBACK_IDS = ['exa', 'firecrawl'];
+const RESEARCH_EXA_TIMEOUT_MS = 4_500;
+const researchHits = new WeakMap<OmniSearchResult, Record<string, WebSearchHit[]>>();
+
 export async function dispatchOmniSearch(
   rawArgs: Record<string, unknown>,
   opts: OmniSearchDispatchOpts = {},
 ): Promise<OmniSearchResult> {
   const args = validate(rawArgs);
+  const allowed = getAvailableResearchProviders();
+  const requested = args.engines === undefined ? undefined : new Set(args.engines.map(id => id.toLowerCase()));
+  const providers = requested === undefined
+    ? allowed
+    : allowed.filter(provider => requested.has(provider.id.toLowerCase()));
+  return dispatchWithProviders(args, opts, providers);
+}
+
+export async function dispatchResearchOmniSearch(
+  rawArgs: Record<string, unknown>,
+  opts: OmniSearchDispatchOpts = {},
+): Promise<OmniSearchResult> {
+  const args = validate(rawArgs);
+  const now = opts.now ?? Date.now;
+  const deadlineAt = now() + RESEARCH_SEARCH_BUDGET_MS;
+  const selected = getAvailableResearchProviders();
+  const requested = args.engines === undefined ? undefined : new Set(args.engines.map(id => id.toLowerCase()));
+  const providers = requested === undefined
+    ? selected
+    : selected.filter(provider => requested.has(provider.id.toLowerCase()));
+  const webFallback = providers.filter(provider => RESEARCH_WEB_FALLBACK_IDS.includes(provider.id));
+  const webResult = await dispatchResearchWebFallback(args, opts, webFallback, deadlineAt);
+  return combineResearchResults(args, emptyOmniSearchResult(args), webResult);
+}
+
+function emptyOmniSearchResult(args: OmniSearchArgs): OmniSearchResult {
+  const result: OmniSearchResult = {
+    output: '',
+    metadata: { perEngine: {}, totalHits: 0, merge: args.merge ?? 'interleave' },
+  };
+  researchHits.set(result, {});
+  return result;
+}
+
+async function dispatchResearchWebFallback(
+  args: OmniSearchArgs,
+  opts: OmniSearchDispatchOpts,
+  providers: ReturnType<typeof getAvailableWebSearchProviders>,
+  deadlineAt: number,
+): Promise<OmniSearchResult> {
+  const accumulated = emptyOmniSearchResult(args);
+  for (const provider of providers) {
+    const result = await dispatchWithProviders(args, opts, [provider], {
+      deadlineAt,
+      now: opts.now ?? Date.now,
+    });
+    Object.assign(accumulated.metadata.perEngine, result.metadata.perEngine);
+    accumulated.metadata.totalHits += result.metadata.totalHits;
+    accumulated.output += accumulated.output && result.output ? `\n\n${result.output}` : result.output;
+    Object.assign(researchHits.get(accumulated)!, researchHits.get(result));
+    const details = result.metadata.perEngine[provider.id];
+    // A successful but empty response is no usable research evidence, so continue to the next provider.
+    if (details && !details.error && details.hits > 0) break;
+  }
+  return accumulated;
+}
+
+function combineResearchResults(
+  args: OmniSearchArgs,
+  grokResult: OmniSearchResult,
+  webResult: OmniSearchResult,
+): OmniSearchResult {
+  const perEngine = { ...grokResult.metadata.perEngine, ...webResult.metadata.perEngine };
+  const hitsByEngine = { ...researchHits.get(grokResult), ...researchHits.get(webResult) };
+  const merge = args.merge ?? 'interleave';
+  const limit = Math.max(1, Math.min(args.limit ?? DEFAULT_LIMIT, MAX_LIMIT));
+  const merged = (merge === 'interleave'
+    ? interleaveHits(Object.fromEntries(Object.entries(hitsByEngine).map(([id, hits]) => [id, { hits }])))
+    : groupByEngine(Object.fromEntries(Object.entries(hitsByEngine).map(([id, hits]) => [id, { hits }]))))
+    .slice(0, limit);
+  const selectedByEngine = new Map<string, WebSearchHit[]>();
+  for (const [id, hits] of Object.entries(hitsByEngine)) selectedByEngine.set(id, []);
+  // Keep merge order for the global limit while retaining each source heading.
+  for (const hit of merged) {
+    const id = Object.keys(hitsByEngine).find(engine => hitsByEngine[engine]!.includes(hit));
+    if (id) selectedByEngine.get(id)!.push(hit);
+  }
+  const output: string[] = [`omni_search "${args.query}" — ${merged.length} hits across ${Object.keys(perEngine).length} provider${Object.keys(perEngine).length === 1 ? '' : 's'}`];
+  for (const [id, info] of Object.entries(perEngine)) {
+    output.push(`  ${id}: ${selectedByEngine.get(id)?.length ?? 0} hits in ${info.durationMs}ms${info.error ? ` ERROR: ${info.error}` : ''}`);
+  }
+  output.push('');
+  if (merge === 'by-engine') {
+    for (const [id, hits] of selectedByEngine) {
+      if (hits.length === 0) continue;
+      output.push(`## ${id}`);
+      for (const hit of hits) output.push(formatHit(hit));
+      output.push('');
+    }
+  } else {
+    for (const hit of merged) output.push(formatHit(hit));
+  }
+  const result: OmniSearchResult = {
+    output: output.join('\n'),
+    metadata: {
+      perEngine: Object.fromEntries(Object.entries(perEngine).map(([id, info]) => [id, {
+        ...info, hits: selectedByEngine.get(id)?.length ?? 0,
+      }])),
+      totalHits: merged.length,
+      merge,
+    },
+  };
+  researchHits.set(result, hitsByEngine);
+  return result;
+}
+
+async function dispatchWithProviders(
+  args: OmniSearchArgs,
+  opts: OmniSearchDispatchOpts,
+  selectedProviders?: ReturnType<typeof getAvailableWebSearchProviders>,
+  researchLimits?: { deadlineAt: number; now: () => number },
+): Promise<OmniSearchResult> {
   const merge = args.merge ?? 'interleave';
   const limit = Math.max(1, Math.min(args.limit ?? DEFAULT_LIMIT, MAX_LIMIT));
 
-  let providers = getAvailableWebSearchProviders();
-  if (args.engines && args.engines.length > 0) {
+  let providers = selectedProviders ?? getAvailableWebSearchProviders();
+  if (!selectedProviders && args.engines && args.engines.length > 0) {
     const wanted = new Set(args.engines.map(e => e.toLowerCase()));
     providers = providers.filter(p => wanted.has(p.id.toLowerCase()));
   }
@@ -105,13 +224,38 @@ export async function dispatchOmniSearch(
     const start = Date.now();
     emit({ engine: p.id, phase: 'start' });
     try {
-      const result = await p.search({
+      const query = {
         query: args.query,
         limit,
         allowDomains: args.allow_domains,
         blockDomains: args.block_domains,
         recencyDays: args.recency_days,
-      });
+      };
+      let result;
+      if (researchLimits) {
+        const remainingMs = researchLimits.deadlineAt - researchLimits.now();
+        const timeoutMs = p.id === 'exa'
+          ? Math.min(RESEARCH_EXA_TIMEOUT_MS, remainingMs)
+          : remainingMs;
+        if (timeoutMs <= 0) throw new DOMException('Research search budget exhausted', 'TimeoutError');
+        const controller = new AbortController();
+        let timer: ReturnType<typeof setTimeout> | undefined;
+        try {
+          result = await Promise.race([
+            p.search(query, controller.signal),
+            new Promise<never>((_, reject) => {
+              timer = setTimeout(() => {
+                controller.abort();
+                reject(new DOMException(`Research search timed out after ${timeoutMs}ms`, 'TimeoutError'));
+              }, timeoutMs);
+            }),
+          ]);
+        } finally {
+          if (timer !== undefined) clearTimeout(timer);
+        }
+      } else {
+        result = await p.search(query);
+      }
       perEngine[p.id] = { hits: result.hits, durationMs: Date.now() - start };
       for (const hit of result.hits) {
         try {
@@ -153,7 +297,7 @@ export async function dispatchOmniSearch(
     for (const h of merged) lines.push(formatHit(h));
   }
 
-  return {
+  const result: OmniSearchResult = {
     output: lines.join('\n'),
     metadata: {
       perEngine: Object.fromEntries(Object.entries(perEngine).map(([k, v]) => [k, {
@@ -163,11 +307,27 @@ export async function dispatchOmniSearch(
       merge,
     },
   };
+  researchHits.set(result, Object.fromEntries(Object.entries(perEngine).map(([id, info]) => [id, info.hits])));
+  return result;
 }
 
-/** Probe-compatible: at least 2 search providers available. */
+/** Probe-compatible: at least 2 Exa/Firecrawl providers available for omni_search. */
 export function omniSearchAvailable(): boolean {
-  return getAvailableWebSearchProviders().length >= 2;
+  return getAvailableResearchProviders().length >= 2;
+}
+
+/** Research-only probe: require one bounded Exa/Firecrawl web route. */
+export function researchOmniSearchAvailable(): boolean {
+  return getAvailableResearchProviders().some(provider => RESEARCH_WEB_FALLBACK_IDS.includes(provider.id));
+}
+
+export function getAvailableResearchSearchEngineIds(): string[] {
+  return getAvailableResearchProviders().map(provider => provider.id);
+}
+
+function getAvailableResearchProviders(): ReturnType<typeof getAvailableWebSearchProviders> {
+  const available = getAvailableResearchWebSearchProviders();
+  return RESEARCH_WEB_FALLBACK_IDS.flatMap(id => available.filter(provider => provider.id === id));
 }
 
 function interleaveHits(perEngine: Record<string, { hits: WebSearchHit[] }>): WebSearchHit[] {

package/src/task-agent/parent-host.ts

@@ -582,6 +582,16 @@ export function installRemoteCodexAccessBatch(target: ParentHostConfig, mirrors:
   if (result.status !== 0) throw new Error(`remote Codex access mirror batch failed (ssh rc=${result.status ?? 'unknown'})`);
 }
 
+/** Install the same refresh-free snapshot for direct CLI use, outside per-launch parent credentials. */
+export const REMOTE_CODEX_CLI_MIRROR_DIR = '$HOME/.elanous/remote-parent-credentials/cli-mirror';
+export function installRemoteCodexCliMirror(
+  target: ParentHostConfig,
+  mirrors: readonly { elanousAuth: string; codexAuth: string; account: string }[],
+  ssh: SshRunner = defaultSshRunner,
+): void {
+  installRemoteCodexAccessBatch({ ...target, configDir: REMOTE_CODEX_CLI_MIRROR_DIR }, mirrors, ssh);
+}
+
 // ── 관측: 원격 런 원장 거울 ─────────────────────────────────────────────────────────────
 
 const RUN_ID_RE = /^run-[A-Za-z0-9_-]{4,64}$/;

package/src/task-agent/pod-distributor-entry.ts

@@ -0,0 +1,3 @@
+/** Caller-side marker for the tasks-hand Pod admission path. It is not passed into the child Pod. */
+export const POD_DISTRIBUTOR_ENTRY_ENV = 'ELANOUS_POD_DISTRIBUTOR_ENTRY';
+export const TASK_HAND_POD_DISTRIBUTOR_ENTRY = 'tasks-hand';

package/src/task-agent/repair-outcomes.ts

@@ -27,3 +27,68 @@ export function measureRepairOutcomes(cards: readonly Pick<TaskCard, 'id' | 'his
   }
   return { ...counts, cards: affected.size };
 }
+
+export interface RepairTierModelCall {
+  card: string;
+  runId: string;
+  at: string;
+  tier: string;
+  model: string;
+  status: string;
+}
+
+/** Measure repair launch records in the requested window; missing dimensions stay explicit. */
+export function measureRepairTierModels(
+  cards: readonly Pick<TaskCard, 'id' | 'history' | 'repairs' | 'tier'>[],
+  window: { since: number; until: number },
+) {
+  const attempts = new Map<string, RepairTierModelCall & { called: boolean }>();
+  let invalidTimestamp = 0;
+  let missingRunId = 0;
+  for (const card of cards) {
+    for (const repair of card.repairs ?? []) {
+      const at = Date.parse(repair.at);
+      if (!Number.isFinite(at)) { invalidTimestamp++; continue; }
+      if (at < window.since || at >= window.until) continue;
+      if (!repair.runId) { missingRunId++; continue; }
+      const key = `${card.id}\0${repair.runId}`;
+      const previous = attempts.get(key);
+      if (previous && Date.parse(previous.at) > at) continue;
+      const called = card.history.some((entry) => entry.runId === repair.runId
+        && (entry.event === 'harness.role-llm' || entry.event === 'repair-result'));
+      attempts.set(key, {
+        card: card.id,
+        runId: repair.runId,
+        at: repair.at,
+        tier: card.tier ?? 'unknown',
+        model: repair.toModel || 'unknown',
+        status: repair.status,
+        called,
+      });
+    }
+  }
+  const rows = [...attempts.values()].sort((a, b) => a.at.localeCompare(b.at) || a.card.localeCompare(b.card) || a.runId.localeCompare(b.runId));
+  const grouped = new Map<string, number>();
+  for (const row of rows) {
+    const key = `${row.tier}\0${row.model}`;
+    grouped.set(key, (grouped.get(key) ?? 0) + 1);
+  }
+  const tiers = ['하', '중', '상', '특', ...(rows.some((row) => !['하', '중', '상', '특'].includes(row.tier)) ? ['unknown'] : [])];
+  const models = [...new Set([...rows.map((row) => row.model), 'openai-codex/gpt-6-sol'])];
+  const byTierModel = tiers.flatMap((tier) => models.map((model) => {
+    const observedN = grouped.get(`${tier}\0${model}`) ?? 0;
+    return { tier, model, n: observedN || null, measured: observedN > 0, observedN };
+  })).sort((a, b) => a.tier.localeCompare(b.tier) || a.model.localeCompare(b.model));
+  const publicRow = ({ called: _called, ...row }: RepairTierModelCall & { called: boolean }): RepairTierModelCall => row;
+  const solRows = rows.filter((row) => row.model.includes('gpt-6-sol'));
+  return {
+    samples: rows.length,
+    measured: rows.length > 0,
+    unmeasuredReason: rows.length ? null : 'no repair attempts in the requested window',
+    byTierModel,
+    solCalls: solRows.filter((row) => row.called).map(publicRow),
+    solCallUnmeasured: solRows.filter((row) => !row.called).map(publicRow),
+    invalidTimestamp,
+    missingRunId,
+  };
+}

package/src/task-agent/task-hand.ts

@@ -15,6 +15,7 @@ import { fileURLToPath } from 'node:url';
 import { parse as parseYaml } from 'yaml';
 import { runGraph, validateUnitCalls, type GraphRunOptions, type GraphRunState } from '../graph-runner/runner.js';
 import type { GraphWizardDeps } from '../graph-wizard/generate.js';
+import type { PluginWizardDeps, PluginWizardInput } from '../graph-wizard/mission-compose.js';
 import { parseGraphTemplateYaml } from '../self-implement/graph-yaml.js';
 import { resolveDaemonHarnessTarget } from '../intake-plane/harness-target.js';
 import { getUserConfig } from '../user-config.js';
@@ -29,10 +30,12 @@ import { checkCompletionEvidence, deliverableReceiptEvidence } from './completio
 import { judgeNextMove } from './judge.js';
 import { checklistDevVersion, listChecklist } from '../release-loop/checklist.js';
 import { loadRunLedger, runLedgerDir } from '../self-implement/run-ledger.js';
+import { POD_DISTRIBUTOR_ENTRY_ENV, TASK_HAND_POD_DISTRIBUTOR_ENTRY } from './pod-distributor-entry.js';
 // Keep doctor-visit recording synchronous: updateTaskCard callers observe it before the transition returns.
 import { recordTaskAgentNeedsOwnerVisit } from '../self-implement/doctor-visit.js';
 import { applyRunIdentityTag, applyRunIdentityTags, deriveBirthIdentity, parseRunIdentityTag, runIdentityFieldText, runIdentityQueuePriority, runPriorityClass, validateRunIdentity, type RunIdentity, type RunIdentityCell, type RunIdentityOrigin } from './run-identity.js';
 import { parseWorkOrder, renderWorkOrderGoal, WORK_ORDER_FILE_PATTERN, type WorkOrder } from './work-order.js';
+import { recordCoordinatorShadowDispatch, resolveCoordinatorShadowRoot } from '../loops/orchestrator/coordinator-shadow.js';
 import { inspectPrelaunchAlreadyDone, type AlreadyDoneDecision, type AlreadyDoneCandidate,
   type PrelaunchGitRunnerForTest } from './prelaunch-already-done.js';
 import { draftClaimComment, draftClaimRecordLive, draftClaimState, draftReleaseComment } from '../self-dev/draft-triage-rules.js';
@@ -190,15 +193,19 @@ export const COMPOSITION_ROOT = join(dirname(fileURLToPath(import.meta.url)), '.
 export function selectTaskComposition(completion: CompletionKind, root?: string): CompositionSelection;
 export function selectTaskComposition(completion: CompletionKind, root: string, mission: {
   text: string; ledgerPath: string; cardId: string; callLLM?: GraphWizardDeps['callLLM']; onPersist?: (persist: () => void) => void;
+  pluginWizard?: PluginWizardInput; pluginWizardDeps?: PluginWizardDeps;
 }): Promise<CompositionSelection>;
 export function selectTaskComposition(completion: CompletionKind, root = COMPOSITION_ROOT, mission?: {
   text: string; ledgerPath: string; cardId: string; callLLM?: GraphWizardDeps['callLLM']; onPersist?: (persist: () => void) => void;
+  pluginWizard?: PluginWizardInput; pluginWizardDeps?: PluginWizardDeps;
 }): CompositionSelection | Promise<CompositionSelection> {
   if (mission) {
     const standard = selectTaskComposition(completion, root);
     return import('../graph-wizard/mission-compose.js').then(async ({ composeMissionGraph }) => {
       const result = await composeMissionGraph({ text: mission.text, completion, root, ledgerPath: mission.ledgerPath,
-        cardId: mission.cardId, standard }, { callLLM: mission.callLLM, deferPersistence: mission.onPersist !== undefined });
+        cardId: mission.cardId, standard, ...(mission.pluginWizard ? { pluginWizard: mission.pluginWizard } : {}) },
+      { callLLM: mission.callLLM, deferPersistence: mission.onPersist !== undefined,
+        ...(mission.pluginWizardDeps ? { pluginWizard: mission.pluginWizardDeps } : {}) });
       mission.onPersist?.(result.persist);
       return result.selection;
     });
@@ -1089,6 +1096,10 @@ export type TaskLauncher = (args: string[], cwd?: string, context?: TaskLaunchCo
 export interface HandTaskOptions {
   text: string;
   seat?: TaskSeat;
+  /** Validated order parsed by the CLI; its canonical rendering is used only for shadow evidence. */
+  workOrder?: WorkOrder;
+  /** Repository root for shadow dispatch evidence; production defaults to the invoking repository. */
+  coordinatorShadowRoot?: string;
   checklistId?: string;
   completion?: TaskCard['completion'];
   /** `--project <id> --target <dir>` — target 은 존재 확인 뒤 절대 경로로 바꿔 싣는다. */
@@ -1129,6 +1140,10 @@ export interface HandTaskOptions {
   composeGraph?: boolean;
   /** Injectable LLM boundary for isolated composition tests. */
   composeCallLLM?: GraphWizardDeps['callLLM'];
+  /** Explicit missing-tool handoff from the active assistant; keeps the wizard opt-in and uses the same task graph path. */
+  pluginWizard?: Omit<PluginWizardInput, 'mission' | 'root'> & { root?: string };
+  /** Host surfaces for Telegram, side-tab agents, trial/use, and progress reporting. */
+  pluginWizardDeps?: PluginWizardDeps;
   /** `--live` 일 때만 불린다. */
   launcher?: TaskLauncher;
   /**
@@ -1183,7 +1198,7 @@ export class TaskLaunchError extends Error {
   }
 }
 
-export interface HandTaskResult { card: TaskCard; move: TaskCardMove; mode: 'shadow' | 'live'; launched: boolean; cwd?: string }
+export interface HandTaskResult { card: TaskCard; move: TaskCardMove; mode: 'shadow' | 'live'; launched: boolean; reason?: string; cwd?: string }
 
 /** Dispatch evidence for a handed deliverable card; unlike handTask, this never launches work. */
 export function dispatchDeliverableCompletion(id: string, input: { ref: string; receipt?: boolean }, path: string, now: () => Date = () => new Date()): boolean {
@@ -1329,9 +1344,12 @@ export async function handTask(opts: HandTaskOptions): Promise<HandTaskResult> {
     })
     : undefined;
   let persistComposition: (() => void) | undefined;
-  const selected = (opts.composeGraph ?? (process.env.ELANOUS_MISSION_GRAPH_COMPOSE === '1'))
+  const pluginWizard = opts.pluginWizard ? { ...opts.pluginWizard, mission: text,
+    root: opts.pluginWizard.root ?? opts.compositionRoot ?? COMPOSITION_ROOT } : undefined;
+  const selected = (pluginWizard !== undefined || (opts.composeGraph ?? (process.env.ELANOUS_MISSION_GRAPH_COMPOSE === '1')))
     ? await selectTaskComposition(completion, opts.compositionRoot ?? COMPOSITION_ROOT,
       { text, ledgerPath: path, cardId: id, callLLM: opts.composeCallLLM,
+        ...(pluginWizard ? { pluginWizard, pluginWizardDeps: opts.pluginWizardDeps } : {}),
         onPersist: persist => { persistComposition = persist; } })
     : selectTaskComposition(completion, opts.compositionRoot);
   // 2판 — launcher 'graph-run' 조합(단위 해석까지 완료)은 실제 graph run 으로 발사한다. 더 이상 거부하지 않는다.
@@ -1598,11 +1616,12 @@ export async function handTask(opts: HandTaskOptions): Promise<HandTaskResult> {
       reason: knowhow.reason, repoPath: knowhowRepo, repoRevision,
       repoSource: project ? 'project' : configuredRepo ? 'harness.defaultRepo' : 'package' }); } catch { /* fail-soft */ }
   }
-  // LAUNCH-SINGLE-DOOR-1C — 발사 직전 단일문: 모든 요청(중복 포함)은 원장에 append 되고, 소비 영수증은
-  // requestId 단위로 최초 1회만 발급된다. 주입된 문이 없으면 생산 우주의 기본 문을 쓴다(시험 환경은 건너뛴다).
+  // LAUNCH-SINGLE-DOOR — hand 재시도는 새 카드/시도이므로 문면만으로 만든 영구 requestId 를 재사용하지 않는다.
+  // 실제 실행 중인 같은 골은 자식 harness 의 active-run gate 가 막는다. 부모 영수증은 그 자식에 한 번 상속한다.
   const launchDoor = opts.launchRequestDoor
     ?? (process.env.NODE_ENV === 'test' ? undefined : openLaunchRequestDoor({ source: 'hand' }));
-  const launchDoorRequestId = launchDoor?.requestId(card.text);
+  const launchAttemptKey = `${card.id}\n${card.createdAt}\n${randomBytes(12).toString('hex')}\n${card.text}`;
+  const launchDoorRequestId = launchDoor?.requestId(launchAttemptKey);
   let inheritedLaunchDoorReceipt: string | undefined;
   if (launchDoor !== undefined && launchDoorRequestId !== undefined) {
     const doorConsumption = launchDoor.consume(launchDoorRequestId);
@@ -1611,7 +1630,7 @@ export async function handTask(opts: HandTaskOptions): Promise<HandTaskResult> {
       const refused: TaskCard = { ...card, history: [...card.history, { at, event: LAUNCH_REFUSED_DUPLICATE_EVENT, detail: doorConsumption.reason }] };
       writeCard(path, refused);
       try { debug.log('task-agent', 'launch-refused-duplicate', { taskId: id, requestId: launchDoorRequestId, reason: doorConsumption.reason }); } catch { /* fail-soft */ }
-      return { card: refused, move, mode, launched: false, ...(project ? { cwd: project.target } : {}) };
+      return { card: refused, move, mode, launched: false, reason: `${LAUNCH_REFUSED_DUPLICATE_EVENT}: ${doorConsumption.reason}`, ...(project ? { cwd: project.target } : {}) };
     }
     // 소비 영수증을 자식 say 에 물려줘 그 문을 다시 두드리지 않게 한다(한 번만 상속).
     inheritedLaunchDoorReceipt = doorConsumption.status === 'consumed' ? launchDoorRequestId : undefined;
@@ -1625,6 +1644,7 @@ export async function handTask(opts: HandTaskOptions): Promise<HandTaskResult> {
     ...(cardPrNumber(card) ? { ELANOUS_TASK_BOUND_PR: String(cardPrNumber(card)) } : {}),
     ...(card.checklistId ? { ELANOUS_POD_SLOT_ID: card.checklistId } : {}),
     ...(card.seat ? { ELANOUS_POD_OWNER_KIND: 'seat', ELANOUS_POD_OWNER_ID: card.seat } : {}),
+    ...(podLaunch ? { [POD_DISTRIBUTOR_ENTRY_ENV]: TASK_HAND_POD_DISTRIBUTOR_ENTRY } : {}),
     ...(card.taLand ? { [TA_LAND_ENV]: '1' } : {}) }, cardLabelContext: taskCardLabelContext(card),
     // An omitted card provider uses the established Pod default. Carry the effective value explicitly so
     // remote-parent code never has to infer a provider from the serialized CLI argv.
@@ -1645,6 +1665,26 @@ export async function handTask(opts: HandTaskOptions): Promise<HandTaskResult> {
     try { debug.log('task-agent', 'launch-failed', { taskId: id, seat: card.seat ?? null, reason }); } catch { /* fail-soft */ }
     throw new TaskLaunchError(failed, reason);
   }
+  // Record only an accepted dispatch: failed launcher attempts must not create a three-day retirement signal.
+  if (opts.workOrder !== undefined) {
+    const agent = process.env.ELANOUS_SEAT?.trim() || process.env.AI_AGENT?.trim();
+    if (agent) {
+      try {
+        const directive = createHash('sha256').update(renderWorkOrderGoal(opts.workOrder)).digest('hex');
+        recordCoordinatorShadowDispatch(resolveCoordinatorShadowRoot(opts.coordinatorShadowRoot ?? process.cwd()), {
+          date: (opts.now ?? (() => new Date()))().toISOString().slice(0, 10),
+          agent,
+          ...(opts.seat ? { recipient: opts.seat } : {}),
+          cell: opts.workOrder.cellId,
+          directive,
+        });
+      } catch (error) {
+        try { debug.log('task-agent.work-order', 'shadow-dispatch-record-failed', {
+          cellId: opts.workOrder.cellId, reason: error instanceof Error ? error.message : String(error),
+        }, { level: 'warn' }); } catch { /* shadow evidence is fail-soft */ }
+      }
+    }
+  }
   const launchedAt = (opts.now ?? (() => new Date()))().toISOString();
   const receivedRunId = receipt && typeof receipt.runId === 'string' ? receipt.runId.trim() : '';
   // 넘긴 런 id 와 «같은» 영수증만 — 다른 id 면 env 로 넘긴 런과 카드가 어긋난다(묶지 않는다).