mixdog 0.9.63 → 0.9.65

package/scripts/ship-mode-test.mjs

@@ -1,98 +0,0 @@
-import assert from 'node:assert/strict';
-import test from 'node:test';
-import { createRequire } from 'node:module';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-
-const require = createRequire(import.meta.url);
-const debug = require('../src/lib/mixdog-debug.cjs');
-
-const MODE_ENVS = [
-  'MIXDOG_MODE',
-  'MIXDOG_SHIP',
-  'MIXDOG_DIAGNOSTICS',
-  'MIXDOG_DEBUG',
-  'MIXDOG_DEBUG_SESSION_START',
-  'MIXDOG_AGENT_TRACE_LOCAL_DISABLE',
-  'MIXDOG_AGENT_TRACE_PATH',
-  'MIXDOG_TOOL_FAILURE_LOG_DISABLE',
-  'MIXDOG_TOOL_FAILURE_LOG_PATH',
-];
-
-function withEnv(overrides, fn) {
-  const prev = {};
-  for (const k of MODE_ENVS) prev[k] = process.env[k];
-  for (const k of MODE_ENVS) delete process.env[k];
-  for (const [k, v] of Object.entries(overrides)) process.env[k] = v;
-  try { return fn(); }
-  finally {
-    for (const k of MODE_ENVS) {
-      if (prev[k] == null) delete process.env[k];
-      else process.env[k] = prev[k];
-    }
-  }
-}
-
-test('MIXDOG_MODE=ship forces shipping mode with diagnostics off', () => {
-  withEnv({ MIXDOG_MODE: 'ship' }, () => {
-    assert.equal(debug.resolveMixdogMode(), 'ship');
-    assert.equal(debug.isShippingMode(), true);
-    assert.equal(debug.isDevMode(), false);
-    assert.equal(debug.isDiagnosticIOEnabled(), false);
-  });
-});
-
-test('MIXDOG_MODE=dev forces dev mode with diagnostics on', () => {
-  withEnv({ MIXDOG_MODE: 'dev' }, () => {
-    assert.equal(debug.resolveMixdogMode(), 'dev');
-    assert.equal(debug.isDiagnosticIOEnabled(), true);
-  });
-});
-
-test('MIXDOG_DEBUG implies dev mode', () => {
-  withEnv({ MIXDOG_MODE: 'ship', MIXDOG_DEBUG: '1' }, () => {
-    // explicit MIXDOG_MODE=ship still wins over debug flag by precedence
-    assert.equal(debug.resolveMixdogMode(), 'ship');
-  });
-  withEnv({ MIXDOG_DEBUG: '1' }, () => {
-    assert.equal(debug.resolveMixdogMode(), 'dev');
-    assert.equal(debug.isDiagnosticIOEnabled(), true);
-  });
-});
-
-test('MIXDOG_DIAGNOSTICS force-enables diagnostic IO under shipping', () => {
-  withEnv({ MIXDOG_MODE: 'ship', MIXDOG_DIAGNOSTICS: '1' }, () => {
-    assert.equal(debug.isShippingMode(), true);
-    assert.equal(debug.isDiagnosticIOEnabled(), true);
-  });
-});
-
-test('shipping mode suppresses default diagnostic file paths', async () => {
-  const io = await import('../src/runtime/agent/orchestrator/agent-trace-io.mjs?ship-default');
-  withEnv({ MIXDOG_MODE: 'ship' }, () => {
-    assert.equal(io._resolveLocalTracePath(), null);
-    assert.equal(io._resolveToolFailurePath(), null);
-  });
-});
-
-test('explicit diagnostic file paths opt in under shipping mode', async () => {
-  const io = await import('../src/runtime/agent/orchestrator/agent-trace-io.mjs?ship-explicit-path');
-  const base = join(tmpdir(), `mixdog-ship-mode-test-${process.pid}`);
-  const tracePath = join(base, 'explicit-agent-trace.jsonl');
-  const failuresPath = join(base, 'explicit-tool-failures.jsonl');
-  withEnv({
-    MIXDOG_MODE: 'ship',
-    MIXDOG_AGENT_TRACE_PATH: tracePath,
-    MIXDOG_TOOL_FAILURE_LOG_PATH: failuresPath,
-  }, () => {
-    assert.equal(io._resolveLocalTracePath(), tracePath);
-    assert.equal(io._resolveToolFailurePath(), failuresPath);
-  });
-});
-
-test('git checkout default stays dev for local diagnostics', () => {
-  withEnv({}, () => {
-    assert.equal(debug.resolveMixdogMode(), 'dev');
-    assert.equal(debug.isDiagnosticIOEnabled(), true);
-  });
-});

package/scripts/smoke-loop-failure-summary-test.mjs

@@ -1,38 +0,0 @@
-import assert from 'node:assert/strict';
-import test from 'node:test';
-import { actionableFailureCount } from './smoke-loop-failure-summary.mjs';
-
-test('returns a numeric actionable failure count', () => {
-  assert.equal(actionableFailureCount('{"actionable_failures":{"matched":0}}'), 0);
-  assert.equal(actionableFailureCount('{"actionable_failures":{"matched":1}}'), 1);
-});
-
-test('rejects malformed tool-failures JSON', () => {
-  assert.throws(
-    () => actionableFailureCount('{'),
-    /tool failures returned malformed JSON/,
-  );
-});
-
-test('rejects a missing or malformed actionable failure count', () => {
-  assert.throws(
-    () => actionableFailureCount('{}'),
-    /tool failures returned malformed result schema/,
-  );
-  assert.throws(
-    () => actionableFailureCount('{"actionable_failures":{"matched":"0"}}'),
-    /tool failures returned malformed result schema/,
-  );
-  assert.throws(
-    () => actionableFailureCount('{"actionable_failures":{"matched":-1}}'),
-    /tool failures returned malformed result schema/,
-  );
-  assert.throws(
-    () => actionableFailureCount('{"actionable_failures":{"matched":0.5}}'),
-    /tool failures returned malformed result schema/,
-  );
-  assert.throws(
-    () => actionableFailureCount('{"actionable_failures":{"matched":1e999}}'),
-    /tool failures returned malformed result schema/,
-  );
-});

package/scripts/smoke-loop-failure-summary.mjs

@@ -1,16 +0,0 @@
-export function actionableFailureCount(stdout) {
-  let summary;
-  try {
-    summary = JSON.parse(stdout);
-  } catch {
-    throw new Error(`tool failures returned malformed JSON:\n${stdout}`);
-  }
-
-  const matched = summary?.actionable_failures?.matched;
-  if (!Number.isInteger(matched) || matched < 0) {
-    throw new Error(
-      `tool failures returned malformed result schema: expected actionable_failures.matched to be a non-negative integer:\n${stdout}`,
-    );
-  }
-  return matched;
-}

package/scripts/smoke-loop-report.mjs

@@ -1,221 +0,0 @@
-#!/usr/bin/env node
-import { existsSync, readFileSync } from 'node:fs';
-import { resolve } from 'node:path';
-
-function argValue(name, fallback = null) {
-  const idx = process.argv.indexOf(name);
-  if (idx >= 0 && idx + 1 < process.argv.length) return process.argv[idx + 1];
-  const prefix = `${name}=`;
-  const hit = process.argv.find((arg) => arg.startsWith(prefix));
-  return hit ? hit.slice(prefix.length) : fallback;
-}
-
-function parseNumber(value, fallback = null) {
-  if (value == null || value === '') return fallback;
-  const n = Number(value);
-  return Number.isFinite(n) ? n : fallback;
-}
-
-function parseDuration(value, fallback = null) {
-  const raw = String(value || '').trim();
-  if (!raw) return fallback;
-  if (/^\d+$/.test(raw)) return Number(raw);
-  const match = raw.match(/^(\d+(?:\.\d+)?)(ms|s|m|h)$/i);
-  if (!match) throw new Error(`invalid duration: ${raw}`);
-  const n = Number(match[1]);
-  const unit = match[2].toLowerCase();
-  const mult = unit === 'ms' ? 1 : unit === 's' ? 1000 : unit === 'm' ? 60_000 : 3_600_000;
-  return Math.max(1, Math.floor(n * mult));
-}
-
-function argValues(name) {
-  const values = [];
-  const prefix = `${name}=`;
-  for (let i = 0; i < process.argv.length; i += 1) {
-    const arg = process.argv[i];
-    if (arg === name && i + 1 < process.argv.length) values.push(process.argv[i + 1]);
-    else if (arg.startsWith(prefix)) values.push(arg.slice(prefix.length));
-  }
-  return values;
-}
-
-function parseStepCaps(values) {
-  const caps = new Map();
-  for (const value of values) {
-    const raw = String(value || '').trim();
-    if (!raw) continue;
-    const idx = raw.lastIndexOf('=');
-    if (idx <= 0) throw new Error(`invalid --max-step-ms value: ${raw}`);
-    const name = raw.slice(0, idx).trim().replace(/^scripts\//, '');
-    const cap = Number(raw.slice(idx + 1).trim());
-    if (!name || !Number.isFinite(cap) || cap < 0) throw new Error(`invalid --max-step-ms value: ${raw}`);
-    caps.set(name, cap);
-  }
-  return caps;
-}
-
-function summarize(values) {
-  if (!values.length) return { min: 0, max: 0, avg: 0 };
-  const min = Math.min(...values);
-  const max = Math.max(...values);
-  const avg = values.reduce((sum, value) => sum + value, 0) / values.length;
-  return {
-    min: Math.round(min * 10) / 10,
-    max: Math.round(max * 10) / 10,
-    avg: Math.round(avg * 10) / 10,
-  };
-}
-
-function readRows(path) {
-  if (!existsSync(path)) throw new Error(`smoke loop log not found: ${path}`);
-  return readFileSync(path, 'utf8')
-    .split(/\r?\n/)
-    .filter(Boolean)
-    .map((line, index) => {
-      try {
-        return JSON.parse(line);
-      } catch (error) {
-        return { type: 'parse_error', line: index + 1, error: error?.message || String(error), raw: line };
-      }
-    });
-}
-
-function formatDuration(ms) {
-  const total = Math.max(0, Math.round(Number(ms) || 0));
-  const h = Math.floor(total / 3_600_000);
-  const m = Math.floor((total % 3_600_000) / 60_000);
-  const s = Math.floor((total % 60_000) / 1000);
-  if (h > 0) return `${h}h ${m}m ${s}s`;
-  if (m > 0) return `${m}m ${s}s`;
-  return `${s}s`;
-}
-
-function summarizeSteps(iterations) {
-  const byScript = new Map();
-  for (const row of iterations) {
-    if (!Array.isArray(row.steps)) continue;
-    for (const step of row.steps) {
-      const script = String(step?.script || '').replace(/^scripts\//, '');
-      const ms = Number(step?.ms);
-      if (!script || !Number.isFinite(ms)) continue;
-      const values = byScript.get(script) || [];
-      values.push(ms);
-      byScript.set(script, values);
-    }
-  }
-  return Object.fromEntries([...byScript.entries()].map(([script, values]) => [script, summarize(values)]));
-}
-
-const logPath = resolve(argValue('--log', '.mixdog/data/history/smoke-loop.jsonl'));
-const pidArg = parseNumber(argValue('--pid', null), null);
-const minIterations = parseNumber(argValue('--min-iterations', null), null);
-const minElapsedMs = parseDuration(argValue('--min-elapsed', null), null);
-const maxGapMs = parseDuration(argValue('--max-gap', null), null);
-const maxStaleMs = parseDuration(argValue('--max-stale', null), null);
-const maxSmokeMs = parseNumber(argValue('--max-smoke-ms', null), null);
-const maxAvgSmokeMs = parseNumber(argValue('--max-avg-smoke-ms', null), null);
-const maxStepMs = parseStepCaps(argValues('--max-step-ms'));
-const maxRssMb = parseNumber(argValue('--max-rss-mb', null), null);
-const maxRssGrowthMb = parseNumber(argValue('--max-rss-growth-mb', null), null);
-const jsonMode = process.argv.includes('--json');
-const requireComplete = process.argv.includes('--require-complete');
-
-const rows = readRows(logPath);
-const startRows = rows.filter((row) => row?.type === 'start' && (pidArg == null || Number(row.pid) === pidArg));
-const start = startRows.at(-1);
-if (!start) throw new Error(pidArg == null ? 'no smoke loop start row found' : `no smoke loop start row found for pid ${pidArg}`);
-
-const startIndex = rows.lastIndexOf(start);
-const runRows = rows.slice(startIndex).filter((row) => Number(row.pid) === Number(start.pid));
-const iterations = runRows.filter((row) => row?.type === 'iteration');
-const errors = runRows.filter((row) => row?.type === 'error' || row?.type === 'parse_error');
-const summaryRows = runRows.filter((row) => row?.type === 'summary');
-const last = iterations.at(-1) || null;
-const smoke = summarize(iterations.map((row) => Number(row.smoke_ms)).filter(Number.isFinite));
-const stepMs = summarizeSteps(iterations);
-const rss = summarize(iterations.map((row) => Number(row.rss_mb)).filter(Number.isFinite));
-const startRss = Number(start.rss_mb);
-const lastRss = Number(last?.rss_mb);
-const rssGrowth = Number.isFinite(startRss) && Number.isFinite(lastRss)
-  ? Math.round((lastRss - startRss) * 10) / 10
-  : 0;
-const elapsedMs = Number(last?.elapsed_ms || summaryRows.at(-1)?.elapsed_ms || 0);
-const durationMs = Number(start.duration_ms || 0);
-const remainingMs = durationMs > 0 ? Math.max(0, durationMs - elapsedMs) : null;
-const startTs = Date.parse(start.ts);
-const finishAt = durationMs > 0 && Number.isFinite(startTs)
-  ? new Date(startTs + durationMs).toISOString()
-  : null;
-const iterationsPerHour = elapsedMs > 0
-  ? Math.round((iterations.length / (elapsedMs / 3_600_000)) * 10) / 10
-  : 0;
-const gaps = [];
-for (let i = 1; i < iterations.length; i += 1) {
-  const prev = Date.parse(iterations[i - 1].ts);
-  const cur = Date.parse(iterations[i].ts);
-  if (Number.isFinite(prev) && Number.isFinite(cur)) gaps.push(cur - prev);
-}
-const gapSummary = summarize(gaps);
-const lastTs = Date.parse(last?.ts || '');
-const staleMs = Number.isFinite(lastTs) ? Date.now() - lastTs : null;
-
-const failures = [];
-if (errors.length > 0) failures.push(`errors=${errors.length}`);
-if (requireComplete && summaryRows.length === 0) failures.push('loop has no completed summary row');
-if (minIterations != null && iterations.length < minIterations) failures.push(`iterations ${iterations.length} < ${minIterations}`);
-if (minElapsedMs != null && elapsedMs < minElapsedMs) failures.push(`elapsed ${formatDuration(elapsedMs)} < ${formatDuration(minElapsedMs)}`);
-if (maxGapMs != null && gapSummary.max > maxGapMs) failures.push(`max gap ${formatDuration(gapSummary.max)} > ${formatDuration(maxGapMs)}`);
-if (maxStaleMs != null && staleMs != null && staleMs > maxStaleMs) failures.push(`latest iteration stale ${formatDuration(staleMs)} > ${formatDuration(maxStaleMs)}`);
-if (maxSmokeMs != null && smoke.max > maxSmokeMs) failures.push(`smoke max ${smoke.max}ms > ${maxSmokeMs}ms`);
-if (maxAvgSmokeMs != null && smoke.avg > maxAvgSmokeMs) failures.push(`smoke avg ${smoke.avg}ms > ${maxAvgSmokeMs}ms`);
-for (const [script, cap] of maxStepMs.entries()) {
-  const stats = stepMs[script];
-  if (stats && stats.max > cap) failures.push(`${script} max ${stats.max}ms > ${cap}ms`);
-}
-if (maxRssMb != null && rss.max > maxRssMb) failures.push(`rss max ${rss.max}MB > ${maxRssMb}MB`);
-if (maxRssGrowthMb != null && rssGrowth > maxRssGrowthMb) failures.push(`rss growth ${rssGrowth}MB > ${maxRssGrowthMb}MB`);
-
-const report = {
-  ok: failures.length === 0,
-  pid: start.pid,
-  started_at: start.ts,
-  finish_at: finishAt,
-  elapsed_ms: elapsedMs,
-  elapsed: formatDuration(elapsedMs),
-  remaining_ms: remainingMs,
-  remaining: remainingMs == null ? null : formatDuration(remainingMs),
-  min_elapsed_ms: minElapsedMs,
-  iterations: iterations.length,
-  iterations_per_hour: iterationsPerHour,
-  duration_ms: start.duration_ms,
-  interval_ms: start.interval_ms,
-  smoke_ms: smoke,
-  step_ms: stepMs,
-  max_step_ms: Object.fromEntries(maxStepMs.entries()),
-  rss_mb: rss,
-  rss_growth_mb: rssGrowth,
-  gap_ms: gapSummary,
-  stale_ms: staleMs,
-  errors: errors.length,
-  completed: summaryRows.length > 0,
-  require_complete: requireComplete,
-  latest_iteration: last?.iteration || 0,
-  failures,
-};
-
-if (jsonMode) {
-  console.log(JSON.stringify(report, null, 2));
-} else {
-  console.log(`smoke loop report pid=${report.pid} ok=${report.ok}`);
-  console.log(`started=${report.started_at} finish=${report.finish_at || '-'} elapsed=${report.elapsed} remaining=${report.remaining || '-'} iterations=${report.iterations} rate=${iterationsPerHour}/h completed=${report.completed}`);
-  console.log(`smoke_ms min=${smoke.min} avg=${smoke.avg} max=${smoke.max}`);
-  for (const [script, stats] of Object.entries(stepMs)) {
-    console.log(`${script} min=${stats.min} avg=${stats.avg} max=${stats.max}`);
-  }
-  console.log(`rss_mb min=${rss.min} avg=${rss.avg} max=${rss.max} growth=${rssGrowth}`);
-  console.log(`gap_ms min=${gapSummary.min} avg=${gapSummary.avg} max=${gapSummary.max} stale=${staleMs == null ? '-' : staleMs}`);
-  console.log(`errors=${errors.length}`);
-  if (failures.length) console.log(`failures: ${failures.join('; ')}`);
-}
-
-if (failures.length) process.exit(1);

package/scripts/smoke-loop.mjs

@@ -1,202 +0,0 @@
-#!/usr/bin/env node
-import { appendFileSync, mkdirSync } from 'node:fs';
-import { spawnSync } from 'node:child_process';
-import { dirname, isAbsolute, resolve } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { actionableFailureCount } from './smoke-loop-failure-summary.mjs';
-
-const root = resolve(dirname(fileURLToPath(import.meta.url)), '..');
-const DEFAULT_DURATION_MS = 5 * 60 * 60 * 1000;
-
-function argValue(name, fallback = null) {
-  const idx = process.argv.indexOf(name);
-  if (idx >= 0 && idx + 1 < process.argv.length) return process.argv[idx + 1];
-  const prefix = `${name}=`;
-  const hit = process.argv.find((arg) => arg.startsWith(prefix));
-  return hit ? hit.slice(prefix.length) : fallback;
-}
-
-function argFlag(name) {
-  return process.argv.includes(name);
-}
-
-function parseDuration(value, fallback) {
-  const raw = String(value || '').trim();
-  if (!raw) return fallback;
-  if (/^\d+$/.test(raw)) return Number(raw);
-  const match = raw.match(/^(\d+(?:\.\d+)?)(ms|s|m|h)$/i);
-  if (!match) throw new Error(`invalid duration: ${raw}`);
-  const n = Number(match[1]);
-  const unit = match[2].toLowerCase();
-  const mult = unit === 'ms' ? 1 : unit === 's' ? 1000 : unit === 'm' ? 60_000 : 3_600_000;
-  return Math.max(1, Math.floor(n * mult));
-}
-
-function resolveOptionalPath(value, fallback) {
-  const raw = String(value || '').trim();
-  const picked = raw || fallback;
-  if (!picked) return null;
-  return isAbsolute(picked) ? picked : resolve(root, picked);
-}
-
-function runNode(args, label, timeoutMs = 180_000) {
-  const startedAt = performance.now();
-  const result = spawnSync(process.execPath, args, {
-    cwd: root,
-    encoding: 'utf8',
-    stdio: ['ignore', 'pipe', 'pipe'],
-    timeout: timeoutMs,
-    windowsHide: true,
-  });
-  const ms = performance.now() - startedAt;
-  if (result.status !== 0) {
-    const out = `${result.error ? `${result.error}\n` : ''}${result.stdout || ''}${result.stderr || ''}`.trim();
-    throw new Error(`${label} failed in ${ms.toFixed(1)}ms:\n${out}`);
-  }
-  return { ms, stdout: result.stdout || '', stderr: result.stderr || '' };
-}
-
-function runSmokeAll(iteration) {
-  let totalMs = 0;
-  const steps = [];
-  for (const script of ['scripts/smoke.mjs', 'scripts/boot-smoke.mjs']) {
-    const result = runNode([script], `${script} iteration ${iteration}`);
-    totalMs += result.ms;
-    steps.push({
-      script,
-      ms: Math.round(result.ms * 10) / 10,
-    });
-  }
-  return { ms: totalMs, steps };
-}
-
-function sleep(ms) {
-  return new Promise((resolveSleep) => setTimeout(resolveSleep, ms));
-}
-
-function rssMb() {
-  return Math.round((process.memoryUsage().rss / 1024 / 1024) * 10) / 10;
-}
-
-function summarize(values) {
-  if (!values.length) return { min: 0, max: 0, avg: 0 };
-  const min = Math.min(...values);
-  const max = Math.max(...values);
-  const avg = values.reduce((sum, value) => sum + value, 0) / values.length;
-  return {
-    min: Math.round(min * 10) / 10,
-    max: Math.round(max * 10) / 10,
-    avg: Math.round(avg * 10) / 10,
-  };
-}
-
-function serializeError(error) {
-  return {
-    name: error?.name || 'Error',
-    message: error?.message || String(error),
-    stack: error?.stack || null,
-  };
-}
-
-const durationMs = parseDuration(argValue('--duration', process.env.MIXDOG_SMOKE_LOOP_DURATION), DEFAULT_DURATION_MS);
-const intervalMs = parseDuration(argValue('--interval', process.env.MIXDOG_SMOKE_LOOP_INTERVAL), 0);
-const maxIterations = Number(argValue('--iterations', process.env.MIXDOG_SMOKE_LOOP_ITERATIONS || 0)) || Infinity;
-const logPath = argFlag('--no-log')
-  ? null
-  : resolveOptionalPath(
-    argValue('--log', process.env.MIXDOG_SMOKE_LOOP_LOG),
-    '.mixdog/data/history/smoke-loop.jsonl',
-  );
-const startedAt = Date.now();
-const since = new Date(startedAt).toISOString();
-const deadline = startedAt + durationMs;
-let iteration = 0;
-const smokeTimes = [];
-const rssSamples = [];
-
-function writeLoopLog(row) {
-  if (!logPath) return;
-  mkdirSync(dirname(logPath), { recursive: true });
-  appendFileSync(logPath, `${JSON.stringify({
-    ts: new Date().toISOString(),
-    pid: process.pid,
-    ...row,
-  })}\n`, { encoding: 'utf8', mode: 0o600 });
-}
-
-function writeFatalLog(error) {
-  writeLoopLog({
-    type: 'error',
-    iteration,
-    elapsed_ms: Date.now() - startedAt,
-    error: serializeError(error),
-  });
-}
-
-process.on('uncaughtException', (error) => {
-  writeFatalLog(error);
-  process.stderr.write(`${error?.stack || error}\n`);
-  process.exit(1);
-});
-
-process.on('unhandledRejection', (reason) => {
-  const error = reason instanceof Error ? reason : new Error(String(reason));
-  writeFatalLog(error);
-  process.stderr.write(`${error.stack || error}\n`);
-  process.exit(1);
-});
-
-const startRss = rssMb();
-writeLoopLog({
-  type: 'start',
-  duration_ms: durationMs,
-  interval_ms: intervalMs,
-  max_iterations: Number.isFinite(maxIterations) ? maxIterations : null,
-  since,
-  rss_mb: startRss,
-});
-process.stdout.write(`smoke loop start duration=${durationMs}ms interval=${intervalMs}ms since=${since} rss_mb=${startRss} log=${logPath || 'off'}\n`);
-
-while (Date.now() < deadline && iteration < maxIterations) {
-  iteration += 1;
-  const iterStartedAt = Date.now();
-  const smoke = runSmokeAll(iteration);
-  smokeTimes.push(smoke.ms);
-  const failure = runNode(['scripts/tool-failures.mjs', '--since', since, '--limit', '1', '--json'], `failures iteration ${iteration}`, 60_000);
-  if (actionableFailureCount(failure.stdout) > 0) {
-    throw new Error(`tool failures appeared after loop start:\n${failure.stdout}`);
-  }
-  const currentRss = rssMb();
-  rssSamples.push(currentRss);
-  const elapsedMs = Date.now() - startedAt;
-  writeLoopLog({
-    type: 'iteration',
-    iteration,
-    smoke_ms: Math.round(smoke.ms * 10) / 10,
-    steps: smoke.steps,
-    rss_mb: currentRss,
-    elapsed_ms: elapsedMs,
-  });
-  const stepSummary = smoke.steps.map((step) => `${step.script.replace(/^scripts\//, '')}=${step.ms}ms`).join(' ');
-  process.stdout.write(`iteration ${iteration} ok smoke_ms=${smoke.ms.toFixed(1)} ${stepSummary} rss_mb=${currentRss} elapsed_ms=${elapsedMs}\n`);
-  const remaining = deadline - Date.now();
-  if (remaining <= 0 || iteration >= maxIterations) break;
-  if (intervalMs > 0) await sleep(Math.min(intervalMs, remaining));
-  if (Date.now() === iterStartedAt) await sleep(1);
-}
-
-const smokeSummary = summarize(smokeTimes);
-const rssSummary = summarize(rssSamples);
-const totalElapsedMs = Date.now() - startedAt;
-writeLoopLog({
-  type: 'summary',
-  iterations: iteration,
-  elapsed_ms: totalElapsedMs,
-  smoke_ms: smokeSummary,
-  rss_mb: rssSummary,
-});
-process.stdout.write(
-  `smoke loop passed iterations=${iteration} elapsed_ms=${totalElapsedMs} `
-  + `smoke_ms=min:${smokeSummary.min},avg:${smokeSummary.avg},max:${smokeSummary.max} `
-  + `rss_mb=min:${rssSummary.min},avg:${rssSummary.avg},max:${rssSummary.max}\n`,
-);

package/scripts/smoke-runtime-negative.ps1

@@ -1,106 +0,0 @@
-# smoke-runtime-negative.ps1 — Negative-path tests against released win32-x64
-# runtime tarball. Validates: download, sha256, corrupt-tarball, fresh-extract
-# boot, double-init refusal, hostile-env survival.
-#
-# Env: TAG / OS / ARCH / RUNTIME_RELEASE_REPOSITORY (default tribgames/mixdog)
-
-$ErrorActionPreference = 'Stop'
-
-$Tag         = if ($env:TAG)                { $env:TAG }  else { 'runtime-v0.4.0' }
-$Os          = if ($env:OS)                 { $env:OS }   else { 'win32' }
-$Arch        = if ($env:ARCH)               { $env:ARCH } else { 'x64' }
-$ReleaseRepo = if ($env:RUNTIME_RELEASE_REPOSITORY) { $env:RUNTIME_RELEASE_REPOSITORY } else { 'tribgames/mixdog' }
-$PgVer       = '16.4'
-$PgvectorVer = '0.8.2'
-
-$Asset = "mixdog-runtime-${Os}-${Arch}-pg${PgVer}-pgvector${PgvectorVer}.tar.gz"
-$Url   = "https://github.com/${ReleaseRepo}/releases/download/${Tag}/${Asset}"
-
-$Work = New-Item -ItemType Directory -Force -Path "$env:TEMP\smoke-$([guid]::NewGuid().ToString('N'))" | Select-Object -ExpandProperty FullName
-
-try {
-    Write-Host "==> Negative-path smoke for ${Os}-${Arch} from $Url"
-
-    Write-Host "==> Test 1: HEAD reaches release asset"
-    $resp = Invoke-WebRequest -Uri $Url -Method Head -UseBasicParsing -ErrorAction Stop
-    Write-Host "  HTTP $($resp.StatusCode)"
-
-    Write-Host "==> Test 2: full download + sha256"
-    $TarPath = Join-Path $Work $Asset
-    Invoke-WebRequest -Uri $Url -OutFile $TarPath -UseBasicParsing
-    $sha = (Get-FileHash -Algorithm SHA256 $TarPath).Hash.ToLower()
-    Write-Host "  sha256=$sha"
-
-    Write-Host "==> Test 3: corrupt tarball — flip a byte and ensure tar errors"
-    $CorruptPath = "$Work\corrupt.tar.gz"
-    Copy-Item $TarPath $CorruptPath
-    $bytes = [byte[]]::new(1); $rand = [System.Random]::new(); $rand.NextBytes($bytes)
-    $stream = [System.IO.File]::OpenWrite($CorruptPath)
-    $stream.Position = 102400
-    $stream.Write($bytes, 0, 1)
-    $stream.Close()
-    $CorruptDir = "$Work\corrupt"
-    New-Item -ItemType Directory -Force -Path $CorruptDir | Out-Null
-    $TarProc = Start-Process -FilePath tar -ArgumentList @('-xzf', $CorruptPath, '-C', $CorruptDir.Replace('\','/')) -Wait:$false -PassThru -WindowStyle Hidden
-    if (-not $TarProc.WaitForExit(15000)) {
-        Stop-Process -Id $TarProc.Id -Force -ErrorAction SilentlyContinue
-        Write-Host "  PASS: corrupted tarball extraction timed out and was stopped"
-    } elseif ($TarProc.ExitCode -eq 0) {
-        Write-Host "  WARN: corrupted tarball extracted without error (tar gzip recovery)"
-    } else {
-        Write-Host "  PASS: corrupted tarball rejected by tar (exit $($TarProc.ExitCode))"
-    }
-
-    Write-Host "==> Test 4: fresh-extract boot (extension load + distance query)"
-    $FreshDir = "$Work\fresh"
-    New-Item -ItemType Directory -Force -Path $FreshDir | Out-Null
-    & tar -xzf $TarPath -C ($FreshDir.Replace('\','/'))
-    if ($LASTEXITCODE -ne 0) { throw "fresh extract failed" }
-
-    $PgBin   = "$FreshDir\bin"
-    $Data    = "$FreshDir\pgdata"
-    $Log     = "$FreshDir\pg.log"
-    $Port    = 55897
-
-    # Hostile env: minimal PATH (System32 only), no PGROOT/PGDATA
-    $SavedPath = $env:PATH
-    $SavedPgRoot = $env:PGROOT
-    $env:PATH   = "$env:SystemRoot\System32;$env:SystemRoot"
-    $env:PGROOT = $null
-    $env:PGDATA = $null
-
-    try {
-        & "$PgBin\postgres.exe" --version
-        if ($LASTEXITCODE -ne 0) { throw "FAIL: postgres --version" }
-        & "$PgBin\initdb.exe" -D $Data --username=postgres --auth-local=trust --no-locale -E UTF8 | Out-Null
-        if ($LASTEXITCODE -ne 0) { throw "FAIL: initdb" }
-        & "$PgBin\pg_ctl.exe" -D $Data -o "-p $Port -h 127.0.0.1" -l $Log -w start
-        if ($LASTEXITCODE -ne 0) { Get-Content $Log | Select-Object -Last 30; throw "FAIL: pg_ctl start" }
-
-        try {
-            & "$PgBin\psql.exe" -h 127.0.0.1 -p $Port -U postgres -d postgres -c "CREATE EXTENSION vector;" | Out-Null
-            if ($LASTEXITCODE -ne 0) { throw "FAIL: CREATE EXTENSION" }
-            $ExtV = & "$PgBin\psql.exe" -h 127.0.0.1 -p $Port -U postgres -d postgres -tAc "SELECT extversion FROM pg_extension WHERE extname='vector';"
-            if ($ExtV.Trim() -ne $PgvectorVer) { throw "FAIL: extversion='$ExtV' expected='$PgvectorVer'" }
-            Write-Host "  PASS: fresh-extract boot + vector extension"
-        } finally {
-            & "$PgBin\pg_ctl.exe" -D $Data -m fast stop 2>$null | Out-Null
-        }
-
-        Write-Host "==> Test 5: second initdb on initialized dir refused"
-        $rc = (Start-Process -FilePath "$PgBin\initdb.exe" -ArgumentList "-D",$Data,"-U","postgres" -Wait -PassThru -NoNewWindow).ExitCode
-        if ($rc -eq 0) {
-            Write-Host "  WARN: second initdb succeeded (unexpected)"
-        } else {
-            Write-Host "  PASS: second initdb refused (exit $rc)"
-        }
-    } finally {
-        $env:PATH   = $SavedPath
-        $env:PGROOT = $SavedPgRoot
-    }
-
-    Write-Host "==> All negative-path smokes: PASS"
-}
-finally {
-    Remove-Item -Recurse -Force $Work -ErrorAction SilentlyContinue
-}