elanous 0.2.41 → 0.2.42

package/src/skills/tools/agent.ts

@@ -271,6 +271,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,6 +353,7 @@ 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 ' +
       'turn budget (default 20). It returns ONE final message which becomes your tool_result. ' +
@@ -377,6 +382,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 +439,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). */
@@ -507,6 +525,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 +945,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,6 +960,7 @@ 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,
   });
@@ -943,6 +969,7 @@ export async function dispatchAgent(
   const handle = globalAgentRegistry.spawn({
     definition,
     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 +990,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

@@ -73,16 +73,39 @@ export function buildOmniSearchTool(): LLMToolSpec {
   };
 }
 
+const RESEARCH_GROK_TIMEOUT_MS = 8_000;
+
 export async function dispatchOmniSearch(
   rawArgs: Record<string, unknown>,
   opts: OmniSearchDispatchOpts = {},
+): Promise<OmniSearchResult> {
+  return dispatchWithProviders(validate(rawArgs), opts);
+}
+
+export async function dispatchResearchOmniSearch(
+  rawArgs: Record<string, unknown>,
+  opts: OmniSearchDispatchOpts = {},
 ): Promise<OmniSearchResult> {
   const args = validate(rawArgs);
+  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()));
+  return dispatchWithProviders(args, opts, providers, { grokTimeoutMs: RESEARCH_GROK_TIMEOUT_MS });
+}
+
+async function dispatchWithProviders(
+  args: OmniSearchArgs,
+  opts: OmniSearchDispatchOpts,
+  selectedProviders?: ReturnType<typeof getAvailableWebSearchProviders>,
+  researchLimits?: { grokTimeoutMs: 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 +128,33 @@ 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 && (p.id === 'grok' || p.id === 'grok-api')) {
+        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(`Grok research search timed out after ${researchLimits.grokTimeoutMs}ms`, 'TimeoutError'));
+              }, researchLimits.grokTimeoutMs);
+            }),
+          ]);
+        } 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 {
@@ -165,11 +208,30 @@ export async function dispatchOmniSearch(
   };
 }
 
-/** Probe-compatible: at least 2 search providers available. */
+/** Probe-compatible: at least 2 search providers available for ordinary omni_search. */
 export function omniSearchAvailable(): boolean {
   return getAvailableWebSearchProviders().length >= 2;
 }
 
+/** Research-only probe: require the bounded Grok/Firecrawl research pair. */
+export function researchOmniSearchAvailable(): boolean {
+  return getAvailableResearchProviders().length >= 2;
+}
+
+export function getAvailableResearchSearchEngineIds(): string[] {
+  return getAvailableResearchProviders().map(provider => provider.id);
+}
+
+function getAvailableResearchProviders(): ReturnType<typeof getAvailableWebSearchProviders> {
+  const available = getAvailableWebSearchProviders();
+  const grok = available.find(provider => provider.id === 'grok')
+    ?? available.find(provider => provider.id === 'grok-api');
+  return [
+    ...(grok ? [grok] : []),
+    ...available.filter(provider => provider.id === 'firecrawl'),
+  ];
+}
+
 function interleaveHits(perEngine: Record<string, { hits: WebSearchHit[] }>): WebSearchHit[] {
   const lists = Object.values(perEngine).map(v => v.hits.slice());
   const merged: WebSearchHit[] = [];

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/task-hand.ts

@@ -29,10 +29,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';
@@ -1089,6 +1091,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 은 존재 확인 뒤 절대 경로로 바꿔 싣는다. */
@@ -1625,6 +1631,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 +1652,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 로 넘긴 런과 카드가 어긋난다(묶지 않는다).

package/src/task-orchestrator/surfaces/pod-distributor.ts

@@ -0,0 +1,48 @@
+import type { PodPoolMember, PodPoolScheduler } from './pod-pool.js';
+export { POD_DISTRIBUTOR_ENTRY_ENV, TASK_HAND_POD_DISTRIBUTOR_ENTRY } from '../../task-agent/pod-distributor-entry.js';
+import { TASK_HAND_POD_DISTRIBUTOR_ENTRY } from '../../task-agent/pod-distributor-entry.js';
+
+/** Origin marker carried only by `tasks hand` Pod launches. */
+export type PodPoolAcquireMode = NonNullable<Parameters<PodPoolScheduler['tryAcquire']>[2]>;
+
+/** Admission context that the later resource-core adapter can map to its request contract. */
+export interface PodDistributorAdmission {
+  requestId: string;
+  idempotencyKey: string;
+  owner: { runId: string; cardId?: string; seat?: string };
+  lane: 'ta';
+  workload: { memoryLimit: string; kind: string };
+  skip?: ReadonlySet<string>;
+  onEmpty?: (reason: string) => void;
+  mode?: PodPoolAcquireMode;
+}
+
+/**
+ * Small seam between a Pod launch surface and its admission backend.
+ * The current adapter delegates to PodPoolScheduler, which owns the existing HostPoolLease accounting.
+ * CORE can replace this adapter with resource admission without changing the tasks-hand call site.
+ */
+export interface PodDistributorAdapter {
+  acquire(request: PodDistributorAdmission): Promise<PodPoolMember | null>;
+}
+
+export function createPodPoolDistributorAdapter(pool: PodPoolScheduler): PodDistributorAdapter {
+  // The legacy pool has no consumer for identity/workload fields; preserve them at this seam for CORE.
+  return {
+    acquire: ({ skip, onEmpty, mode }) => pool.tryAcquire(skip, onEmpty, mode),
+  };
+}
+
+/** Only the tasks-hand entry uses the adapter in this first wire slice; other launchers keep the established path. */
+export function acquirePodPoolSlot(input: {
+  entry: string | undefined;
+  pool: PodPoolScheduler;
+  adapter?: PodDistributorAdapter;
+  request: PodDistributorAdmission;
+}): Promise<PodPoolMember | null> {
+  const { entry, pool, adapter, request } = input;
+  if (entry === TASK_HAND_POD_DISTRIBUTOR_ENTRY) {
+    return (adapter ?? createPodPoolDistributorAdapter(pool)).acquire(request);
+  }
+  return pool.tryAcquire(request.skip, request.onEmpty, request.mode);
+}

package/src/task-orchestrator/surfaces/pod-ledger-collect.ts

@@ -184,6 +184,37 @@ export function createPodLedgerFollower(opts: {
   if (!Number.isFinite(stallMinutes) || stallMinutes <= 0) throw new RangeError('stallMinutes must be positive');
   const onStall = opts.onStall ?? ((message: string) => console.error(message));
   const path = runLedgerPath(opts.runId, dir);   // runId 검증(경로·셸에 안전한 문자만)도 여기서 된다
+  function activityTimestamp(epoch: number): string {
+    const iso = new Date(Math.floor(epoch / 1_000) * 1_000).toISOString();
+    return `${iso.slice(0, 4)}${iso.slice(5, 7)}${iso.slice(8, 10)}${iso.slice(11, 13)}${iso.slice(14, 16)}.${iso.slice(17, 19)}`;
+  }
+  function activityCommand(since: string, until: string, offset: number, sinceTimestamp: string, untilTimestamp: string): string {
+    return [
+      `s="\${ELANOUS_STATE_DIR:-$HOME/.elanous}"`,
+      `f="$s/run-ledger/${opts.runId}.jsonl"`,
+      'w="$s/worktrees"',
+      'if [ -f "$f" ]; then tail -c +' + (offset + 1) + ' "$f" || exit 1; fi',
+      "target=''; matches=0",
+      'for tree in "$w"/*/*.worktrees/*; do',
+      '  [ -e "$tree/.git" ] || continue',
+      '  owner=$(git -C "$tree" config --worktree --get elanous.harness.owner 2>/dev/null) || continue',
+      `  [ "$owner" = 'dev:${opts.runId}' ] || continue`,
+      '  target="$tree"; matches=$((matches + 1))',
+      'done',
+      'if [ "$matches" -eq 1 ]; then',
+      '  touch_activity_ref() { stamp_value=$1; fallback=$2; ref=$3; touch -d "@$stamp_value" "$ref" 2>/dev/null && return 0; TZ=UTC touch -t "$fallback" "$ref"; }',
+      `  activity_since="$s/.pod-activity-${opts.runId}-$$-since"`,
+      `  activity_until="$s/.pod-activity-${opts.runId}-$$-until"`,
+      "  activity=''",
+      `  if : > "$activity_since" && : > "$activity_until" && touch_activity_ref '${since}' '${sinceTimestamp}' "$activity_since" && touch_activity_ref '${until}' '${untilTimestamp}' "$activity_until"; then`,
+      '    activity=$(find "$target" -type d \\( -name .git -o -name node_modules \\) -prune -o -type f -newer "$activity_since" ! -newer "$activity_until" -exec printf . \\; 2>/dev/null)',
+      '    activity_status=$?',
+      '  else activity_status=1; fi',
+      '  rm -f "$activity_since" "$activity_until"',
+      '  if [ "$activity_status" -eq 0 ]; then printf \'\\nELANOUS_ACTIVITY %s\\n\' "\${#activity}"; else printf \'\\nELANOUS_ACTIVITY_ERROR\\n\'; fi',
+      "else printf '\\nELANOUS_ACTIVITY_ERROR\\n'; fi",
+    ].join('\n');
+  }
   let offset = 0;
   let pending = '';
   let owned = false;
@@ -218,7 +249,13 @@ export function createPodLedgerFollower(opts: {
       const since = `${Math.floor(lastActivityMeasuredAt / 1000)}.${String(lastActivityMeasuredAt % 1000).padStart(3, '0')}`;
       const measurementStartedAt = now();
       const until = `${Math.floor(measurementStartedAt / 1000)}.${String(measurementStartedAt % 1000).padStart(3, '0')}`;
-      const r = opts.exec(`s="\${ELANOUS_STATE_DIR:-$HOME/.elanous}"; f="$s/run-ledger/${opts.runId}.jsonl"; w="$s/worktrees"; if [ -f "$f" ]; then tail -c +${offset + 1} "$f" || exit 1; fi; target=''; matches=0; for tree in "$w"/*/*.worktrees/*; do [ -e "$tree/.git" ] || continue; owner=$(git -C "$tree" config --worktree --get elanous.harness.owner 2>/dev/null) || continue; [ "$owner" = 'dev:${opts.runId}' ] || continue; target="$tree"; matches=$((matches + 1)); done; if [ "$matches" -eq 1 ]; then activity=$(find "$target" -type d \\( -name .git -o -name node_modules \\) -prune -o -type f -newermt '@${since}' ! -newermt '@${until}' -printf . 2>/dev/null) && printf '\\nELANOUS_ACTIVITY %s\\n' "\${#activity}" || printf '\\nELANOUS_ACTIVITY_ERROR\\n'; else printf '\\nELANOUS_ACTIVITY_ERROR\\n'; fi`);
+      const r = opts.exec(activityCommand(
+        since,
+        until,
+        offset,
+        activityTimestamp(lastActivityMeasuredAt),
+        activityTimestamp(measurementStartedAt),
+      ));
       if (r.status !== 0) { log('self-implement.pod', 'ledger-live-unavailable', { runId: opts.runId, status: r.status, stderr: r.stderr.trim().slice(0, 200) }); checkStall(false, false); return { ledgerRead: false, activityMeasured: false }; }
       const marker = r.stdout.lastIndexOf('\nELANOUS_ACTIVITY');
       const activityLine = marker < 0 ? '' : r.stdout.slice(marker + 1);

package/src/task-orchestrator/surfaces/pod-si-warm-entry.ts

@@ -1,16 +1,43 @@
 /** Opt-in SI warm entry; the ordinary Pod spawn remains the default. */
 import { podSelfImplementSpawn, type PodSpawnOptions } from './self-implement-pod.js';
+import type { SiWarmChildAttempt } from './self-implement-pod.js';
+import type { SelfImplementJobDone, SelfImplementJobSpawn } from './self-implement.js';
+import type { SiWarmAcquireResult } from './pod-si-warm-provider.js';
+
+export interface SiWarmEntryAdapter {
+  acquire(input: Parameters<SelfImplementJobSpawn>[0], base: PodSpawnOptions): Promise<SiWarmAcquireResult>;
+  postprocess(input: Parameters<SelfImplementJobSpawn>[0], result: SelfImplementJobDone,
+    attempt: SiWarmChildAttempt, base: PodSpawnOptions): Promise<SelfImplementJobDone>;
+}
 
 export async function podSpawnWithSiWarm(base: PodSpawnOptions,
-  env: NodeJS.ProcessEnv = process.env) {
-  if (env.ELANOUS_SI_WARM_REUSE !== '1') return podSelfImplementSpawn(base);
-  const { acquireSiWarmChild, postprocessSiWarmChild } = await import('./pod-si-warm-host.js');
+  env: NodeJS.ProcessEnv = process.env, adapter?: SiWarmEntryAdapter) {
+  let configEnabled = false;
+  try { configEnabled = base.warmReuseConfig?.()?.ta === true; }
+  catch { /* An unreadable config must not open the warm transport. */ }
+  if (env.ELANOUS_SI_WARM_REUSE !== '1' && !configEnabled) return podSelfImplementSpawn(base);
+  const hooks = adapter ?? await import('./pod-si-warm-host.js').then(({ acquireSiWarmChild, postprocessSiWarmChild }) => ({
+    acquire: acquireSiWarmChild,
+    postprocess: postprocessSiWarmChild,
+  }));
   return podSelfImplementSpawn({ ...base,
     siWarmAttempt: async input => {
-      const result = await acquireSiWarmChild(input, base);
-      return result.status === 'acquired' ? result.attempt : null;
+      const result = await hooks.acquire(input, base);
+      switch (result.status) {
+        case 'acquired': return result.attempt;
+        case 'no-entry': return null;
+        case 'uncertain':
+          // An uncertain lease may already be running this request. Never launch a fresh Job
+          // until its fenced worker is reconciled, or the same goal can execute twice.
+          throw new Error(`si-v1 lease state uncertain: ${result.reason}`);
+        default: {
+          const exhaustive: never = result;
+          void exhaustive;
+          throw new Error('si-v1 lease acquisition returned an unsupported state');
+        }
+      }
     },
     siWarmHostPostprocess: (result, attempt, input) =>
-      postprocessSiWarmChild(input, result, attempt, base),
+      hooks.postprocess(input, result, attempt, base),
   });
 }

package/src/task-orchestrator/surfaces/pod-source-bundle.ts

@@ -13,8 +13,9 @@ type PackOptions = {
   paths?: string[];
   outDir: string;
   maxSizeBytes?: number;
-  mirrorHead?: string;
+  mirrorHead?: string | null;
   log?: (category: string, event: string, data: Record<string, unknown>) => void;
+  probeGit?: typeof gitProbe;
 };
 
 type PackedBundle = {
@@ -35,10 +36,21 @@ function git(repoDir: string, env: NodeJS.ProcessEnv, ...args: string[]): string
   }
 }
 
+function gitProbe(repoDir: string, env: NodeJS.ProcessEnv, ...args: string[]): { status: number; stderr: string } {
+  try {
+    execFileSync('git', args, { cwd: repoDir, env, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] });
+    return { status: 0, stderr: '' };
+  } catch (error) {
+    const e = error as Error & { status?: number; stderr?: Buffer | string };
+    return { status: e.status ?? -1, stderr: String(e.stderr ?? e.message).trim() };
+  }
+}
+
 /** Package the host's on-disk files above a fetchable remote base without touching the user's index. */
 export function packSourceBundle(options: PackOptions): PackedBundle {
   const { repoDir, kind, base, paths, outDir } = options;
   const log = options.log ?? ((category: string, event: string, data: Record<string, unknown>) => debug.log(category, event, data));
+  const probeGit = options.probeGit ?? gitProbe;
   const started = Date.now();
   let root = resolve(repoDir);
   const output = resolve(outDir);
@@ -50,6 +62,9 @@ export function packSourceBundle(options: PackOptions): PackedBundle {
   let headCommit: string | undefined;
   let ownsIndex = false;
   let createdBundle = false;
+  let bundleMode: 'thin' | 'full' | 'unknown' = 'unknown';
+  let bundleReason = 'decision-not-reached';
+  let bundleSizeBytes: number | null = null;
   try {
     root = git(root, env, 'rev-parse', '--show-toplevel');
     const outputRelative = relative(root, output);
@@ -110,16 +125,36 @@ export function packSourceBundle(options: PackOptions): PackedBundle {
     git(root, env, 'update-ref', ref, headCommit);
     createdBundle = true;
     let bundleRevision = ref;
-    if (options.mirrorHead !== undefined) {
+    if (options.mirrorHead === undefined) {
+      bundleMode = 'full';
+      bundleReason = 'mirror-head-unspecified';
+    } else if (options.mirrorHead === null) {
+      bundleMode = 'full';
+      bundleReason = 'mirror-head-missing';
+    } else {
+      bundleMode = 'full';
+      bundleReason = 'mirror-head-invalid';
       // A thin bundle is usable only when its excluded history belongs to the packed base's lineage.
       const mirrorHead = options.mirrorHead;
       let sharedHistory = false;
       if (/^[0-9a-f]{40,64}$/.test(mirrorHead)) {
-        try {
-          git(root, env, 'cat-file', '-e', `${mirrorHead}^{commit}`);
-          git(root, env, 'merge-base', '--is-ancestor', mirrorHead, baseCommit);
-          sharedHistory = true;
-        } catch { /* The mirror is unavailable or unrelated; include all history instead. */ }
+        const commitProbe = probeGit(root, { ...env, GIT_NO_LAZY_FETCH: '1' }, 'cat-file', '-e', `${mirrorHead}^{commit}`);
+        if (commitProbe.status === 0) {
+          const ancestorProbe = probeGit(root, env, 'merge-base', '--is-ancestor', mirrorHead, baseCommit);
+          if (ancestorProbe.status === 0) sharedHistory = true;
+          else if (ancestorProbe.status === 1 && !ancestorProbe.stderr) bundleReason = 'mirror-head-not-ancestor';
+          else bundleReason = 'mirror-head-check-failed';
+        } else if ((commitProbe.status === 1 && !commitProbe.stderr) || (commitProbe.status === 128 && /not a valid object name|could not get object info/i.test(commitProbe.stderr))) {
+          bundleReason = 'mirror-head-unavailable';
+        } else {
+          bundleReason = 'mirror-head-check-failed';
+        }
+      } else {
+        bundleReason = 'mirror-head-invalid';
+      }
+      if (sharedHistory) {
+        bundleMode = 'thin';
+        bundleReason = 'shared-history';
       }
       bundleRevision = sharedHistory ? `${mirrorHead}..${ref}` : ref;
     }
@@ -127,15 +162,16 @@ export function packSourceBundle(options: PackOptions): PackedBundle {
     git(root, env, 'update-ref', '-d', ref, headCommit);
     ref = undefined;
     const sizeBytes = statSync(bundlePath).size;
+    bundleSizeBytes = sizeBytes;
     if (sizeBytes > limit) throw new Error(`bundle size ${sizeBytes} exceeds limit ${limit} bytes`);
     const sha256 = createHash('sha256').update(readFileSync(bundlePath)).digest('hex');
     const result = { bundlePath, sha256, sizeBytes, baseCommit, headCommit, fileCount };
-    log('pod.source', 'bundle-packed', { kind, baseCommit, headCommit, fileCount, sizeBytes, ms: Date.now() - started });
+    log('pod.source', 'bundle-packed', { kind, baseCommit, headCommit, fileCount, bundleMode, bundleReason, sizeBytes, ms: Date.now() - started });
     return result;
   } catch (error) {
     if (createdBundle) rmSync(bundlePath, { force: true });
     const reason = error instanceof Error ? error.message : String(error);
-    log('pod.source', 'bundle-refused', { kind, reason });
+    log('pod.source', 'bundle-refused', { kind, reason, bundleMode, bundleReason, sizeBytes: bundleSizeBytes });
     throw error;
   } finally {
     if (ref && headCommit) git(root, env, 'update-ref', '-d', ref, headCommit);