@xuda.io/ai_module 1.1.5658 → 1.1.5660

package/{xudex_runtime.mjs → xucode_runtime.mjs}

@@ -1,6 +1,6 @@
-// Xudex runtime: the seam between what runs and where it runs.
+// Xucode runtime: the seam between what runs and where it runs.
 //
-// See docs/plans/xudex.md section 3.8. Every layer above this one (the engine, the
+// See docs/plans/xucode.md section 3.8. Every layer above this one (the engine, the
 // verify loop, preview, git, the run tracker) talks to a WORKSPACE and must never
 // know whether that workspace is a persistent VM, an ephemeral runner, a container
 // or a microVM. Section 3.2 says the Proxmox VM is a v1 choice made because we
@@ -44,14 +44,14 @@ if (!global._conf) {
   global._conf = (await import(path.join(process.env.XUDA_HOME, 'common', 'load_conf.mjs'))).loadConf();
 }
 
-const xudex_conf = () => global._conf.xudex || {};
+const xucode_conf = () => global._conf.xucode || {};
 
 // Wall clock for a single command. This is abuse layer 3 in the plan (9.3) as much
 // as it is a timeout: an ephemeral workspace that dies on schedule takes a miner
 // with it, so no caller is allowed to run without a deadline.
 const DEFAULT_TIMEOUT_MS = 30 * 60 * 1000;
 
-const run_timeout_ms = () => Number(xudex_conf().run_timeout_ms) || DEFAULT_TIMEOUT_MS;
+const run_timeout_ms = () => Number(xucode_conf().run_timeout_ms) || DEFAULT_TIMEOUT_MS;
 
 // ── Path safety ────────────────────────────────────────────────────────────────
 // Every relative path from above this layer is attacker-influenced: the agent
@@ -74,7 +74,7 @@ const safe_join = function (root, rel) {
 // interface so the seam has a real implementation from day one rather than a
 // comment, and so the existing Code tab has somewhere to land.
 //
-// It is NOT a xudex customer substrate and must never become one. Section 3.1 is
+// It is NOT a xucode customer substrate and must never become one. Section 3.1 is
 // the reason: the verify loop installs arbitrary packages and runs arbitrary test
 // suites, and this substrate's filesystem belongs to a box that also runs CouchDB
 // and our cpi services. Hence the config gate below, off unless a box opts in.
@@ -83,7 +83,7 @@ const local_substrate = function ({ run_process }) {
     kind: 'local',
 
     available() {
-      return xudex_conf().allow_local_substrate === true;
+      return xucode_conf().allow_local_substrate === true;
     },
 
     async acquire({ project_id, dir, timeout_ms }) {
@@ -107,6 +107,10 @@ const local_substrate = function ({ run_process }) {
             killSignal: 'SIGKILL',
             onStdout: opts.onStdout,
             onStderr: opts.onStderr,
+            // The abuse kill switch, same contract as the VM substrate: return a reason and
+            // whatever is running stops. Both substrates have to honour it or the tracker can
+            // only enforce on one kind of machine.
+            abort_check: opts.should_abort || undefined,
           });
           const ms = Date.now() - started;
           return {
@@ -117,6 +121,8 @@ const local_substrate = function ({ run_process }) {
             // flag, so the deadline is re-derived here instead of being guessed by
             // every caller.
             timed_out: ms >= (Number(opts.timeout_ms) || deadline),
+            aborted: ret.aborted === true,
+            abort_reason: ret.abort_reason || null,
             ms,
           };
         },
@@ -191,7 +197,7 @@ export const create_runtime = function ({ run_process }) {
         if (s && s.available()) return await s.acquire(req);
       }
       throw new Error(
-        `no xudex runtime is available (asked for ${req.preferred_kind || 'any'}, have ${[...substrates.keys()].join(', ') || 'none'})`,
+        `no xucode runtime is available (asked for ${req.preferred_kind || 'any'}, have ${[...substrates.keys()].join(', ') || 'none'})`,
       );
     },
   };

package/{xudex_tracker.mjs → xucode_tracker.mjs}

@@ -1,6 +1,6 @@
-// Xudex run tracker: what a run cost, and whether it was a build at all.
+// Xucode run tracker: what a run cost, and whether it was a build at all.
 //
-// docs/plans/xudex.md 9.4. One component, three jobs, which is why it is built properly
+// docs/plans/xucode.md 9.4. One component, three jobs, which is why it is built properly
 // rather than bolted on as monitoring:
 //
 //   1. ABUSE DETECTION. A machine that runs arbitrary customer code is the classic mining
@@ -30,14 +30,14 @@
 // CPU here is SYSTEM WIDE, from /proc/stat, so on a multi-core box a miner that uses only
 // some of the cores never reaches the threshold. Measured on dev 2026-08-14: a
 // single-threaded busy loop peaked at 85% and would not have tripped a 90% line. It is
-// much less of a gap than it first looks, because the xudex tiers are 1, 2 and 4 vCPU, so
+// much less of a gap than it first looks, because the xucode tiers are 1, 2 and 4 vCPU, so
 // there are not many cores to hide behind, and an attacker throttling to stay under the
 // line is an attacker earning proportionally less. It is a real gap all the same, so the
 // core count is recorded on every run: thresholds cannot be tuned per box size without it,
 // and tuning on real data is exactly what log-only mode is for.
 //
 // ── Log-only first, and this is not optional ───────────────────────────────────────────
-// `xudex.tracker.enforce` is false. The tracker records a verdict and logs it and does
+// `xucode.tracker.enforce` is false. The tracker records a verdict and logs it and does
 // nothing else, so thresholds are tuned against real builds before anything can act on
 // them. The first false positive under enforcement suspends a paying customer in the
 // middle of their work, and there is no good way to apologise for that.
@@ -48,7 +48,7 @@ if (!global._conf) {
   global._conf = (await import(path.join(process.env.XUDA_HOME, 'common', 'load_conf.mjs'))).loadConf();
 }
 
-const tracker_conf = () => global._conf.xudex?.tracker || {};
+const tracker_conf = () => global._conf.xucode?.tracker || {};
 
 // One shell command per sample, because sampling a workspace costs an exec and a run is
 // sampled repeatedly. Every line is prefixed so the parser never has to guess what it is
@@ -62,7 +62,7 @@ export const SAMPLE_COMMAND = [
   `ps -eo comm= 2>/dev/null | sort -u | tr '\\n' ',' | sed 's/^/proc /'`,
 ].join('; ');
 
-// Process names that mean real work is happening. Xudex v1 is Node and TypeScript only
+// Process names that mean real work is happening. Xucode v1 is Node and TypeScript only
 // (plan section 10), so this list is deliberately small: a wider list is a wider hole,
 // because every name on it is a name a miner can adopt.
 export const BUILD_PROCESSES = [
@@ -167,7 +167,7 @@ export const evaluate_run = function (record, conf = tracker_conf()) {
   };
 };
 
-// A tracker for one run. `workspace` is the runtime interface's handle (xudex_runtime.mjs),
+// A tracker for one run. `workspace` is the runtime interface's handle (xucode_runtime.mjs),
 // so this works identically on a VM, an ephemeral runner or a container, which is the
 // whole reason that seam exists.
 export const create_run_tracker = function ({ workspace, conf = tracker_conf(), now = () => Date.now() }) {
@@ -194,7 +194,7 @@ export const create_run_tracker = function ({ workspace, conf = tracker_conf(),
         last_sample_ts = started_ts;
       } catch (e) {
         // Sampling is observation. It must never be the reason a customer's run fails.
-        console.warn(`[xudex] tracker start sample failed: ${e.message}`);
+        console.warn(`[xucode] tracker start sample failed: ${e.message}`);
       }
       return true;
     },
@@ -225,7 +225,7 @@ export const create_run_tracker = function ({ workspace, conf = tracker_conf(),
         last = cur;
         last_sample_ts = ts;
       } catch (e) {
-        console.warn(`[xudex] tracker sample failed: ${e.message}`);
+        console.warn(`[xucode] tracker sample failed: ${e.message}`);
       }
       return true;
     },
@@ -239,7 +239,7 @@ export const create_run_tracker = function ({ workspace, conf = tracker_conf(),
       const mean = cpu_values.length ? cpu_values.reduce((a, b) => a + b, 0) / cpu_values.length : 0;
 
       const record = {
-        docType: 'xudex_run',
+        docType: 'xucode_run',
         ...meta,
         engine,
         model,
@@ -272,5 +272,35 @@ export const create_run_tracker = function ({ workspace, conf = tracker_conf(),
       record.enforced = verdict.verdict === 'flag' && verdict.enforce === true;
       return record;
     },
+
+    // The same rules, asked DURING the run instead of after it (plan 9.3 layer 6).
+    //
+    // Judging only at the end is close to useless against the thing this exists to catch: a
+    // miner takes everything the run timeout allows, so a verdict delivered afterwards has
+    // already paid for thirty minutes of the cycles it was meant to deny. Asked every sample,
+    // the same evidence stops it in single digit minutes.
+    //
+    // The grace period is deliberately generous and separate from the CPU window. A cold
+    // `npm install` on a big dependency tree is minutes of real CPU before anything a sampler
+    // would recognise as a build process appears, and killing a customer's first honest run is
+    // a far worse outcome than a miner getting five extra minutes.
+    live_verdict() {
+      const out_bytes = first && last && last.net_tx != null && first.net_tx != null ? Math.max(0, last.net_tx - first.net_tx) : 0;
+      const partial = {
+        cpu: { sustained_high_seconds: Math.round(sustained_high_ms / 1000) },
+        net: { out_bytes },
+        build_seen,
+      };
+      const verdict = evaluate_run(partial, conf);
+      const elapsed_seconds = started_ts ? Math.round((now() - started_ts) / 1000) : 0;
+      const grace = Number(conf.min_seconds_before_kill ?? 300);
+      return {
+        ...verdict,
+        elapsed_seconds,
+        // Three separate conditions, and all three have to hold: it looks wrong, enforcement is
+        // switched on at all, and the run has been going long enough for that to mean something.
+        stop: verdict.verdict === 'flag' && verdict.enforce === true && elapsed_seconds >= grace,
+      };
+    },
   };
 };

package/{xudex_verify.mjs → xucode_verify.mjs}

@@ -1,8 +1,8 @@
 // The verify loop. This is the product.
 //
-// docs/plans/xudex.md section 6. Codex and Claude Code are terminals: they will happily
+// docs/plans/xucode.md section 6. Codex and Claude Code are terminals: they will happily
 // tell you they are done and leave your build broken, because they have no environment to
-// check against. Xudex has one, so after every run and BEFORE the customer is told anything
+// check against. Xucode has one, so after every run and BEFORE the customer is told anything
 // succeeded, the change is put through the project's own gates:
 //
 //   install (only if the manifest moved) -> typecheck -> test -> build -> the running app
@@ -33,7 +33,7 @@ if (!global._conf) {
   global._conf = (await import(path.join(process.env.XUDA_HOME, 'common', 'load_conf.mjs'))).loadConf();
 }
 
-const verify_conf = () => global._conf.xudex?.verify || {};
+const verify_conf = () => global._conf.xucode?.verify || {};
 
 const DEFAULTS = {
   max_repair_attempts: 2,
@@ -139,7 +139,7 @@ export const repair_prompt = function (result) {
   ].join('\n');
 };
 
-// Run the gates. `workspace` is the runtime interface's handle (xudex_runtime.mjs), so this
+// Run the gates. `workspace` is the runtime interface's handle (xucode_runtime.mjs), so this
 // is identical on a VM, an ephemeral runner or a container.
 //
 // `runtime_check` is the seam for the preview leg (build order step 11): once a preview
@@ -246,7 +246,7 @@ export const verify_with_repair = async function ({ workspace, repair, max_attem
     try {
       repaired = await repair(repair_prompt(result), { attempt: n, failed: result.failed });
     } catch (err) {
-      console.warn(`[xudex] repair attempt ${n} threw: ${err.message}`);
+      console.warn(`[xucode] repair attempt ${n} threw: ${err.message}`);
       break;
     }
     // A repair that declined to change anything will fail identically next time, so

package/{xudex_vm.mjs → xucode_vm.mjs}

@@ -1,11 +1,11 @@
-// The VM substrate: a xudex workspace on the account's own machine.
+// The VM substrate: a xucode workspace on the account's own machine.
 //
-// docs/plans/xudex.md 3.2 and 3.8. This is the second implementation of the runtime
+// docs/plans/xucode.md 3.2 and 3.8. This is the second implementation of the runtime
 // interface, and building it is what proves that seam was real rather than a comment: the
 // engine, the verify loop, the tracker and preview are not touched by anything in this file.
 //
 // ── It does NOT use SSH, and that is not a preference ──────────────────────────────────
-// A xudex machine is `app_type: 'vps'` (the flavor rides on `is_xudex`, see deploy_xudex),
+// A xucode machine is `app_type: 'vps'` (the flavor rides on `is_xucode`, see deploy_xucode),
 // and customer VPS on this platform are KEYLESS by design: since the 2026-07-15 consent
 // split no standing platform SSH key lives in those guests, and they correctly refuse one.
 // Reaching them over SSH would mean pushing the control-plane key back in, which regresses
@@ -35,7 +35,7 @@ if (!global._conf) {
 // attacker-influenced: the agent writes the file names and the customer writes the prompt.
 export const shq = (value) => `'${String(value).replace(/'/g, `'\\''`)}'`;
 
-const vm_conf = () => global._conf.xudex?.vm || {};
+const vm_conf = () => global._conf.xucode?.vm || {};
 
 export const create_vm_substrate = function ({ pve_request, resolve_machine, delay = (ms) => new Promise((r) => setTimeout(r, ms)), now = () => Date.now() }) {
   if (typeof pve_request !== 'function') throw new Error('create_vm_substrate needs pve_request');
@@ -46,7 +46,7 @@ export const create_vm_substrate = function ({ pve_request, resolve_machine, del
   // Dispatch a script in the guest and wait for it, with a deadline rather than a poll count.
   // `on_tail` is called with new bytes from the log file as they appear, which is the only way
   // to see progress on a channel that otherwise speaks once, at the end.
-  const guest_exec = async function ({ node_doc, vmid, script, timeout_ms, on_tail = null, log_file = null }) {
+  const guest_exec = async function ({ node_doc, vmid, script, timeout_ms, on_tail = null, log_file = null, should_abort = null }) {
     const body = [
       ['command', '/bin/bash'],
       ['command', '-c'],
@@ -56,14 +56,68 @@ export const create_vm_substrate = function ({ pve_request, resolve_machine, del
     const pid = disp && (disp.pid ?? disp.PID);
     if (pid == null) throw new Error('guest exec returned no pid (is qemu-guest-agent running?)');
 
+    // Killing the process GROUP, not the process. A build spawns children, and signalling only
+    // the shell we started leaves the thing actually burning the CPU running happily.
+    const kill_in_guest = async () => {
+      try {
+        await pve_request(node_doc, 'POST', `/nodes/${node_doc.node}/qemu/${vmid}/agent/exec`, [
+          ['command', '/bin/bash'],
+          ['command', '-c'],
+          ['command', `kill -TERM -${pid} 2>/dev/null; sleep 2; kill -KILL -${pid} 2>/dev/null; true`],
+        ]);
+      } catch (e) {
+        // Nothing useful is left to try, and the caller is already being told it failed.
+      }
+    };
+
     const deadline = now() + (Number(timeout_ms) || 30 * 60 * 1000);
     let offset = 0;
 
     while (now() < deadline) {
+      // Asked before the status read so a decision to stop is acted on at the first opportunity
+      // rather than one poll later. This is the abuse kill switch (plan 9.3 layer 6): whatever is
+      // running has been judged, and it stops now.
+      if (should_abort) {
+        let reason = null;
+        try {
+          reason = await should_abort();
+        } catch (e) {
+          // A broken judge must never kill a customer's run.
+          reason = null;
+        }
+        if (reason) {
+          await kill_in_guest();
+          return { stdout: '', stderr: String(reason), exit_code: 137, truncated: false, timed_out: false, aborted: true, abort_reason: String(reason) };
+        }
+      }
+
       const st = await pve_request(node_doc, 'GET', `/nodes/${node_doc.node}/qemu/${vmid}/agent/exec-status?pid=${pid}`);
       if (st && st.exited) {
+        const stdout = st['out-data'] != null ? String(st['out-data']) : '';
+
+        // FLUSH THE TAIL BEFORE RETURNING. Everything a command printed between the last poll
+        // and its exit is in `stdout` but has never been handed to `on_tail`, and a caller that
+        // is PARSING the stream (rather than just displaying it) loses those events entirely.
+        //
+        // This was not theoretical. An engine's last events are the ones that matter most: the
+        // closing message and the token usage both arrive in the final moments, so a real run
+        // showed the agent's opening sentence, never its conclusion, and recorded 0 tokens
+        // against a turn that actually cost 40,969. The run meter is what abuse detection and
+        // accounting read, so silently zeroing it is worse than losing the text.
+        //
+        // Sliced on the BYTE offset the tail reads used, so the two agree exactly and nothing is
+        // delivered twice.
+        if (on_tail && log_file) {
+          try {
+            const buf = Buffer.from(stdout, 'utf8');
+            if (buf.length > offset) on_tail(buf.subarray(offset).toString('utf8'));
+          } catch (e) {
+            // The command already succeeded. Failing it over a progress callback would be absurd.
+          }
+        }
+
         return {
-          stdout: st['out-data'] != null ? String(st['out-data']) : '',
+          stdout,
           stderr: st['err-data'] != null ? String(st['err-data']) : '',
           exit_code: st.exitcode ?? 0,
           truncated: !!(st['out-truncated'] || st['err-truncated']),
@@ -100,13 +154,7 @@ export const create_vm_substrate = function ({ pve_request, resolve_machine, del
 
     // Out of time. Kill the process group in the guest rather than leaving a build running on
     // a machine the customer is paying for, then say so.
-    try {
-      await pve_request(node_doc, 'POST', `/nodes/${node_doc.node}/qemu/${vmid}/agent/exec`, [
-        ['command', '/bin/bash'],
-        ['command', '-c'],
-        ['command', `kill -TERM -${pid} 2>/dev/null; kill -KILL -${pid} 2>/dev/null; true`],
-      ]);
-    } catch (e) {}
+    await kill_in_guest();
     return { stdout: '', stderr: `the command did not finish within ${Math.round((Number(timeout_ms) || 0) / 1000)}s and was stopped`, exit_code: 124, truncated: false, timed_out: true };
   };
 
@@ -117,14 +165,14 @@ export const create_vm_substrate = function ({ pve_request, resolve_machine, del
     // Available when this box can reach Proxmox at all. Whether a PARTICULAR account has a
     // machine is answered by acquire, because that is a per-request question.
     available() {
-      return global._conf.xudex?.enabled === true && !!global._conf.proxmox && global._conf.proxmox.fs_agent !== false;
+      return global._conf.xucode?.enabled === true && !!global._conf.proxmox && global._conf.proxmox.fs_agent !== false;
     },
 
     async acquire({ uid, project_id, app_id }) {
       const machine = await resolve_machine({ uid, app_id: app_id || project_id });
-      if (!machine || machine.error) throw new Error(machine?.error || 'this account has no xudex machine');
+      if (!machine || machine.error) throw new Error(machine?.error || 'this account has no xucode machine');
       const { node_doc, vmid } = machine;
-      const root = global._conf.xudex?.projects_root || '/srv/xudex';
+      const root = global._conf.xucode?.projects_root || '/srv/xucode';
       const dir = path.posix.join(root, String(project_id));
 
       await guest_exec({ node_doc, vmid, script: `mkdir -p ${shq(dir)}`, timeout_ms: 60000 });
@@ -153,13 +201,13 @@ export const create_vm_substrate = function ({ pve_request, resolve_machine, del
 
           // A caller that wants progress gets a log file and an incremental tail; one that does
           // not gets the plain form, which is cheaper by one exec per poll.
-          const log_file = opts.onStdout ? `/tmp/xudex-exec-${vmid}-${started}.log` : null;
+          const log_file = opts.onStdout ? `/tmp/xucode-exec-${vmid}-${started}.log` : null;
           const script = log_file
             ? `cd ${shq(cwd)}; ${env} { ${command}; } > ${shq(log_file)} 2>&1; rc=$?; cat ${shq(log_file)}; rm -f ${shq(log_file)}; exit $rc`
             : `cd ${shq(cwd)}; ${env} ${command}`;
 
-          const ret = await guest_exec({ node_doc, vmid, script, timeout_ms: opts.timeout_ms, on_tail: opts.onStdout || null, log_file });
-          return { exit_code: ret.exit_code, stdout: ret.stdout || '', stderr: ret.stderr || '', timed_out: ret.timed_out === true, ms: now() - started, truncated: ret.truncated };
+          const ret = await guest_exec({ node_doc, vmid, script, timeout_ms: opts.timeout_ms, on_tail: opts.onStdout || null, log_file, should_abort: opts.should_abort || null });
+          return { exit_code: ret.exit_code, stdout: ret.stdout || '', stderr: ret.stderr || '', timed_out: ret.timed_out === true, aborted: ret.aborted === true, abort_reason: ret.abort_reason || null, ms: now() - started, truncated: ret.truncated };
         },
 
         // Base64 across the channel in both directions. Proxmox hands back out-data already
@@ -197,11 +245,11 @@ export const create_vm_substrate = function ({ pve_request, resolve_machine, del
             .filter(Boolean);
         },
 
-        // The preview URL. A xudex machine publishes nothing but previews (plan 3.7), so this is
+        // The preview URL. A xucode machine publishes nothing but previews (plan 3.7), so this is
         // the one port that is ever reachable, and it goes through the platform's existing web
         // route for the app rather than a second proxy invented here.
         async expose_port(port) {
-          const base = global._conf.xudex?.preview_domain;
+          const base = global._conf.xucode?.preview_domain;
           if (!base) return null;
           return { url: `https://${String(project_id).replace(/[^a-zA-Z0-9]/g, '')}.${base}`, port };
         },