@xuda.io/ai_module 1.1.5656 → 1.1.5658

package/xudex_preview.mjs

@@ -0,0 +1,263 @@
+// Xudex preview: the project, actually running.
+//
+// docs/plans/xudex.md section 7, and the last gate of the verify loop in section 6. The verify
+// loop already left the seam open (`runtime_check`); this is what plugs into it.
+//
+// ── Why this is a gate and not a feature ───────────────────────────────────────────────
+// A change can typecheck, pass its tests and build cleanly, and still take the app down the
+// moment it loads: a bad import that only the bundler resolves, a missing environment variable,
+// a component that throws on mount. Those are exactly the failures a customer notices first and
+// the ones a terminal-shaped agent never sees. So "does it still run" is a gate like any other,
+// and its output goes back to the engine through the same repair path as a failing test.
+//
+// ── Two layers, and only one of them exists yet ────────────────────────────────────────
+// SERVER SIDE (built here): we start the dev server ourselves, so a process that dies, refuses
+// to bind, or prints a compile error is visible without a browser at all. That catches most
+// breakage, and it works today on every substrate.
+//
+// BROWSER SIDE (not built): console errors and failed requests from the loaded page, which is
+// what `utils/_autodebug_detect.mjs` already does for deployed apps. It needs a URL the outside
+// world can reach, and `expose_port` returns null until the VM substrate and its proxy land
+// (build order 3.8 and section 7). The seam is here and reports "not checked" rather than
+// pretending a page nobody loaded was fine.
+
+import path from 'node:path';
+
+if (!global._conf) {
+  global._conf = (await import(path.join(process.env.XUDA_HOME, 'common', 'load_conf.mjs'))).loadConf();
+}
+
+const preview_conf = () => global._conf.xudex?.preview || {};
+const num = (key, fallback) => Number(preview_conf()[key]) || fallback;
+
+// Where a project's dev server is told to listen. Fixed per project rather than random, so a
+// restart lands on the same port and anything holding a URL keeps working.
+export const preview_port = function (project_id, base = num('base_port', 4300), span = num('port_span', 200)) {
+  let h = 0;
+  const s = String(project_id || '');
+  for (let i = 0; i < s.length; i++) h = (h * 31 + s.charCodeAt(i)) >>> 0;
+  return base + (h % span);
+};
+
+// What starts this project. `dev` first because that is the one with hot reload, which is the
+// difference between a preview and a screenshot.
+export const detect_dev_command = function (manifest, package_manager = 'npm') {
+  const scripts = manifest?.scripts || {};
+  const script = scripts.dev ? 'dev' : scripts.start ? 'start' : null;
+  if (!script) return null;
+  return { script, argv: package_manager === 'npm' ? ['npm', 'run', script] : [package_manager, 'run', script] };
+};
+
+// Signatures that mean the app is broken rather than merely noisy. Deliberately a small list of
+// things that are unambiguous: a dev server prints a great deal at startup, and treating any
+// mention of the word "error" as a failure would make this gate cry wolf until somebody turned
+// it off, which is the worst outcome available.
+const FATAL_PATTERNS = [
+  // Not `Error: Cannot find module`. Node's ESM loader says
+  // `Error [ERR_MODULE_NOT_FOUND]: Cannot find module '...' imported from ...`, so anchoring on
+  // `Error:` misses the single most common way a broken import kills a dev server. CommonJS says
+  // `Error: Cannot find module`, so matching the phrase alone covers both.
+  /Cannot find module/,
+  /ERR_MODULE_NOT_FOUND/,
+  /\bModule not found\b/,
+  /\bSyntaxError\b/,
+  /\bReferenceError\b/,
+  /\bTypeError\b.*\n\s+at /,
+  /\bEADDRINUSE\b/,
+  /Failed to compile/i,
+  /\[vite\].*error/i,
+  /error during build/i,
+  /Cannot resolve/i,
+];
+
+// Collapse near-identical lines, the same way the autodebug detector does, so a server that
+// prints its one error forty times reports one error rather than forty.
+const normalize = (line) =>
+  String(line)
+    .replace(/:\d+:\d+/g, ':L:C')
+    .replace(/\?t=\d+/g, '?t=*')
+    .replace(/\b0x[0-9a-f]+\b/gi, '0x*')
+    .trim();
+
+// Lines that are part of a failure but are not the STATEMENT of it: stack frames, the caret Node
+// prints under an offending token, and its own internals. They are still captured, because they
+// arrive in the block below the anchor, but anchoring ON one produces a second entry for a failure
+// already reported and leads with `throw new ERR_MODULE_NOT_FOUND(`, which tells the engine
+// nothing it can act on.
+const NOISE_LINE = /^\s*(at\s|throw\s|\^+\s*$)|node:internal\//;
+
+export const extract_errors = function (log, max = num('max_errors', 8)) {
+  const lines = String(log || '').split('\n');
+  const found = new Map();
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (NOISE_LINE.test(line)) continue;
+    if (!FATAL_PATTERNS.some((p) => p.test(line))) continue;
+    // Keep the following lines too: the message names what broke, the stack says where.
+    const block = lines
+      .slice(i, i + 4)
+      .join('\n')
+      .trim();
+    const key = normalize(line);
+    if (!found.has(key)) found.set(key, block);
+    if (found.size >= max) break;
+  }
+  return [...found.values()];
+};
+
+// Single-quote for the shell, the same helper shape index.mjs already uses for detached code runs.
+// Anything built with JSON.stringify goes through the outer shell's expansion first, which is how
+// `$$` in the launch line silently became the wrong pid.
+const shq = (value) => `'${String(value).replace(/'/g, `'\\''`)}'`;
+
+export const create_preview = function ({ conf = preview_conf, now = () => Date.now() } = {}) {
+  const log_path = (project_id) => `/tmp/xudex-preview-${String(project_id).replace(/[^a-zA-Z0-9_-]/g, '')}.log`;
+  const pid_path = (project_id) => `/tmp/xudex-preview-${String(project_id).replace(/[^a-zA-Z0-9_-]/g, '')}.pid`;
+
+  const is_listening = async function (workspace, port) {
+    // Node is guaranteed present (this is a Node project by definition) and curl is not, so the
+    // check is a one-liner rather than a dependency.
+    const probe = `node -e "const n=require('net');const s=n.connect(${port},'127.0.0.1');s.on('connect',()=>{console.log('up');s.end();process.exit(0)});s.on('error',()=>{console.log('down');process.exit(0)});setTimeout(()=>{console.log('down');process.exit(0)},1500)"`;
+    const r = await workspace.exec(['sh', '-c', probe], { timeout_ms: 10000 });
+    return (r.stdout || '').includes('up');
+  };
+
+  return {
+    preview_port,
+    detect_dev_command,
+    extract_errors,
+
+    async status(workspace, project_id, port) {
+      const p = port || preview_port(project_id);
+      return { port: p, listening: await is_listening(workspace, p) };
+    },
+
+    // Stop, and WAIT until it has actually stopped.
+    //
+    // Two things are easy to get wrong here and both were caught by the tests rather than reasoned
+    // about. First, kill the process GROUP: a dev server spawns a bundler and a watcher, and
+    // signalling only the recorded pid leaves them holding the port, which then looks like the
+    // next start failing for no reason. Second, a signal is ASYNCHRONOUS: returning as soon as it
+    // is sent means `stop()` can be followed immediately by a `start()` that cannot bind. On Linux
+    // that race lost consistently; on macOS it happened to win, which is the worst kind of bug.
+    async stop(workspace, project_id, port) {
+      const pf = pid_path(project_id);
+      const p = port || preview_port(project_id);
+      // Signal the recorded process group AND whatever is actually holding the port. The pid file
+      // is the normal path; the port sweep is what handles a machine that has been left with an
+      // orphan by a crashed run, a reboot, or a bug like the quoting one above. The PORT is the
+      // resource being managed, so "stop whatever is on it" is the honest definition of stop, and
+      // without it a single orphan makes that project unusable until somebody logs in.
+      const signal = async (sig) => {
+        const by_pidfile = `[ -f ${pf} ] && kill -${sig} -$(cat ${pf}) 2>/dev/null; [ -f ${pf} ] && kill -${sig} $(cat ${pf}) 2>/dev/null`;
+        // fuser and lsof are each missing on plenty of images, so try both and shrug if neither is
+        // there: the pid-file path above is still the primary.
+        const by_port = `(command -v fuser >/dev/null 2>&1 && fuser -k -${sig} ${p}/tcp 2>/dev/null) || (command -v lsof >/dev/null 2>&1 && kill -${sig} $(lsof -t -i:${p} 2>/dev/null) 2>/dev/null)`;
+        await workspace.exec(['sh', '-c', `${by_pidfile}; ${by_port}; true`], { timeout_ms: 20000 });
+      };
+
+      await signal('TERM');
+      const deadline = now() + num('stop_timeout_ms', 8000);
+      while (now() < deadline) {
+        if (!(await is_listening(workspace, p))) {
+          await workspace.exec(['sh', '-c', `rm -f ${pf}`], { timeout_ms: 10000 });
+          return true;
+        }
+        await new Promise((r) => setTimeout(r, 300));
+      }
+
+      // It ignored the polite request. A dev server that will not exit is holding a port another
+      // run needs, so it does not get a vote.
+      await signal('KILL');
+      await new Promise((r) => setTimeout(r, 500));
+      const still = await is_listening(workspace, p);
+      await workspace.exec(['sh', '-c', `rm -f ${pf}`], { timeout_ms: 10000 });
+      return !still;
+    },
+
+    // Start the dev server and wait for it to answer. Detached with its output redirected to a
+    // file, because a dev server outlives the call that started it: waiting on it would hang the
+    // run forever, which is precisely what `exec` is designed not to allow.
+    async start(workspace, { project_id, manifest, package_manager = 'npm', port, timeout_ms = num('start_timeout_ms', 90000) } = {}) {
+      const cmd = detect_dev_command(manifest, package_manager);
+      if (!cmd) return { started: false, why: 'this project has no dev or start script' };
+
+      const p = port || preview_port(project_id);
+      const lf = log_path(project_id);
+      const pf = pid_path(project_id);
+
+      if (await is_listening(workspace, p)) return { started: true, already: true, port: p, log: lf };
+
+      await workspace.exec(['sh', '-c', `rm -f ${lf}`], { timeout_ms: 10000 });
+      // Same shape UI-220 already proved for detached code runs, and for the same two reasons.
+      //
+      // `setsid` makes the launched shell a SESSION LEADER, which is what lets `kill -pid` reach
+      // the dev server plus the bundler and watcher it spawns. Backgrounding alone does not: the
+      // recorded pid would be the wrapper, and killing it leaves children holding the port, which
+      // then looks like the next start failing for no reason.
+      //
+      // The shell writes its own `$$` and then EXECs, so the recorded pid IS the server rather
+      // than a parent that is about to disappear.
+      //
+      // `setsid` is util-linux and is absent on macOS, so it is resolved rather than assumed. The
+      // fleet has it; a developer's laptop running the tests does not, and a preview that only
+      // works on Linux is a preview nobody can test before deploying.
+      const argv = cmd.argv.join(' ');
+      // SINGLE quotes, and this is not a style choice. The inner script has to reach `sh -c`
+      // with `$$` intact so the new shell expands it to ITS OWN pid. Building this with
+      // JSON.stringify produces double quotes, which means the OUTER shell expands `$$` first and
+      // the pid file ends up holding the pid of a shell that exits a moment later. Everything
+      // still appears to work: the server starts, the file exists, and `stop` then signals a dead
+      // pid and silently leaves the dev server running forever. It passed on macOS by luck of
+      // process-group layout and left orphans holding ports on Linux.
+      const inner = `echo $$ > ${pf}; exec ${argv}`;
+      const launch = `cd ${shq(workspace.dir)} && SETSID=$(command -v setsid || true); PORT=${p} $SETSID sh -c ${shq(inner)} > ${shq(lf)} 2>&1 &`;
+      await workspace.exec(['sh', '-c', launch], { timeout_ms: 30000 });
+
+      const deadline = now() + timeout_ms;
+      while (now() < deadline) {
+        if (await is_listening(workspace, p)) return { started: true, port: p, log: lf, command: cmd.argv.join(' ') };
+        // A server that has already printed a fatal error is not going to come up, and waiting
+        // the full ninety seconds to say so wastes the customer's time for no information.
+        const tail = await workspace.exec(['sh', '-c', `tail -c 20000 ${lf} 2>/dev/null || true`], { timeout_ms: 10000 });
+        const errors = extract_errors(tail.stdout);
+        if (errors.length) return { started: false, port: p, log: lf, errors, why: 'the dev server failed to start' };
+        await new Promise((r) => setTimeout(r, num('poll_interval_ms', 1000)));
+      }
+
+      const tail = await workspace.exec(['sh', '-c', `tail -c 20000 ${lf} 2>/dev/null || true`], { timeout_ms: 10000 });
+      return { started: false, port: p, log: lf, errors: extract_errors(tail.stdout), why: `the dev server did not answer on port ${p} within ${Math.round(timeout_ms / 1000)}s` };
+    },
+
+    // The verify loop's `runtime_check`. Returns the shape that loop expects, and returns
+    // ok:true with a plain explanation when there is nothing to check, because a project with no
+    // dev server has not passed a preview check, it simply has not got one.
+    runtime_check({ project_id, manifest, package_manager = 'npm' } = {}) {
+      return async (workspace) => {
+        const cmd = detect_dev_command(manifest, package_manager);
+        if (!cmd) return { ok: true, skipped: true, output: 'this project has no dev server to check' };
+
+        const started = await this.start(workspace, { project_id, manifest, package_manager });
+        if (!started.started) {
+          return { ok: false, output: [started.why, '', ...(started.errors || [])].join('\n').trim() };
+        }
+
+        // It is listening. Now look at what it said on the way up: a dev server can bind its port
+        // and still be serving a compile error, which is exactly the failure a customer sees.
+        const tail = await workspace.exec(['sh', '-c', `tail -c 20000 ${started.log} 2>/dev/null || true`], { timeout_ms: 10000 });
+        const errors = extract_errors(tail.stdout);
+        if (errors.length) return { ok: false, output: ['the app is running but reported errors', '', ...errors].join('\n') };
+
+        // The browser leg. `expose_port` is null on every substrate that cannot publish a port,
+        // so this reports honestly instead of claiming a page nobody loaded was fine.
+        let url = null;
+        try {
+          const exposed = await workspace.expose_port(started.port);
+          url = exposed?.url || null;
+        } catch (e) {}
+
+        return { ok: true, port: started.port, url, browser_checked: false, output: url ? `running at ${url}` : 'running, no public url on this machine yet' };
+      };
+    },
+  };
+};

package/xudex_run.mjs

@@ -0,0 +1,231 @@
+// A xudex run: the piece that makes the other five worth having.
+//
+// docs/plans/xudex.md. Everything before this was a component with a test. This is the loop
+// the customer actually experiences, and it is the whole product in one function:
+//
+//   mirror  ->  workspace  ->  engine  ->  capture  ->  verify  ->  repair  ->  answer
+//
+// Read it as a sequence of promises kept:
+//
+//   the token never leaves the region server        (the mirror, 9.2)
+//   the machine is swappable                        (the runtime interface, 3.8)
+//   nothing above knows which CLI ran               (the engine seam, 5.1)
+//   the change set is the repository's opinion      (capture, from UI-226)
+//   nobody is told "done" over a broken build       (the verify loop, 6)
+//   we know what the run cost and whether it mined  (the tracker, 9.4)
+//
+// ── Why everything is injected ─────────────────────────────────────────────────────────
+// Every dependency arrives as a parameter, which is not ceremony: it is what lets the whole
+// chain be driven end to end in a test with a scripted engine, against a real git repository
+// and a real workspace, without spending an API call or waiting on a model. The one thing
+// that must be right here is the ORDER and the ERROR HANDLING, and both are only testable if
+// the engine can be made to behave on demand.
+
+import path from 'node:path';
+
+if (!global._conf) {
+  global._conf = (await import(path.join(process.env.XUDA_HOME, 'common', 'load_conf.mjs'))).loadConf();
+}
+
+// Same branch contract as the Code tab: a chat owns a branch, and the default branch is never
+// checked out for writing, so nothing a run does can reach main without a person merging it.
+export const run_branch = function (conversation_id) {
+  return `xuda/${String(conversation_id || '').replace(/^cov_/, '').slice(0, 12)}`;
+};
+
+// git status porcelain, minus whatever was already dirty when the run started. This is UI-226's
+// decision and it is load-bearing: the change set is what the REPOSITORY says changed, never what
+// the agent claims it changed. An agent that forgets to mention a file, or invents one, cannot
+// make the file list wrong, and the same code works for every engine.
+export const parse_status = function (stdout) {
+  const out = [];
+  for (const line of String(stdout || '').split('\n')) {
+    if (!line.trim()) continue;
+    // Porcelain is `XY <path>`, and the runner trims output, which removes the leading space of
+    // the FIRST line only. A fixed column-3 slice therefore ate the first character of the first
+    // path, which is exactly the bug UI-226 found (`app.js` came back as `pp.js`). Matching the
+    // status codes instead of counting columns cannot regress that way.
+    const m = line.match(/^\s*([A-Z?!ADMRCU ]{1,2})\s+(.+)$/);
+    if (!m) continue;
+    const rel = m[2].includes(' -> ') ? m[2].split(' -> ').pop() : m[2];
+    out.push({ status: m[1].trim(), rel: rel.replace(/^"|"$/g, '') });
+  }
+  return out;
+};
+
+export const create_runner = function ({ runtime, mirror, engines, verify, tracker_factory, run_process, git_exec, conf = () => global._conf.xudex || {}, now = () => Date.now() }) {
+  for (const [name, dep] of Object.entries({ runtime, mirror, engines, verify, tracker_factory, run_process, git_exec })) {
+    if (!dep) throw new Error(`create_runner needs ${name}`);
+  }
+
+  const projects_root = () => conf().projects_root || '/srv/xudex';
+  const sample_interval_ms = () => Number(conf().tracker?.sample_interval_ms) || 15000;
+
+  // One engine turn. Everything about spawning a CLI lives here, so the run below reads as a
+  // sequence of decisions rather than a pile of process handling.
+  const one_turn = async function ({ workspace, launch, prompt, emit }) {
+    const state = engines.create_run_state();
+    const feed = engines.create_stream(launch.engine, (event) => {
+      state.accept(event);
+      if (emit) emit(event);
+    });
+
+    const ret = await workspace.exec([launch.command, ...launch.args, prompt], {
+      env: launch.env,
+      timeout_ms: Number(conf().run_timeout_ms) || 30 * 60 * 1000,
+      onStdout: feed,
+    });
+
+    // A CLI that dies without emitting a usable error still has to produce one, or the customer
+    // sees a run that simply stopped. stderr is the only thing left to say why.
+    if (ret.exit_code !== 0 && !state.state.error) {
+      state.state.error = ret.timed_out ? 'The engine ran out of time and was stopped.' : (ret.stderr || '').trim().split('\n').slice(-3).join('\n') || `the engine exited with code ${ret.exit_code}`;
+    }
+    return { ...state.state, exit_code: ret.exit_code, timed_out: ret.timed_out === true };
+  };
+
+  return {
+    run_branch,
+    parse_status,
+
+    async run({ uid, repo, project_id, conversation_id, prompt, launch, workspace_dir, emit = null, verify_ctx = {}, max_repair_attempts } = {}) {
+      const fail = (message, extra = {}) => ({ code: -1, data: message, ...extra });
+      if (!prompt) return fail('There is nothing to do: the request was empty.');
+      if (!launch || launch.error) return fail(launch?.error || 'That engine is not available.', { needs_key: launch?.needs_key || null });
+
+      const branch = run_branch(conversation_id);
+
+      // ── 1. The repository, through the mirror ────────────────────────────────────────
+      // The mirror is the only thing that ever authenticates upstream. Everything after this
+      // point runs with no credential at all, which is what makes it safe to run on a machine
+      // executing code an AI just wrote.
+      if (emit) emit({ type: 'phase', text: 'Preparing the repository' });
+      const mirrored = await mirror.ensure({ uid, repo });
+      if (mirrored.error) return fail(mirrored.error);
+
+      const dir = workspace_dir || path.join(projects_root(), String(project_id));
+      const prepared = await mirror.sync_workspace({ mirror_dir: mirrored.dir, dest: dir, branch, default_branch: repo.default_branch });
+      if (prepared.error) return fail(prepared.error);
+
+      // ── 2. A workspace to run in ─────────────────────────────────────────────────────
+      let workspace;
+      try {
+        workspace = await runtime.acquire({ project_id, dir: prepared.dir });
+      } catch (err) {
+        return fail('Xuda could not prepare a machine for this project. Please try again.');
+      }
+
+      try {
+        // What was already dirty before we started. Without this the run gets credited with a
+        // change somebody made by hand, and revert would then throw away their work.
+        const before = await workspace.exec(['git', 'status', '--porcelain', '--untracked-files=all'], { timeout_ms: 60000 });
+        const pre_dirty = new Set(parse_status(before.stdout).map((f) => f.rel));
+
+        // ── 3. The engine ──────────────────────────────────────────────────────────────
+        const tracker = tracker_factory({ workspace });
+        await tracker.start();
+        const sampler = setInterval(() => {
+          tracker.sample().catch(() => {});
+        }, sample_interval_ms());
+
+        let turn;
+        try {
+          if (emit) emit({ type: 'phase', text: `Running ${launch.label}` });
+          turn = await one_turn({ workspace, launch, prompt, emit });
+        } finally {
+          clearInterval(sampler);
+        }
+
+        // A provider error is the customer's provider talking, not us, and it is shown verbatim
+        // (plan 5.2). With BYOK we cannot see their balance or their rate limits, so dressing a
+        // 429 up as "something went wrong" would send them looking in the wrong place.
+        if (turn.error && !turn.messages.length) {
+          const record = tracker.finish({ usage: turn.usage, engine: launch.engine, meta: { uid, project_id, conversation_id, branch } });
+          return { code: -1, data: turn.error, engine_error: true, record };
+        }
+
+        // ── 4. What actually changed, according to git ──────────────────────────────────
+        const after = await workspace.exec(['git', 'status', '--porcelain', '--untracked-files=all'], { timeout_ms: 60000 });
+        const files = parse_status(after.stdout).filter((f) => !pre_dirty.has(f.rel));
+
+        // ── 5. Verification, and repair ─────────────────────────────────────────────────
+        // The repair callback is what closes the loop: a failing gate goes back to the SAME
+        // engine thread, so the fix arrives with the context of the change that broke it.
+        let repair_turns = 0;
+        const repair = async (repair_text) => {
+          repair_turns++;
+          if (emit) emit({ type: 'phase', text: `Fixing what the checks caught (attempt ${repair_turns})` });
+          const resumed = engines.prepare_launch({
+            engine: launch.engine,
+            model: launch.model,
+            // Resuming matters more here than anywhere else: a cold engine would try to fix a
+            // failure it has never seen, in code it did not write.
+            resume_session_id: turn.session_id,
+            api_key: launch.env?.ANTHROPIC_API_KEY || launch.env?.OPENAI_API_KEY,
+            sandbox: launch.sandbox,
+          });
+          if (resumed.error) return false;
+          const again = await one_turn({ workspace, launch: { ...resumed, label: launch.label }, prompt: repair_text, emit });
+          return !again.error;
+        };
+
+        if (emit) emit({ type: 'phase', text: 'Checking the change against your build and tests' });
+        const verified = await verify.verify_with_repair({
+          workspace,
+          // Repair whenever the tree is red, not only when the run has files to its name. Those
+          // are different questions: a run that edits a file somebody had ALREADY left dirty
+          // breaks the build while owning nothing in the change list, and gating repair on
+          // attribution would hand that back broken with no attempt to fix it. Attribution
+          // decides what we SHOW; the tree being red decides what we DO.
+          repair,
+          max_attempts: max_repair_attempts,
+          on_step: (step) => emit && emit({ type: 'phase', text: `${step.name}: ${step.ran ? (step.ok ? 'passed' : 'failed') : 'not configured'}` }),
+          ...verify_ctx,
+        });
+
+        // Files are re-read after repair, because a repair changes more of them.
+        const final_status = repair_turns ? await workspace.exec(['git', 'status', '--porcelain', '--untracked-files=all'], { timeout_ms: 60000 }) : after;
+        const final_files = parse_status(final_status.stdout).filter((f) => !pre_dirty.has(f.rel));
+
+        // ── 6. Close the books ──────────────────────────────────────────────────────────
+        const record = tracker.finish({
+          usage: turn.usage,
+          engine: launch.engine,
+          meta: { uid, project_id, conversation_id, branch, files: final_files.length, verified: verified.ok, repair_turns },
+        });
+
+        return {
+          code: 1,
+          data: {
+            // The answer is the engine's own words, and the verdict is ours. They are kept
+            // separate on purpose: an engine that says "done" over a red build must not be able
+            // to borrow our credibility for it.
+            message: turn.messages.join('\n\n').trim(),
+            verdict: verified.verdict,
+            ok: verified.ok,
+            files: final_files,
+            branch,
+            base_sha: prepared.base_sha,
+            session_id: turn.session_id,
+            steps: verified.steps,
+            failed: verified.failed || null,
+            repair_turns,
+            // A red tree with nothing attributable to this run almost always means the project
+            // was already failing when the customer got here. Worth saying: being told "your
+            // change broke the build" about a change you did not make is how a customer decides
+            // the verification cannot be trusted.
+            pre_existing_failure: !verified.ok && final_files.length === 0,
+          },
+          record,
+        };
+      } finally {
+        // Releasing without destroy: on a persistent machine the working copy IS the warmth the
+        // customer is paying for, and on an ephemeral one the substrate throws the whole thing
+        // away regardless.
+        try {
+          await workspace.release();
+        } catch (e) {}
+      }
+    },
+  };
+};