elanous 0.2.40 → 0.2.42

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';
@@ -45,6 +47,7 @@ import { INFLIGHT_REGISTRY_FILE, registerInflight } from '../pr-tool/inflight-re
 import { taskParentRoleEnv, taskParentRolePinsForChild } from './task-parent-role-llm.js';
 import { runHarvestUnit, type ReviewInvocation } from './harvest-unit.js';
 import { TASK_CARD_PREFIX } from './task-card-prefix.js';
+import { childLlmEffortProblem } from '../intelligence-map/model-catalog.js';
 
 export interface ResolveHandTextDeps {
   cwd: string;
@@ -414,7 +417,7 @@ export interface TaskCard {
     moveId?: string }>;
 }
 
-/** 구현 자식 LLM 선택 — 하니스 `--child-llm-provider/--child-llm-model/--child-llm-effort` 로 그대로 넘긴다(검증 권위는 하니스). */
+/** 구현 자식 LLM 선택 — 하니스 `--child-llm-provider/--child-llm-model/--child-llm-effort` 로 넘긴다. */
 export interface TaskChildLlm { provider: string; model: string; effort?: string }
 
 /**
@@ -431,6 +434,8 @@ export function parseChildLlm(value: string, effort?: string): TaskChildLlm {
   const model = provider === 'openrouter' && !rest.startsWith('openrouter/') ? `openrouter/${rest}` : rest;
   if (effort === undefined) return { provider, model };
   if (!effort || /[\s\p{Cc}]/u.test(effort)) throw new Error(`--child-llm-effort 가 비었거나 공백·제어 문자를 담았다: ${JSON.stringify(effort)}`);
+  const problem = childLlmEffortProblem(model, effort);
+  if (problem) throw new Error(problem);
   return { provider, model, effort };
 }
 
@@ -1086,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 은 존재 확인 뒤 절대 경로로 바꿔 싣는다. */
@@ -1622,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.
@@ -1642,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-failure-reason.ts

@@ -125,6 +125,49 @@ export const POD_EXIT_CLASSES = ['oom-killed', 'deadline-exceeded', 'gh-login-fa
 
 export type PodExitClass = typeof POD_EXIT_CLASSES[number];
 
+/** Build the parent-ledger row for a terminal child attempt. A Job can complete
+ * successfully while its child result is still unsuccessful (for example,
+ * report-deficit after preserving a partial PR); retain both facts together. */
+export function podChildEvidenceLedgerRow(input: {
+  job: string;
+  childRunId: string;
+  state: 'complete' | 'failed' | 'aborted';
+  result?: {
+    stage?: unknown;
+    ok?: unknown;
+    failureClassification?: unknown;
+    completionDisposition?: unknown;
+    error?: unknown;
+    childEvidence?: unknown;
+  } | null;
+  noResultDiagnostic?: string | null;
+  noResultLogEvidence?: Record<string, unknown> | null;
+  podTermination?: PodTermination | null;
+}): Record<string, unknown> | null {
+  const { result } = input;
+  const persist = input.state === 'failed' || input.state === 'aborted' || input.noResultLogEvidence != null
+    || (input.state === 'complete' && (input.noResultDiagnostic != null || result?.ok === false));
+  if (!persist) return null;
+
+  const childEvidence = input.noResultLogEvidence
+    ? { ...(result?.childEvidence && typeof result.childEvidence === 'object' && !Array.isArray(result.childEvidence)
+      ? result.childEvidence as Record<string, unknown> : {}), ...input.noResultLogEvidence }
+    : result?.childEvidence ?? null;
+  const completedButUnsuccessful = input.state === 'complete' && result?.ok === false;
+  const childResult = completedButUnsuccessful && result ? Object.fromEntries([
+    ['stage', result.stage], ['ok', result.ok], ['failureClassification', result.failureClassification],
+    ['completionDisposition', result.completionDisposition], ['error', result.error],
+  ].filter(([, value]) => value !== undefined)) : null;
+
+  return {
+    childEvidence,
+    childRunId: input.childRunId,
+    job: input.job,
+    ...(input.podTermination ? { podTermination: input.podTermination } : {}),
+    ...(childResult && Object.keys(childResult).length > 0 ? { childResult } : {}),
+  };
+}
+
 const isPodBookkeepingLine = (line: string): boolean =>
   /^(?:ELANOUS_(?:MEM|RUN_LEDGER|USAGE_ROLLUP|POD_)|\[graph\] |\[ask\]\s+\d+\)\s)/u.test(line) || /^(?:at\s+\S|\.\.\.\s+\d+\s+more\b|cleanup\s+(?:complete|done|finished)\b)/iu.test(line);
 

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-ledger-events.ts

@@ -1,3 +1,4 @@
+import { createHash } from 'node:crypto';
 import { mkdirSync, readFileSync, statSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 
@@ -39,6 +40,29 @@ export function captureFailedPodJobs(input: {
   }
   const location = { host: first.host, context: first.context, namespace: first.namespace, childRunId: first.childRunId, jobUid: first.jobUid };
   const evidenceDir = join(artifactDir, 'pod-failure-capture', runId, job, first.childRunId as string);
+  // A failed kubectl/SSH read is itself the missing diagnostic. Keep its stderr in
+  // the private artifact directory and put only the path and exit status in the ledger.
+  const readFailure = (reason: string, result: { status: number | null; stderr: string }, extra: Record<string, unknown> = {}): void => {
+    let stderrEvidence: string | null = null;
+    let stderrCaptureStatus: 'saved' | 'redacted' | 'empty' | 'write-failed' = result.stderr ? 'saved' : 'empty';
+    if (result.stderr) {
+      try {
+        mkdirSync(evidenceDir, { recursive: true });
+        const tail = result.stderr.slice(-8192).split(/\r?\n/).map(line => {
+          if (!SECRET_VALUE.test(line)) return line;
+          stderrCaptureStatus = 'redacted';
+          return '[redacted credential line]';
+        }).join('\n');
+        const digest = createHash('sha256').update(tail).digest('hex').slice(0, 16);
+        stderrEvidence = join(evidenceDir, `${reason}-${digest}.stderr.log`);
+        try { writeFileSync(stderrEvidence, tail, { flag: 'wx', mode: 0o600 }); }
+        catch (error) {
+          if ((error as NodeJS.ErrnoException).code !== 'EEXIST' || readFileSync(stderrEvidence, 'utf8') !== tail) throw error;
+        }
+      } catch { stderrEvidence = null; stderrCaptureStatus = 'write-failed'; }
+    }
+    finish('failed', reason, { ...location, ...extra, kubectlStatus: result.status, stderrEvidence, stderrCaptureStatus });
+  };
   const previous = rows.find(row => row.event === 'pod-failure-capture' && row.data?.job === job && row.data?.outcome === 'collected'
     && row.data.childRunId === first.childRunId && row.data.jobUid === first.jobUid
     && row.data.host === first.host && row.data.context === first.context && row.data.namespace === first.namespace);
@@ -54,8 +78,8 @@ export function captureFailedPodJobs(input: {
   try {
     const jobResult = kubectl(first.host as string, [...args, 'get', 'job', job, '-o', 'json']);
     if (jobResult.status !== 0) {
-      finish(/\bNotFound\b|not found/i.test(jobResult.stderr) ? 'vanished' : 'failed',
-        /\bNotFound\b|not found/i.test(jobResult.stderr) ? 'job-not-found' : 'job-read-failed', location);
+      if (/\bNotFound\b|not found/i.test(jobResult.stderr)) finish('vanished', 'job-not-found', { ...location, kubectlStatus: jobResult.status });
+      else readFailure('job-read-failed', jobResult);
       return;
     }
     const jobBody = JSON.parse(jobResult.stdout) as { metadata?: { name?: string; uid?: string } };
@@ -78,7 +102,7 @@ export function captureFailedPodJobs(input: {
       } catch { return false; }
     });
     const podResult = kubectl(first.host as string, [...args, 'get', 'pods', '-l', `job-name=${job}`, '-o', 'json']);
-    if (podResult.status !== 0) { finish('failed', 'pods-read-failed', { ...location, jobEvidence }); return; }
+    if (podResult.status !== 0) { readFailure('pods-read-failed', podResult, { jobEvidence }); return; }
     const pods = JSON.parse(podResult.stdout) as { items?: Array<{ metadata?: { name?: string; ownerReferences?: Array<{ uid?: string }> } }> };
     if (!pods.items?.length || pods.items.some(p => !p.metadata?.ownerReferences?.some(owner => owner.uid === jobBody.metadata?.uid))) {
       finish('failed', 'pod-owner-mismatch', { ...location, jobEvidence }); return;
@@ -89,7 +113,8 @@ export function captureFailedPodJobs(input: {
       finish('failed', 'pod-ambiguous', { ...location, jobEvidence, podEvidence }); return;
     }
     const logs = kubectl(first.host as string, [...args, 'logs', `pod/${podName}`, '-c', 'child']);
-    if (logs.status !== 0) { finish('failed', 'logs-read-failed', { ...location, jobEvidence, podEvidence }); return; }
+    if (logs.status !== 0) { readFailure('logs-read-failed', logs, { jobEvidence, podEvidence }); return; }
+    if (!logs.stdout.trim()) { finish('failed', 'logs-empty', { ...location, jobEvidence, podEvidence }); return; }
     const logEvidence = save('child.log', logs.stdout);
     finish('collected', 'job-failed', { ...location, jobEvidence, podEvidence, logEvidence });
   } catch { finish('failed', 'capture-error', location); }

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