mixdog 0.8.1 → 0.9.1

package/scripts/agent-tag-reuse-smoke.mjs

@@ -0,0 +1,183 @@
+#!/usr/bin/env node
+// Focused smoke for the spawn tag-reuse priority added to agent-tool.mjs.
+//
+// Validates the unified 4-tier spawn dispatch when an explicit tag is pinned:
+//   1) live + idle  -> spawn reuses the existing session (reused:true, send path)
+//   2) live + busy  -> spawn queues the prompt instead of throwing
+//   3) lingering terminal trace (no live session) -> spawn/send error, no respawn
+//   4) genuinely new tag -> a fresh spawn (no reused/respawned flag)
+//
+// No network: a fake askSession drives status transitions. Uses the REAL
+// session manager so resolveTag / worker-index behavior is exercised end to end.
+//
+// Run: node scripts/agent-tag-reuse-smoke.mjs
+import { mkdtempSync, mkdirSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { createStandaloneAgent } from '../src/standalone/agent-tool.mjs';
+import { initProviders } from '../src/runtime/agent/orchestrator/providers/registry.mjs';
+import {
+  closeSession,
+  enqueuePendingMessage,
+  getSession,
+  getSessionLastProgressAt,
+  getSessionRuntime,
+  listSessions,
+} from '../src/runtime/agent/orchestrator/session/manager.mjs';
+
+process.env.MIXDOG_AGENT_TRACE_DISABLE = '1';
+
+const root = mkdtempSync(join(tmpdir(), 'mixdog-agent-reuse-'));
+const dataDir = join(root, '.mixdog-data');
+mkdirSync(dataDir, { recursive: true });
+
+function assert(condition, message) {
+  if (!condition) throw new Error(message);
+}
+function sleep(ms) { return new Promise((r) => setTimeout(r, ms)); }
+function taskId(text) { return String(text).match(/agent task: (\S+)/)?.[1] || null; }
+
+const askLog = [];
+let holdBusy = false;
+async function fakeAskSession(sessionId, prompt) {
+  const session = getSession(sessionId);
+  if (session) { session.status = 'running'; session.lastStreamDeltaAt = Date.now(); }
+  askLog.push({ sessionId, prompt });
+  try {
+    if (holdBusy && /stay busy/i.test(prompt)) {
+      for (let i = 0; i < 40 && holdBusy; i += 1) await sleep(25);
+    }
+    return { content: `ack: ${String(prompt).split('\n').pop()}` };
+  } finally {
+    if (session) { session.status = 'idle'; session.lastUsedAt = new Date().toISOString(); session.lastStreamDeltaAt = Date.now(); }
+  }
+}
+
+const cfgMod = {
+  loadConfig() {
+    return {
+      providers: { 'openai-oauth': { enabled: true } },
+      agents: {
+        reviewer: { provider: 'openai-oauth', model: 'gpt-5.5', effort: 'low' },
+        worker: { provider: 'openai-oauth', model: 'gpt-5.5', effort: 'low', fast: true },
+      },
+      presets: [
+        { id: 'fake-reviewer', name: 'Fake Reviewer', provider: 'openai-oauth', model: 'gpt-5.5', tools: 'readonly', effort: 'low' },
+        { id: 'fake-worker', name: 'Fake Worker', provider: 'openai-oauth', model: 'gpt-5.5', tools: 'full', effort: 'low', fast: true },
+      ],
+    };
+  },
+  resolveRuntimeSpec(preset, ctx) {
+    return { lane: 'agent', scopeKey: `reuse:${ctx.agentId}`, provider: preset.provider, model: preset.model };
+  },
+};
+const reg = { initProviders };
+const mgr = {
+  getSession,
+  listSessions,
+  closeSession,
+  getSessionRuntime,
+  enqueuePendingMessage,
+  getSessionLastProgressAt,
+  askSession: fakeAskSession,
+};
+
+const ctx = { invocationSource: 'model-tool', cwd: root, clientHostPid: 0xBEEF };
+const agent = createStandaloneAgent({ cfgMod, reg, mgr, dataDir, cwd: root, defaultMode: 'async' });
+
+async function waitJob(out, pattern, label, tries = 60) {
+  const id = taskId(out);
+  assert(id, `missing task id for ${label}: ${out}`);
+  let last = '';
+  for (let i = 0; i < tries; i += 1) {
+    last = await agent.execute({ type: 'read', task_id: id }, ctx);
+    if (pattern.test(last)) return last;
+    if (/status: error/.test(last)) break;
+    await sleep(40);
+  }
+  throw new Error(`${label} did not match ${pattern}: ${last}`);
+}
+function sessionForTag(tag) {
+  return listSessions().find((s) => s?.agentTag === tag && !s.closed) || null;
+}
+async function waitSessionForTag(tag, label, tries = 60) {
+  for (let i = 0; i < tries; i += 1) {
+    const s = sessionForTag(tag);
+    if (s) return s;
+    await sleep(25);
+  }
+  throw new Error(`${label}: live session for tag ${tag} never appeared`);
+}
+
+async function main() {
+  await initProviders({ 'openai-oauth': { enabled: true } });
+
+  // --- tier 4: a genuinely new explicit tag spawns fresh (no reuse flag) ---
+  const firstOut = await agent.execute({
+    type: 'spawn', agent: 'reviewer', tag: 'reviewerA', prompt: 'first review pass', cwd: root,
+  }, ctx);
+  assert(/agent task:/.test(firstOut), `first spawn must return a task: ${firstOut}`);
+  assert(!/reused: true/.test(firstOut) && !/respawned/.test(firstOut), `fresh tag must not be flagged reused/respawned: ${firstOut}`);
+  await waitJob(firstOut, /ack: first review pass/, 'first spawn');
+  const sid = (await waitSessionForTag('reviewerA', 'first spawn')).id;
+  assert(sid, 'reviewerA session should remain live (idle) within the reap window');
+
+  // --- tier 1 (the headline bug): re-spawn the SAME tag while idle+live ---
+  const reuseOut = await agent.execute({
+    type: 'spawn', agent: 'reviewer', tag: 'reviewerA', prompt: 'second review pass', cwd: root,
+  }, ctx);
+  assert(!/^Error/.test(reuseOut), `idle same-tag re-spawn must not error: ${reuseOut}`);
+  assert(/reused: true/.test(reuseOut), `idle same-tag re-spawn must be flagged reused: ${reuseOut}`);
+  await waitJob(reuseOut, /ack: second review pass/, 'reuse spawn');
+  const sid2 = (await waitSessionForTag('reviewerA', 'reuse spawn')).id;
+  assert(sid2 === sid, `reuse must continue the SAME session (context kept): ${sid} -> ${sid2}`);
+
+  // --- tier 2: re-spawn the SAME tag while BUSY -> queue, do not throw ---
+  holdBusy = true;
+  const busyStart = await agent.execute({
+    type: 'spawn', agent: 'worker', tag: 'workerB', prompt: 'stay busy please', cwd: root,
+  }, ctx);
+  const busySession = await waitSessionForTag('workerB', 'busy worker');
+  for (let i = 0; i < 40; i += 1) {
+    if (getSession(busySession.id)?.status === 'running') break;
+    await sleep(25);
+  }
+  const queuedOut = await agent.execute({
+    type: 'spawn', agent: 'worker', tag: 'workerB', prompt: 'stacked while busy', cwd: root,
+  }, ctx);
+  assert(/agent message queued/.test(queuedOut), `busy same-tag re-spawn must queue, got: ${queuedOut}`);
+  assert(/reused: true/.test(queuedOut), `busy re-spawn queue should carry reused flag: ${queuedOut}`);
+  holdBusy = false;
+  await waitJob(busyStart, /ack: stay busy please/, 'busy worker finish');
+
+  // --- tier 3: terminal trace only -> coldRespawn keeps the tag ---
+  // --- tier 3: lingering trace without live session must not cold-respawn ---
+  closeSession(sid, 'smoke-session-closed-trace');
+  const traceSpawnOut = await agent.execute({
+    type: 'spawn', agent: 'reviewer', tag: 'reviewerA', prompt: 'must not respawn', cwd: root,
+  }, ctx);
+  assert(/^Error:/.test(traceSpawnOut), `terminal-trace spawn must error, got: ${traceSpawnOut}`);
+  assert(/finished or closed worker/i.test(traceSpawnOut), `spawn error should mention trace: ${traceSpawnOut}`);
+  const traceSendOut = await agent.execute({
+    type: 'send', tag: 'reviewerA', message: 'must not cold-respawn', cwd: root,
+  }, ctx);
+  assert(/^Error:/.test(traceSendOut), `terminal-trace send must error, got: ${traceSendOut}`);
+  assert(/not found|closed/i.test(traceSendOut), `send should surface prepareSend failure: ${traceSendOut}`);
+
+  // agent close clears the trace; same tag can spawn fresh again
+  await agent.execute({ type: 'close', tag: 'reviewerA' }, ctx);
+  const freshAfterClose = await agent.execute({
+    type: 'spawn', agent: 'reviewer', tag: 'reviewerA', prompt: 'post-forget fresh', cwd: root,
+  }, ctx);
+  assert(!/^Error/.test(freshAfterClose), `post-forget spawn must work: ${freshAfterClose}`);
+  await waitJob(freshAfterClose, /ack: post-forget fresh/, 'post-forget spawn');
+
+  process.stdout.write(`agent tag-reuse smoke passed (asks=${askLog.length})\n`);
+}
+
+try {
+  await main();
+} finally {
+  try { agent.closeAll('agent-tag-reuse-smoke-end'); } catch {}
+  rmSync(root, { recursive: true, force: true });
+}

package/scripts/background-task-meta-smoke.mjs

@@ -0,0 +1,38 @@
+import assert from 'node:assert/strict';
+import {
+  registerBackgroundTask,
+  renderBackgroundTask,
+  taskSummary,
+} from '../src/runtime/shared/background-tasks.mjs';
+
+const task = registerBackgroundTask({
+  surface: 'agent',
+  operation: 'spawn',
+  label: 'smoke',
+  meta: {
+    tag: 'w1',
+    role: 'worker',
+    firstResponseTimeoutMs: 30_000,
+    idleTimeoutMs: 120_000,
+    spawnPrepTimeoutMs: 90_000,
+    watchdogPolicy: { firstResponseMs: 30_000 },
+  },
+});
+
+const rendered = renderBackgroundTask(task, { includeResult: false });
+for (const forbidden of [
+  'firstResponseTimeoutMs',
+  'idleTimeoutMs',
+  'spawnPrepTimeoutMs',
+  'watchdogPolicy',
+]) {
+  assert.equal(rendered.includes(forbidden), false, `render leaked ${forbidden}`);
+}
+
+const summary = taskSummary(task);
+assert.equal(summary.firstResponseTimeoutMs, undefined);
+assert.equal(summary.idleTimeoutMs, undefined);
+assert.equal(summary.spawnPrepTimeoutMs, undefined);
+assert.equal(summary.tag, 'w1');
+
+console.log('background-task-meta-smoke: ok');

package/scripts/boot-smoke.mjs

@@ -10,8 +10,18 @@ const FAST_BACKGROUND_ENV = {
   MIXDOG_DISABLE_PROVIDER_WARMUP: '1',
   MIXDOG_DISABLE_CHANNEL_START: '1',
 };
+const DEFAULT_BACKGROUND_ENV = {
+  MIXDOG_DISABLE_SESSION_PREWARM: '',
+  MIXDOG_ENABLE_SESSION_PREWARM: '',
+  MIXDOG_SESSION_PREWARM_DELAY_MS: '',
+  MIXDOG_DISABLE_PROVIDER_WARMUP: '',
+  MIXDOG_ENABLE_PROVIDER_WARMUP: '',
+  MIXDOG_PROVIDER_WARMUP_BEFORE_FIRST_TURN: '',
+  MIXDOG_PROVIDER_WARMUP_DELAY_MS: '',
+  MIXDOG_PROVIDER_MODEL_WARMUP_DELAY_MS: '',
+};
 
-function runCase(name, args, { env = {}, input = null, expectStdout = null, expectStderr = null } = {}) {
+function runCase(name, args, { env = {}, input = null, expectStdout = null, expectStderr = null, maxMs = THRESHOLD_MS } = {}) {
   const startedAt = performance.now();
   const result = spawnSync(process.execPath, args, {
     cwd: root,
@@ -19,7 +29,7 @@ function runCase(name, args, { env = {}, input = null, expectStdout = null, expe
     input,
     encoding: 'utf8',
     stdio: [input == null ? 'ignore' : 'pipe', 'pipe', 'pipe'],
-    timeout: Math.max(10_000, THRESHOLD_MS + 5_000),
+    timeout: Math.max(10_000, maxMs + 5_000),
   });
   const ms = performance.now() - startedAt;
   const stdout = result.stdout || '';
@@ -33,8 +43,8 @@ function runCase(name, args, { env = {}, input = null, expectStdout = null, expe
   if (expectStderr && !stderr.includes(expectStderr)) {
     throw new Error(`${name} stderr missing ${expectStderr}:\n${stderr.slice(0, 1000)}`);
   }
-  if (ms > THRESHOLD_MS) {
-    throw new Error(`${name} boot smoke exceeded ${THRESHOLD_MS}ms (${ms.toFixed(1)}ms)`);
+  if (ms > maxMs) {
+    throw new Error(`${name} boot smoke exceeded ${maxMs}ms (${ms.toFixed(1)}ms)`);
   }
   return { name, ms: Math.round(ms * 10) / 10 };
 }
@@ -54,19 +64,22 @@ const rows = [
     try {
       const status = runtime.toolsStatus();
       const active = new Set(status.activeTools || []);
-      for (const name of ['read','code_graph','grep','glob','list','apply_patch','explore','bridge','tool_search','shell']) {
+      for (const name of ['read','code_graph','grep','find','glob','list','apply_patch','explore','agent','shell','task','cwd','recall','search','web_fetch','Skill','tool_search']) {
         if (!active.has(name)) throw new Error('missing ' + name + ' in ' + [...active].join(','));
       }
-      for (const name of ['bash','task']) {
+      for (const name of ['bash']) {
         if (active.has(name)) throw new Error('unexpected ' + name + ' in ' + [...active].join(','));
       }
       const result = runtime.selectTools('shell');
-      if (!result.already.includes('shell') || !result.added.includes('task')) {
-        throw new Error('shell alias should keep shell active and add task: ' + JSON.stringify(result));
+      const selectedNames = new Set([...(result.added || []), ...(result.already || [])]);
+      if (!selectedNames.has('shell') || !selectedNames.has('task')) {
+        throw new Error('shell alias should resolve shell and task: ' + JSON.stringify(result));
       }
       const nextActive = new Set(result.status.activeTools || []);
+      const nextDiscovered = new Set(result.status.discoveredTools || []);
       for (const name of ['shell','task']) {
-        if (!nextActive.has(name)) throw new Error('selected tool missing ' + name + ' in ' + [...nextActive].join(','));
+        const selected = result.native === true ? nextDiscovered : nextActive;
+        if (!selected.has(name) && !nextActive.has(name)) throw new Error('selected tool missing ' + name + ' in ' + [...selected].join(','));
       }
       console.log('runtime_tools active=' + status.activeCount + '/' + status.count + ' selected=' + result.added.join(','));
     } finally {
@@ -86,6 +99,36 @@ const rows = [
     input: '/quit\n',
     expectStdout: 'bye.',
   }),
+  runCase('runtime_idle_exit', ['--input-type=module', '-e', `
+    const { createMixdogSessionRuntime } = await import('./src/mixdog-session-runtime.mjs');
+    const runtime = await createMixdogSessionRuntime({ toolMode: 'full' });
+    await new Promise((resolve) => setTimeout(resolve, 450));
+    const startedAt = performance.now();
+    await runtime.close('runtime-idle-exit-smoke', { waitForExit: false });
+    console.log('runtime_idle_exit close_ms=' + (performance.now() - startedAt).toFixed(1));
+  `], {
+    env: { ...DEFAULT_BACKGROUND_ENV, MIXDOG_BOOT_PROFILE: '1' },
+    expectStdout: 'runtime_idle_exit close_ms=',
+    expectStderr: 'session:prewarm-skipped',
+    maxMs: 2_000,
+  }),
+  runCase('runtime_idle_exit_provider_optin', ['--input-type=module', '-e', `
+    const { createMixdogSessionRuntime } = await import('./src/mixdog-session-runtime.mjs');
+    const runtime = await createMixdogSessionRuntime({ toolMode: 'full' });
+    await new Promise((resolve) => setTimeout(resolve, 250));
+    await runtime.close('runtime-provider-optin-exit-smoke', { waitForExit: false });
+    console.log('runtime_idle_exit_provider_optin ok');
+  `], {
+    env: {
+      ...DEFAULT_BACKGROUND_ENV,
+      MIXDOG_BOOT_PROFILE: '1',
+      MIXDOG_ENABLE_PROVIDER_WARMUP: '1',
+      MIXDOG_PROVIDER_WARMUP_DELAY_MS: '100',
+    },
+    expectStdout: 'runtime_idle_exit_provider_optin ok',
+    expectStderr: 'providers:warm-deferred',
+    maxMs: 2_000,
+  }),
 ];
 
 for (const row of rows) {

package/scripts/build-runtime-linux.sh

@@ -0,0 +1,348 @@
+#!/usr/bin/env bash
+# build-runtime-linux.sh — Build self-contained PostgreSQL 16 + pgvector runtime on Linux.
+# Designed to run inside ubuntu:20.04 container (glibc 2.31 floor) so produced
+# binaries run on every distro from Ubuntu 20.04 / Debian 11 / RHEL 8 forward.
+# Targets the runner's native arch (x64 or arm64).
+# Produces: dist/mixdog-runtime-linux-{arch}-pg{pgver}-pgvector{vecver}.tar.gz
+# Bundles foreign dyn deps via ldd transitive closure (binaries + ALL extension
+# modules under lib/postgresql/) + patchelf rpath rewrite. Final smoke: initdb,
+# pg_ctl start, CREATE EXTENSION vector, distance query, stop.
+
+set -euo pipefail
+
+PG_VERSION="16.4"
+PGVECTOR_VERSION="0.8.2"
+TARGET_OS="${TARGET_OS:-linux}"
+TARGET_ARCH="${TARGET_ARCH:-x64}"
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+ROOT_DIR="$(cd "$SCRIPT_DIR/.." && pwd)"
+BUILD_DIR="$ROOT_DIR/build/runtime-linux-$TARGET_ARCH"
+STAGE_DIR="$BUILD_DIR/stage"
+DIST_DIR="$ROOT_DIR/dist"
+RUNTIME_DIR="$BUILD_DIR/runtime"
+
+OUTPUT_NAME="mixdog-runtime-${TARGET_OS}-${TARGET_ARCH}-pg${PG_VERSION}-pgvector${PGVECTOR_VERSION}.tar.gz"
+
+mkdir -p "$BUILD_DIR" "$STAGE_DIR" "$DIST_DIR" "$RUNTIME_DIR"/{bin,lib,share}
+
+# ---------------------------------------------------------------------------
+# Build deps. SUDO=sudo iff non-root; inside ubuntu:20.04 container we are root.
+# ---------------------------------------------------------------------------
+SUDO=""
+if [[ "$(id -u)" -ne 0 ]]; then SUDO="sudo"; fi
+# Export rather than inline-assign before $SUDO: when SUDO is empty (root),
+# `$SUDO DEBIAN_FRONTEND=... apt-get` would parse the env-assignment as a
+# command name and fail with "command not found".
+export DEBIAN_FRONTEND=noninteractive
+
+echo "==> Installing build dependencies"
+$SUDO apt-get update -qq
+$SUDO apt-get install -y --no-install-recommends \
+  build-essential libreadline-dev zlib1g-dev libssl-dev \
+  libicu-dev libxml2-dev libzstd-dev liblz4-dev \
+  pkg-config curl git ca-certificates patchelf file \
+  bsdmainutils
+
+if [[ -x "$STAGE_DIR/bin/postgres" ]]; then
+  echo "==> Cache hit: PG already built at $STAGE_DIR — skipping configure/make"
+  unset TARGET_OS TARGET_ARCH
+else
+  echo "==> Downloading PostgreSQL $PG_VERSION source"
+  cd "$BUILD_DIR"
+  if [[ ! -f "postgresql-${PG_VERSION}.tar.gz" ]]; then
+    curl -fsSL "https://ftp.postgresql.org/pub/source/v${PG_VERSION}/postgresql-${PG_VERSION}.tar.gz" \
+      -o "postgresql-${PG_VERSION}.tar.gz"
+  fi
+  rm -rf "postgresql-${PG_VERSION}"
+  tar xzf "postgresql-${PG_VERSION}.tar.gz"
+
+  echo "==> Configuring PostgreSQL"
+  cd "postgresql-${PG_VERSION}"
+  ./configure \
+    --prefix="$STAGE_DIR" \
+    --without-perl \
+    --without-python \
+    --without-tcl \
+    --with-openssl \
+    --with-libxml \
+    --with-icu \
+    --with-readline \
+    --enable-thread-safety \
+    CFLAGS="-O2"
+
+  echo "==> Building PostgreSQL"
+  # PG Makefile.global has its own TARGET_ARCH var; env-passed TARGET_ARCH=x64
+  # would collide as a make-variable override and leak into compile commands.
+  unset TARGET_OS TARGET_ARCH
+  make -j"$(nproc)"
+  make install
+  make -C contrib/pgcrypto install
+fi
+
+PG_CONFIG="$STAGE_DIR/bin/pg_config"
+export PATH="$STAGE_DIR/bin:$PATH"
+
+echo "==> Stripping PostgreSQL binaries"
+find "$STAGE_DIR" -name '*.so*' -type f -exec strip --strip-debug {} \; 2>/dev/null || true
+find "$STAGE_DIR/bin" -type f -exec strip --strip-all {} \; 2>/dev/null || true
+
+if [[ -f "$STAGE_DIR/lib/postgresql/vector.so" ]]; then
+  echo "==> Cache hit: pgvector already installed — skipping clone/build"
+else
+  echo "==> Cloning pgvector $PGVECTOR_VERSION"
+  cd "$BUILD_DIR"
+  rm -rf pgvector
+  git clone --branch "v${PGVECTOR_VERSION}" --depth 1 \
+    https://github.com/pgvector/pgvector.git pgvector
+
+  echo "==> Building pgvector"
+  cd pgvector
+  make PG_CONFIG="$PG_CONFIG" -j"$(nproc)"
+  make PG_CONFIG="$PG_CONFIG" install
+fi
+
+echo "==> Assembling runtime layout"
+rm -rf "$RUNTIME_DIR"
+mkdir -p "$RUNTIME_DIR"/{bin,lib,share}
+cp -a "$STAGE_DIR/bin/postgres"   "$RUNTIME_DIR/bin/"
+cp -a "$STAGE_DIR/bin/pg_ctl"     "$RUNTIME_DIR/bin/"
+cp -a "$STAGE_DIR/bin/pg_dump"    "$RUNTIME_DIR/bin/"
+cp -a "$STAGE_DIR/bin/pg_restore" "$RUNTIME_DIR/bin/"
+cp -a "$STAGE_DIR/bin/psql"       "$RUNTIME_DIR/bin/"
+cp -a "$STAGE_DIR/bin/initdb"     "$RUNTIME_DIR/bin/"
+
+cp -a "$STAGE_DIR/lib"/.   "$RUNTIME_DIR/lib/"   2>/dev/null || true
+cp -a "$STAGE_DIR/share"/. "$RUNTIME_DIR/share/" 2>/dev/null || true
+
+# ---------------------------------------------------------------------------
+# Bundle foreign dyn deps — seed from binaries AND every extension module
+# under lib/postgresql/. dlopen-loaded modules (extensions) need the same
+# treatment as direct binary deps; missing them = runtime "ERROR: could not
+# load library" on CREATE EXTENSION.
+# ---------------------------------------------------------------------------
+echo "==> Bundling foreign dynamic dependencies (binaries + extensions)"
+
+KEEP_RE='^(linux-vdso|ld-linux|libc\.so|libm\.so|libpthread\.so|libdl\.so|librt\.so|libnsl\.so|libresolv\.so)'
+
+collect_deps() {
+  ldd "$1" 2>/dev/null \
+    | awk '/=>/{print $3}' \
+    | grep -E '^/' \
+    | while read -r path; do
+        bn=$(basename "$path")
+        if echo "$bn" | grep -Eq "$KEEP_RE"; then
+          continue  # system lib — keep on host
+        fi
+        echo "$path"
+      done \
+    | sort -u
+}
+
+declare -A SEEN
+declare -a QUEUE
+# Seeds: binaries + every .so under lib/postgresql/ (extensions, contrib mods).
+for seed in "$RUNTIME_DIR/bin/postgres" "$RUNTIME_DIR/bin/psql" \
+            "$RUNTIME_DIR/bin/pg_ctl"; do
+  [[ -f "$seed" ]] && QUEUE+=("$seed")
+done
+while IFS= read -r -d '' ext; do
+  QUEUE+=("$ext")
+done < <(find "$RUNTIME_DIR/lib/postgresql" -name '*.so' -print0 2>/dev/null)
+
+declare -a FOREIGN
+while [[ ${#QUEUE[@]} -gt 0 ]]; do
+  current="${QUEUE[0]}"
+  QUEUE=("${QUEUE[@]:1}")
+  while IFS= read -r dep; do
+    real="$(readlink -f "$dep")"
+    [[ -n "${SEEN[$real]+x}" ]] && continue
+    SEEN[$real]=1
+    FOREIGN+=("$dep")
+    QUEUE+=("$dep")
+  done < <(collect_deps "$current")
+done
+
+# Sanity: glibc / loader must never be bundled — if KEEP_RE regresses this catches it.
+if find "$RUNTIME_DIR/lib" -maxdepth 1 \
+     \( -name 'libc.so*' -o -name 'ld-linux*' -o -name 'libpthread.so*' \) \
+   | grep -q .; then
+  echo "FATAL: bundled glibc/loader detected — KEEP_RE filter did not work"
+  exit 1
+fi
+
+echo "  bundling ${#FOREIGN[@]} foreign libraries"
+for so_path in "${FOREIGN[@]}"; do
+  real_path="$(readlink -f "$so_path")"
+  real_name="$(basename "$real_path")"
+  if [[ ! -f "$RUNTIME_DIR/lib/$real_name" ]]; then
+    cp -L "$real_path" "$RUNTIME_DIR/lib/$real_name"
+    chmod u+w "$RUNTIME_DIR/lib/$real_name"
+    echo "    + $real_name"
+  fi
+  link="$so_path"
+  while [[ -L "$link" ]]; do
+    link_name="$(basename "$link")"
+    link_target="$(readlink "$link")"
+    if [[ ! -e "$RUNTIME_DIR/lib/$link_name" ]]; then
+      ln -sf "$(basename "$link_target")" "$RUNTIME_DIR/lib/$link_name"
+    fi
+    link="$(dirname "$link")/$link_target"
+  done
+done
+
+echo "==> Stripping static archives from lib/"
+find "$RUNTIME_DIR/lib" -name '*.a' -delete
+
+echo "==> Patching rpath"
+# Binaries: $ORIGIN/../lib (from bin/ to lib/)
+find "$RUNTIME_DIR/bin" -type f -executable | while read -r bin; do
+  if file "$bin" 2>/dev/null | grep -q ELF; then
+    patchelf --set-rpath '$ORIGIN/../lib' "$bin" 2>/dev/null || true
+  fi
+done
+# Top-level lib/*.so*: $ORIGIN
+find "$RUNTIME_DIR/lib" -maxdepth 1 -type f -name '*.so*' | while read -r so; do
+  if file "$so" 2>/dev/null | grep -q ELF; then
+    patchelf --set-rpath '$ORIGIN' "$so" 2>/dev/null || true
+  fi
+done
+# Every extension module under lib/postgresql/: $ORIGIN/.. (=lib/) and $ORIGIN/../.. (=runtime root)
+find "$RUNTIME_DIR/lib/postgresql" -name '*.so' 2>/dev/null | while read -r ext; do
+  if file "$ext" 2>/dev/null | grep -q ELF; then
+    patchelf --set-rpath '$ORIGIN/..:$ORIGIN/../..' "$ext" 2>/dev/null || true
+  fi
+done
+
+# ---------------------------------------------------------------------------
+# Self-contained smoke — full PG lifecycle, not just --version
+# ---------------------------------------------------------------------------
+echo "==> Self-contained smoke test (initdb + CREATE EXTENSION vector + distance query)"
+unset LD_LIBRARY_PATH
+SMOKE_DATA="$BUILD_DIR/smoke-pgdata"
+SMOKE_LOG="$BUILD_DIR/smoke-pg.log"
+SMOKE_PORT=55899
+
+# PG initdb refuses to run as root. Inside ubuntu:20.04 container we are root,
+# so create an unprivileged user and run the smoke under it.
+if [[ "$(id -u)" -eq 0 ]]; then
+  if ! id pguser >/dev/null 2>&1; then useradd -m -s /bin/bash pguser; fi
+  chown -R pguser:pguser "$BUILD_DIR"
+  RUN_AS=(runuser -u pguser --)
+else
+  RUN_AS=()
+fi
+
+"${RUN_AS[@]}" "$RUNTIME_DIR/bin/postgres" --version || { echo "FAIL: postgres --version"; exit 1; }
+MISSING="$(ldd "$RUNTIME_DIR/bin/postgres" 2>&1 | grep 'not found' || true)"
+if [[ -n "$MISSING" ]]; then echo "FAIL: missing deps in postgres:"; echo "$MISSING"; exit 1; fi
+
+SMOKE_OK=""
+for attempt in 1 2 3; do
+  echo "==> Self-contained smoke (attempt $attempt/3)"
+  rm -rf "$SMOKE_DATA"
+  set +e
+  (
+    set -e
+    "${RUN_AS[@]}" "$RUNTIME_DIR/bin/initdb" -D "$SMOKE_DATA" --auth-local=trust --no-locale -E UTF8 -U postgres > /dev/null
+    "${RUN_AS[@]}" "$RUNTIME_DIR/bin/pg_ctl" -D "$SMOKE_DATA" -o "-p $SMOKE_PORT -h 127.0.0.1" -l "$SMOKE_LOG" -w start
+    "${RUN_AS[@]}" "$RUNTIME_DIR/bin/psql" -h 127.0.0.1 -p "$SMOKE_PORT" -U postgres -d postgres -c "CREATE EXTENSION vector;" > /dev/null
+    EXTV="$("${RUN_AS[@]}" "$RUNTIME_DIR/bin/psql" -h 127.0.0.1 -p "$SMOKE_PORT" -U postgres -d postgres -tAc "SELECT extversion FROM pg_extension WHERE extname='vector';")"
+    DIST="$("${RUN_AS[@]}" "$RUNTIME_DIR/bin/psql" -h 127.0.0.1 -p "$SMOKE_PORT" -U postgres -d postgres -tAc "SELECT '[1,2,3]'::vector <-> '[1,2,4]'::vector;")"
+    echo "  vector extension version: $EXTV"
+    echo "  distance query result:    $DIST"
+    [[ "$EXTV" == "$PGVECTOR_VERSION" ]] || { echo "FAIL: extversion=$EXTV expected=$PGVECTOR_VERSION"; exit 1; }
+    "${RUN_AS[@]}" "$RUNTIME_DIR/bin/pg_ctl" -D "$SMOKE_DATA" -m fast stop > /dev/null
+  )
+  attempt_rc=$?
+  set -e
+  if [[ $attempt_rc -eq 0 ]]; then
+    rm -rf "$SMOKE_DATA"
+    echo "  PASS smoke (extension load + vector distance)"
+    SMOKE_OK=1
+    break
+  fi
+  echo "  attempt $attempt failed (rc=$attempt_rc) — cleaning up"
+  echo "  -- last 20 lines of $SMOKE_LOG --"
+  tail -20 "$SMOKE_LOG" 2>/dev/null || true
+  "${RUN_AS[@]}" "$RUNTIME_DIR/bin/pg_ctl" -D "$SMOKE_DATA" -m immediate stop > /dev/null 2>&1 || true
+  pkill -f "$RUNTIME_DIR/bin/postgres" > /dev/null 2>&1 || true
+  rm -rf "$SMOKE_DATA"
+done
+if [[ -z "${SMOKE_OK:-}" ]]; then
+  echo "FAIL: smoke failed all 3 attempts"
+  exit 1
+fi
+
+# Licenses
+curl -fsSL "https://raw.githubusercontent.com/postgres/postgres/REL_16_STABLE/COPYRIGHT" \
+  -o "$RUNTIME_DIR/LICENSE.postgresql"
+cp "$BUILD_DIR/pgvector/LICENSE" "$RUNTIME_DIR/LICENSE.pgvector"
+
+echo "==> Creating tarball: $OUTPUT_NAME"
+tar czf "$DIST_DIR/$OUTPUT_NAME" -C "$RUNTIME_DIR" .
+
+echo "==> Generating sha256 sidecar"
+cd "$DIST_DIR"
+sha256sum "$OUTPUT_NAME" > "${OUTPUT_NAME}.sha256"
+
+# ---------------------------------------------------------------------------
+# Phase A: Re-smoke from EXTRACTED tarball with hostile env. Catches false-pass
+# where the build host happens to satisfy a dep that the tarball is missing.
+# Uses `env -i` to clear all variables, minimal PATH, fresh data dir.
+# ---------------------------------------------------------------------------
+echo "==> Re-smoke from extracted tarball (hostile env, verify self-contained)"
+EXTRACT_DIR="$BUILD_DIR/extract-smoke"
+rm -rf "$EXTRACT_DIR"; mkdir -p "$EXTRACT_DIR"
+tar xzf "$DIST_DIR/$OUTPUT_NAME" -C "$EXTRACT_DIR"
+if [[ "$(id -u)" -eq 0 ]]; then chown -R pguser:pguser "$EXTRACT_DIR"; fi
+EXTRACT_DATA="$EXTRACT_DIR/extract-pgdata"
+EXTRACT_LOG="$EXTRACT_DIR/extract-pg.log"
+EXTRACT_PORT=55898
+
+"${RUN_AS[@]}" env -i HOME="$EXTRACT_DIR" PATH="/usr/bin:/bin" \
+  "$EXTRACT_DIR/bin/postgres" --version
+
+EXTRACT_SMOKE_OK=""
+for attempt in 1 2 3; do
+  echo "==> Re-smoke from extracted tarball (attempt $attempt/3)"
+  rm -rf "$EXTRACT_DATA"
+  set +e
+  (
+    set -e
+    "${RUN_AS[@]}" env -i HOME="$EXTRACT_DIR" PATH="/usr/bin:/bin" \
+      "$EXTRACT_DIR/bin/initdb" -D "$EXTRACT_DATA" --auth-local=trust --no-locale -E UTF8 -U postgres > /dev/null
+    "${RUN_AS[@]}" env -i HOME="$EXTRACT_DIR" PATH="/usr/bin:/bin" \
+      "$EXTRACT_DIR/bin/pg_ctl" -D "$EXTRACT_DATA" -o "-p $EXTRACT_PORT -h 127.0.0.1" -l "$EXTRACT_LOG" -w start
+    "${RUN_AS[@]}" env -i HOME="$EXTRACT_DIR" PATH="/usr/bin:/bin" \
+      "$EXTRACT_DIR/bin/psql" -h 127.0.0.1 -p "$EXTRACT_PORT" -U postgres -d postgres -c "CREATE EXTENSION vector;" > /dev/null
+    EXTV2="$("${RUN_AS[@]}" env -i HOME="$EXTRACT_DIR" PATH="/usr/bin:/bin" \
+      "$EXTRACT_DIR/bin/psql" -h 127.0.0.1 -p "$EXTRACT_PORT" -U postgres -d postgres -tAc \
+      "SELECT extversion FROM pg_extension WHERE extname='vector';")"
+    [[ "$EXTV2" == "$PGVECTOR_VERSION" ]] || { echo "FAIL: extracted-smoke extversion=$EXTV2"; exit 1; }
+    "${RUN_AS[@]}" env -i HOME="$EXTRACT_DIR" PATH="/usr/bin:/bin" \
+      "$EXTRACT_DIR/bin/pg_ctl" -D "$EXTRACT_DATA" -m fast stop > /dev/null
+  )
+  attempt_rc=$?
+  set -e
+  if [[ $attempt_rc -eq 0 ]]; then
+    rm -rf "$EXTRACT_DIR"
+    echo "  PASS extracted-tarball smoke"
+    EXTRACT_SMOKE_OK=1
+    break
+  fi
+  echo "  attempt $attempt failed (rc=$attempt_rc) — cleaning up"
+  echo "  -- last 20 lines of $EXTRACT_LOG --"
+  tail -20 "$EXTRACT_LOG" 2>/dev/null || true
+  "${RUN_AS[@]}" env -i HOME="$EXTRACT_DIR" PATH="/usr/bin:/bin" \
+    "$EXTRACT_DIR/bin/pg_ctl" -D "$EXTRACT_DATA" -m immediate stop > /dev/null 2>&1 || true
+  pkill -f "$EXTRACT_DIR/bin/postgres" > /dev/null 2>&1 || true
+  rm -rf "$EXTRACT_DATA"
+done
+if [[ -z "${EXTRACT_SMOKE_OK:-}" ]]; then
+  echo "FAIL: extracted-tarball smoke failed all 3 attempts"
+  exit 1
+fi
+
+echo "==> Done: $DIST_DIR/$OUTPUT_NAME"
+ls -lh "$DIST_DIR/$OUTPUT_NAME"