elanous 0.2.15 → 0.2.17

package/src/task-orchestrator/surfaces/pod-ledger-prod-sink.ts

@@ -0,0 +1,75 @@
+import { debug } from '../../debug/log.js';
+import { LogStore, logsDbPath } from '../../mss/logging/log-store.js';
+
+type Emit = (category: string, event: string, data: Record<string, unknown>) => void;
+type Store = Pick<LogStore, 'insertBatch'>;
+
+/** 발사한 부모(`harness say --config-dir …`)가 정한 집의 logs.db — 부모가 자식 `self orchestrate` 에 env 로 넘긴다. */
+export const POD_REEMIT_LOGS_DB_ENV = 'ELANOUS_POD_REEMIT_LOGS_DB';
+export function launchHomeLogsDb(env: NodeJS.ProcessEnv = process.env): string | undefined {
+  return env[POD_REEMIT_LOGS_DB_ENV]?.trim() || undefined;
+}
+
+let cached: { path: string; store: Store } | null = null;
+let announced = '';
+
+/**
+ * POD-OBS(10-06 · 0.2.16 P0 · OP 사양): Pod 자식 원장 «재방출»만 부모가 발사 때 정한 집(A)의 logs.db 로 보낸다.
+ * 자식 orchestrate 는 트리 파생 test 우주(B)에서 돌아, 지금은 재방출이 B 에만 쌓였다(24h `ledger-collected` 운영 2 vs 다른 우주 250).
+ * 자식 우주 원장·격리는 그대로 둔다. A 를 못 열면 조용히 버리지 않고 B 로 떨어뜨리며 경고한다.
+ * env 가 없거나(옛 발사) A == B 이거나 시험 프로세스면 null → 호출측이 지금처럼 B 에만 쓴다.
+ */
+export function operationalReemit(opts: {
+  currentDb?: string;
+  operationalDb?: string;
+  open?: (path: string) => Store;
+  testProcess?: boolean;
+  fallback?: Emit;
+} = {}): Emit | null {
+  const operationalDb = opts.operationalDb ?? launchHomeLogsDb();
+  if (!operationalDb) return null;
+  const currentDb = opts.currentDb ?? logsDbPath();
+  const testProcess = opts.testProcess ?? (process.env.NODE_ENV === 'test' || !!process.env.ELANOUS_TEST_HOME);
+  if (testProcess && !opts.open) return null;
+  if (currentDb === operationalDb) return null;
+  const open = opts.open ?? ((path: string) => new LogStore(path, { instance: 'prod' }));
+  const fallback: Emit = opts.fallback ?? ((c, e, d) => debug.log(c, e, d));
+  const write = (category: string, event: string, data: Record<string, unknown>): void => {
+    if (!cached || cached.path !== operationalDb || opts.open) cached = { path: operationalDb, store: open(operationalDb) };
+    cached.store.insertBatch([{ rec: { ts: new Date().toISOString(), category, event, data }, surface: 'pod-reemit' }]);
+  };
+  let warned = false;
+  return (category, event, data) => {
+    try {
+      if (announced !== `${currentDb}->${operationalDb}` || opts.open) {
+        // 어느 우주로 보냈는지 한 줄(A 에) — 조회자가 «B 에 왜 없나»를 여기서 본다.
+        write('self-implement.pod', 'reemit-target', { targetUniverse: operationalDb, childUniverse: currentDb });
+        announced = `${currentDb}->${operationalDb}`;
+      }
+      write(category, event, data);
+    } catch (error) {
+      fallback(category, event, data);
+      if (warned) return;
+      // 경고는 싱크(발사 하나)당 한 번 — 줄마다 찍으면 경고가 원장을 덮는다.
+      warned = true;
+      try {
+        fallback('self-implement.pod', 'reemit-target-unavailable', {
+          targetUniverse: operationalDb, childUniverse: currentDb, reason: error instanceof Error ? error.message : String(error),
+        });
+      } catch { /* nothing */ }
+    }
+  };
+}
+
+let shared: { key: string; emit: Emit } | null = null;
+
+/** 재방출 기본 경로: 집(A)이 정해져 있으면 A 에만, 아니면 지금처럼 지금 우주(B)의 debug.log.
+ *  프로세스(발사)당 싱크 하나 — collector 의 `log`·`emit`, follower 가 같은 싱크를 써서 경고·대상 줄이 한 번이다. */
+export function defaultPodReemit(): Emit {
+  const key = `${launchHomeLogsDb() ?? ''}->${logsDbPath()}`;
+  if (shared?.key === key) return shared.emit;
+  const operational = operationalReemit();
+  const emit: Emit = operational ?? ((category, event, data) => { debug.log(category, event, data); });
+  shared = { key, emit };
+  return emit;
+}

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

@@ -8,13 +8,14 @@
  *   - 컨텍스트  kubectl 컨텍스트 이름(이 맥의 kubeconfig)
  *   - @ssh호스트 원격 클러스터면 그 기계 — 이미지 판 대조·반입(`docker load` ⊕ `k3d image import`)에 쓴다
  *   - 상한      이 노드에 동시에 둘 Job 수(기본 2)
- * Job 마다 앞 순위부터 «진행 중 < 상한»인 노드를 고른다. 다 차면 자리가 날 때까지 기다린다.
+ * Job 마다 «빈 자리 비율»이 가장 큰 노드를 고른다(동률은 앞 순위 · 측정 실패 노드는 측정된 노드가 다 찼을 때만). 다 차면 자리가 날 때까지 기다린다.
  * 노드 선택의 진행 중 수는 로컬 프로세스 기준이다. 발사 허가는 별도의 lease 측정으로
  * 다른 호스트의 Running/Pending 및 메모리 예약까지 고려한다.
  * 풀을 안 주면 종전처럼 «현재 컨텍스트» 하나다(동작 불변).
  */
 import { spawn, spawnSync } from 'node:child_process';
-import { existsSync } from 'node:fs';
+import { existsSync, mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
 import { join, resolve } from 'node:path';
 import { debug } from '../../debug/log.js';
 import { PodLeaseAdmission, type PodLeasePredecessor, type PodLeaseRelease } from '../../pod-lease/admission.js';
@@ -186,7 +187,8 @@ export class PodPoolScheduler {
   private readonly hostLease: HostPoolLease;
   private readonly pollMs: number;
   private readonly occupancy: () => Record<string, MemberOccupancy> | Promise<Record<string, MemberOccupancy>>;
-  constructor(readonly members: readonly PodPoolMember[], options: { status?: () => PoolLeaseRecommendation | Promise<PoolLeaseRecommendation>; kubectl?: PoolKubectl; dns?: (context: string) => PoolDnsProbe; pollMs?: number; hostLease?: HostPoolLease; occupancy?: () => Record<string, MemberOccupancy> | Promise<Record<string, MemberOccupancy>>; dependencyMerged?: (after: PodLeasePredecessor, signal?: AbortSignal) => PredecessorState | boolean | Promise<PredecessorState | boolean> } = {}) {
+  private readonly memberMemory: () => Array<{ context: string; allocatableMemoryBytes: number | null }> | Promise<Array<{ context: string; allocatableMemoryBytes: number | null }>>;
+  constructor(readonly members: readonly PodPoolMember[], options: { status?: () => PoolLeaseRecommendation | Promise<PoolLeaseRecommendation>; kubectl?: PoolKubectl; dns?: (context: string) => PoolDnsProbe; pollMs?: number; hostLease?: HostPoolLease; memberMemory?: () => Array<{ context: string; allocatableMemoryBytes: number | null }> | Promise<Array<{ context: string; allocatableMemoryBytes: number | null }>>; occupancy?: () => Record<string, MemberOccupancy> | Promise<Record<string, MemberOccupancy>>; dependencyMerged?: (after: PodLeasePredecessor, signal?: AbortSignal) => PredecessorState | boolean | Promise<PredecessorState | boolean> } = {}) {
     this.pollMs = options.pollMs ?? 15_000;
     // One lease directory per pool (contexts, not caps) — every CLI process launching into the same clusters shares it.
     this.hostLease = options.hostLease ?? podPoolHostLease(members);
@@ -195,6 +197,9 @@ export class PodPoolScheduler {
       return recommendConcurrency(measure, { capacity: members.reduce((n, m) => n + m.capacity, 0), accounts: 0, perAccount: 0 });
     });
     this.measure = async () => measureStatus();
+    // An injected status (tests, callers with their own measurement) without memberMemory never shells out to kubectl here.
+    this.memberMemory = options.memberMemory ?? (options.status ? (() => []) : () => measurePoolLease(members, { ...(options.kubectl ? { kubectl: options.kubectl } : {}), ...(options.dns ? { dns: options.dns } : {}) }).members
+      .map((m: PodLeaseMember) => ({ context: m.context, allocatableMemoryBytes: m.allocatableMemoryBytes })));
     this.occupancy = options.occupancy ?? (() => measureMemberOccupancy(members, { ...(options.kubectl ? { kubectl: options.kubectl } : {}), ...(options.dns ? { dns: options.dns } : {}) }));
     this.admission = new PodLeaseAdmission({ status: async () => {
       const measured = await measureStatus();
@@ -267,15 +272,34 @@ export class PodPoolScheduler {
       };
     });
   }
+  /**
+   * LAUNCH-STALL (10-06): members whose total allocatable memory is below one Job's limit can never take it —
+   * waiting for them is an endless silent stall (minio 12.5GB vs a 16Gi standard Job). A member whose memory
+   * could not be read is not judged unfit (unknown ≠ too small).
+   */
+  async unfitMembers(limitBytes: number): Promise<Array<{ context: string; allocatableMemoryBytes: number }>> {
+    let rows: Array<{ context: string; allocatableMemoryBytes: number | null }>;
+    try { rows = await this.memberMemory(); } catch { return []; }
+    return rows.flatMap((r) => r.allocatableMemoryBytes !== null && r.allocatableMemoryBytes < limitBytes
+      ? [{ context: r.context, allocatableMemoryBytes: r.allocatableMemoryBytes }] : []);
+  }
+  /** Why admission is still waiting: the pool-wide lease measurement (null before any reading). Slot waits get their reason from tryAcquire's onEmpty. */
+  waitReason(): string | null {
+    const r = this.lastRaw;
+    if (!r) return null;
+    return `recommended=${r.recommended ?? 'unknown'} limitedBy=${r.limitedBy ?? '-'} memorySlots=${r.memorySlots ?? '?'}${r.reason ? ` reason=${r.reason}` : ''}`;
+  }
   admissionSnapshot(): ReturnType<PodLeaseAdmission['snapshot']> {
     return this.admission.snapshot();
   }
   /**
-   * Pick the member with the most free slots: capacity − measured cluster occupancy − this process's inflight.
+   * Pick the member with the largest free share: (capacity − measured cluster occupancy − this process's inflight) / capacity.
+   * POOL-SPREAD (10-06): comparing absolute free slots always picked the big member (node-b 25 vs node-c 4), so the small
+   * member idled until the big one was full. Comparing the free share fills members in proportion to their capacity.
    * A member whose occupancy could not be read falls back to inflight-only (never treated as zero occupied).
    * Ties keep the configured member order. Returns null when every readable member is full.
    */
-  async tryAcquire(): Promise<PodPoolMember | null> {
+  async tryAcquire(skip?: ReadonlySet<string>, onEmpty?: (reason: string) => void): Promise<PodPoolMember | null> {
     let reading: Record<string, MemberOccupancy>;
     try { reading = await this.occupancy(); }
     catch (error) {
@@ -284,8 +308,15 @@ export class PodPoolScheduler {
     }
     const free: Record<string, number> = {};
     const measured: Record<string, boolean> = {};
-    let best: { member: PodPoolMember; slots: number } | null = null;
+    let best: { member: PodPoolMember; slots: number; measured: boolean } | null = null;
+    // A measured member always beats an unmeasured one (its share would read 100% and draw every Job to a node
+    // that did not answer); unmeasured members compete only when no measured member has a free slot.
+    const better = (cand: { member: PodPoolMember; slots: number; measured: boolean }) => !best
+      || (cand.measured !== best.measured ? cand.measured
+        : cand.slots / cand.member.capacity > best.slots / best.member.capacity);
     for (const m of this.members) {
+      // LAUNCH-STALL: a member this launch cannot fit is skipped for this call only (other launches may fit it).
+      if (skip?.has(m.context)) continue;
       const inflight = this.inflight.get(m.context) ?? 0;
       const row = reading[m.context];
       const ok = !!row && row.occupied !== null;
@@ -294,11 +325,16 @@ export class PodPoolScheduler {
       const slots = m.capacity - occupied - inflight;
       free[m.context] = slots;
       if (slots <= 0) continue;
-      if (!best || slots > best.slots) best = { member: m, slots };
+      const cand = { member: m, slots, measured: ok };
+      if (better(cand)) best = cand;
+    }
+    if (!best) {
+      onEmpty?.(`no free slot · free=${JSON.stringify(free)} · measured=${JSON.stringify(measured)}${skip?.size ? ` · skipped=${[...skip].join(',')}` : ''}`);
+      return null;
     }
-    if (!best) return null;
     this.inflight.set(best.member.context, (this.inflight.get(best.member.context) ?? 0) + 1);
-    debug.log('pod.pool', 'member-selected', { member: best.member.context, free, measured });
+    const share = Object.fromEntries(this.members.map((m) => [m.context, Math.round(Math.max(0, free[m.context] ?? 0) / m.capacity * 100) / 100]));
+    debug.log('pod.pool', 'member-selected', { member: best.member.context, free, measured, share });
     return best.member;
   }
   release(member: PodPoolMember): void {
@@ -387,13 +423,14 @@ export function podImageBuildScript(cwd: string = process.cwd()): string | null
   return null;
 }
 
-type RemoteBuild = (host: string, cluster: string, registry?: string) => Promise<{ ok: boolean; detail: string }>;
+/** packedTgz = 풀 동기화가 한 번 만든 패키지 묶음(있으면 build.sh 가 pack 을 다시 하지 않는다). */
+type RemoteBuild = (host: string, cluster: string, registry?: string, packedTgz?: string) => Promise<{ ok: boolean; detail: string }>;
 
-function defaultRemoteBuild(script: string, image: string): RemoteBuild {
-  return (host, cluster, registry) => new Promise((done) => {
-    const env: NodeJS.ProcessEnv = { ...process.env, ELANOUS_BUILD_REMOTE: host, ELANOUS_L2_CLUSTER: cluster, ELANOUS_BUILD_IMAGE: image === 'elanous-harness-lite:local' ? 'lite' : 'full' };
-    delete env.ELANOUS_BUILD_REGISTRY;
-    if (registry) env.ELANOUS_BUILD_REGISTRY = registry;
+/** 같은 트리의 패키지 묶음(tgz)을 «한 번» 만든다 — 멤버들이 같이 쓴다. cleanup 은 동기화가 끝나면 부른다. */
+type PoolPack = () => Promise<{ ok: boolean; tgz?: string; detail: string; cleanup?: () => void }>;
+
+function runBuildScript(script: string, env: NodeJS.ProcessEnv): Promise<{ ok: boolean; detail: string }> {
+  return new Promise((done) => {
     const child = spawn('bash', [script], { env, stdio: ['ignore', 'pipe', 'pipe'] });
     let out = '';
     child.stdout.on('data', (d) => { out += d; }); child.stderr.on('data', (d) => { out += d; });
@@ -402,18 +439,53 @@ function defaultRemoteBuild(script: string, image: string): RemoteBuild {
   });
 }
 
+/**
+ * 🩸 2026-10-06: 멤버마다 build.sh 가 같은 트리에서 `bun pm pack` 을 «동시에» 돌렸다 — prepack 이 트리에 쓰는
+ * src/version/packed-revision.json 을 다른 쪽 postpack 이 지워 한쪽이 «⛔ pack» 으로 죽었다(node-c 가 매 발사 빠졌다).
+ * ⇒ 원격 멤버가 둘 이상이면 pack 은 여기서 한 번만 하고 그 tgz 를 나눠 준다.
+ */
+function defaultPoolPack(script: string): PoolPack {
+  return async () => {
+    const dir = mkdtempSync(join(tmpdir(), 'elanous-pool-pack-'));
+    const tgz = join(dir, 'elanous.tgz');
+    const env: NodeJS.ProcessEnv = { ...process.env, ELANOUS_BUILD_PACK_ONLY: tgz };
+    delete env.ELANOUS_BUILD_PACKED_TGZ;
+    delete env.ELANOUS_BUILD_REMOTE;
+    const r = await runBuildScript(script, env);
+    const cleanup = () => rmSync(dir, { recursive: true, force: true });
+    if (!r.ok || !existsSync(tgz)) { cleanup(); return { ok: false, detail: r.detail }; }
+    return { ok: true, tgz, detail: r.detail, cleanup };
+  };
+}
+
+function defaultRemoteBuild(script: string, image: string): RemoteBuild {
+  return (host, cluster, registry, packedTgz) => {
+    const env: NodeJS.ProcessEnv = { ...process.env, ELANOUS_BUILD_REMOTE: host, ELANOUS_L2_CLUSTER: cluster, ELANOUS_BUILD_IMAGE: image === 'elanous-harness-lite:local' ? 'lite' : 'full' };
+    delete env.ELANOUS_BUILD_REGISTRY;
+    if (registry) env.ELANOUS_BUILD_REGISTRY = registry;
+    delete env.ELANOUS_BUILD_PACK_ONLY;
+    delete env.ELANOUS_BUILD_PACKED_TGZ;
+    if (packedTgz) env.ELANOUS_BUILD_PACKED_TGZ = packedTgz;
+    return runBuildScript(script, env);
+  };
+}
 /**
  * 풀의 원격 노드들을 «동시에» 이 트리의 판으로 맞춘다 (09-25 개선).
  *   1순위 = 노드 «쪽에서» 빌드(build.sh ELANOUS_BUILD_REMOTE) — 빌드 재료(수십 MB)만 보내고 무거운 층은 그 노드의 캐시가 재사용한다.
  *           📏 커밋이 바뀐 뒤 두 노드를 올리는 데 벽시계 55초(종전: 다시 굽기 1분 40초 ⊕ 4GB 차례 전송 5분 48초).
  *   실패하면 = 종전의 통째 전송(syncPoolImage)으로 떨어진다.
  */
-export async function syncPoolImages(members: readonly PodPoolMember[], image: string, localCommit: string | null, deps: { run?: RemoteRun; remoteBuild?: RemoteBuild; buildScript?: string | null; ship?: typeof syncPoolImage; localSkillsDigest?: string | null; waitIntervalMs?: number; waitMaxMs?: number; now?: () => number; sleep?: (ms: number) => Promise<void>; inspect?: LocalImageInspect; transfer?: ImageShip } = {}): Promise<Map<string, PoolImageSync>> {
+export async function syncPoolImages(members: readonly PodPoolMember[], image: string, localCommit: string | null, deps: { run?: RemoteRun; remoteBuild?: RemoteBuild; buildScript?: string | null; ship?: typeof syncPoolImage; localSkillsDigest?: string | null; waitIntervalMs?: number; waitMaxMs?: number; now?: () => number; sleep?: (ms: number) => Promise<void>; inspect?: LocalImageInspect; transfer?: ImageShip; pack?: PoolPack | null } = {}): Promise<Map<string, PoolImageSync>> {
   const run = deps.run ?? defaultRemoteRun;
   const script = deps.buildScript === undefined ? podImageBuildScript() : deps.buildScript;
   const remoteBuild = deps.remoteBuild ?? (script ? defaultRemoteBuild(script, image) : null);
   const ship = deps.ship ?? ((m: PodPoolMember, img: string, commit: string | null, remote: RemoteRun) => syncPoolImage(m, img, commit, { run: remote, inspect: deps.inspect, transfer: deps.transfer }));
   const results = new Map<string, PoolImageSync>();
+  // pack 한 번 ⊕ 나눠 쓰기 — 원격 멤버가 둘 이상일 때만(하나뿐이면 종전대로 build.sh 가 스스로 pack 한다).
+  //   주입된 remoteBuild(시험)에는 진짜 pack 을 붙이지 않는다 — pack 도 주입해야 쓴다.
+  const pack = deps.pack !== undefined ? deps.pack : (!deps.remoteBuild && script ? defaultPoolPack(script) : null);
+  const sharePack = pack && members.filter((m) => m.sshHost).length >= 2 ? pack : null;
+  let packed: ReturnType<PoolPack> | null = null;
   await Promise.all(members.map(async (m) => {
     const t0 = Date.now();
     if (!m.sshHost) { results.set(m.context, { ok: true, action: 'local', detail: 'this machine', ms: 0 }); return; }
@@ -428,7 +500,12 @@ export async function syncPoolImages(members: readonly PodPoolMember[], image: s
       return;
     }
     if (remoteBuild) {
-      const b = await remoteBuild(m.sshHost, m.k3dCluster, m.registry);
+      // 같은 판이 아닌 멤버가 처음 여기 닿을 때 pack 한다(전부 fresh 면 pack 도 없다).
+      const shared = sharePack ? await (packed ??= sharePack()) : null;
+      if (shared && !shared.ok) debug.log('self-implement.pod', 'pool-image-pack-failed', { context: m.context, detail: shared.detail });
+      const b = shared && !shared.ok
+        ? { ok: false, detail: shared.detail }
+        : await remoteBuild(m.sshHost, m.k3dCluster, m.registry, shared?.tgz);
       const after = remoteImageCommit(m, image, run);
       const refAfter = registryImageRef(m, localCommit ?? after, run, image);
       // ⭐ 레지스트리 노드면 «이 판 커밋 태그가 레지스트리에 있나»로 판정한다 — Pod 는 그 커밋 태그를 pull 한다.
@@ -453,6 +530,6 @@ export async function syncPoolImages(members: readonly PodPoolMember[], image: s
       return;
     }
     results.set(m.context, { ...ship(m, image, localCommit, run), ms: Date.now() - t0 });
-  }));
+  })).finally(async () => { if (packed) (await packed).cleanup?.(); });
   return results;
 }

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

@@ -1,8 +1,10 @@
 /** Pod Job 원천 단계 — default clone · 커밋 · PR · 호스트 번들.
  *  sha·PR·커밋은 형식 검사 전에 스크립트에 넣지 않는다(셸 주입 차단). */
 
+import { execFileSync } from 'node:child_process';
+
 export type PodSource =
-  | { kind: 'default' }
+  | { kind: 'default'; base?: string }
   | { kind: 'commit'; sha: string }
   | { kind: 'pr'; number: number }
   | { kind: 'bundle'; bundlePath: string; sha256: string; sizeBytes: number; headCommit: string };
@@ -29,6 +31,27 @@ function assertSize(value: number): number {
   return value;
 }
 
+/** Check the requested branch on origin before creating a Pod Job, not in the launched job. */
+function assertRemoteBase(repoUrl: string, base: string): void {
+  if (base.startsWith('-') || base === 'HEAD') throw new Error(`invalid Pod base ref: ${base}`);
+  try {
+    execFileSync('git', ['check-ref-format', '--branch', base], { stdio: 'pipe' });
+  } catch {
+    throw new Error(`invalid Pod base ref: ${base}`);
+  }
+  try {
+    const advertised = execFileSync('git', ['ls-remote', '--exit-code', '--heads', repoUrl, `refs/heads/${base}`], {
+      encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'],
+    }).trim();
+    const [sha, ref] = advertised.split('\t');
+    if (!/^[0-9a-f]{40,64}$/.test(sha ?? '') || ref !== `refs/heads/${base}`) {
+      throw new Error('origin did not advertise the requested branch');
+    }
+  } catch {
+    throw new Error(`Pod base ref not found on origin: ${base}`);
+  }
+}
+
 /** Job 스크립트의 원천 단계. 성공 갈래는 `ELANOUS_POD_SOURCE <kind> <HEAD>` 로 끝난다. */
 export function podSourceScript(source: PodSource, repoUrl: string, mirrorPath = '/host-mirror'): string {
   const quotedUrl = `'${repoUrl.replace(/'/g, `'\\''`)}'`;
@@ -48,6 +71,19 @@ export function podSourceScript(source: PodSource, repoUrl: string, mirrorPath =
     'cd repo || exit 5',
   ];
   if (source.kind === 'default') {
+    if (source.base && source.base !== 'main') {
+      assertRemoteBase(repoUrl, source.base);
+      const base = source.base;
+      const quote = (value: string) => `'${value.replace(/'/g, `'\\''`)}'`;
+      const quotedTrackingRef = quote(`refs/remotes/origin/${base}`);
+      return [
+        ...start,
+        `git fetch --depth 50 origin ${quote(`+refs/heads/${base}:refs/remotes/origin/${base}`)} || exit 5`,
+        `git checkout -q -B ${quote(base)} ${quotedTrackingRef} || exit 5`,
+        'head=$(git rev-parse HEAD)',
+        "printf 'ELANOUS_POD_SOURCE default %s\\n' \"$head\"",
+      ].join('\n');
+    }
     return [
       ...start,
       'if [ "$source_via" = mirror ]; then',