agentic-numerical-control 0.1.5 → 0.1.8

package/dist/server/analysis.js

@@ -0,0 +1,356 @@
+// Reads a G-code program the way a careful machinist would before running it:
+// how big it is, how long it takes, which tools it uses and where they change,
+// whether it fits the machine from the current zero, and anything the
+// controller won't do or that looks risky. Everything here is an estimate from
+// the program text and the controller's own settings; nothing touches the machine.
+const AXES = ["x", "y", "z"];
+const ASSUMED_RAPID = 1000; // mm/min, a cautious hobby-machine figure
+const LINE_SAMPLES = 5;
+const round = (n, d = 2) => Math.round(n * 10 ** d) / 10 ** d;
+function parseWords(code) {
+    const g = [];
+    const m = [];
+    const v = {};
+    for (const [, letter, num] of code.matchAll(/([A-Z])\s*([-+]?(?:\d+\.?\d*|\.\d+))/g)) {
+        const n = Number(num);
+        if (letter === "G")
+            g.push(n);
+        else if (letter === "M")
+            m.push(n);
+        else
+            v[letter] = n;
+    }
+    return { g, m, v };
+}
+/** Grbl and grblHAL both report as "Grbl" in CNCjs; grblHAL says so in its version line. */
+function controllerKind(machine) {
+    if (!machine?.controller)
+        return "unknown";
+    if (!/grbl/i.test(machine.controller))
+        return "other";
+    return /hal/i.test(machine.version ?? "") ? "grblhal" : "grbl";
+}
+export function analyzeGcode(gcode, machine) {
+    const settings = machine?.settings ?? null;
+    const setting = (n) => {
+        const raw = settings?.[`$${n}`];
+        const val = raw === undefined ? NaN : Number(raw);
+        return Number.isFinite(val) ? val : null;
+    };
+    const rapid = { x: setting(110), y: setting(111), z: setting(112) };
+    const rapidKnown = rapid.x !== null && rapid.y !== null && rapid.z !== null;
+    const found = new Map();
+    const flag = (code, severity, message, line) => {
+        const c = found.get(code) ?? { severity, message, lines: [] };
+        if (c.lines.length < LINE_SAMPLES && c.lines[c.lines.length - 1] !== line)
+            c.lines.push(line);
+        found.set(code, c);
+    };
+    let scale = 1; // inch programs are converted to mm
+    let units = "mm";
+    let absolute = true;
+    let plane = 17;
+    let motion = 0;
+    let feed = null;
+    let spindleOn = false;
+    let pos = { x: 0, y: 0, z: 0 };
+    let moved = false;
+    let pendingTool = null;
+    let pendingLabel = null;
+    let tool = null;
+    let lastComment = null;
+    const min = { x: Infinity, y: Infinity, z: Infinity };
+    const max = { x: -Infinity, y: -Infinity, z: -Infinity };
+    const feeds = new Set();
+    const speeds = new Set();
+    const tools = [];
+    let toolChanges = 0;
+    let cutLength = 0;
+    let rapidLength = 0;
+    let cuttingSeconds = 0;
+    let rapidSeconds = 0;
+    const runs = [];
+    const steps = [];
+    let step = null;
+    const openStep = (line) => {
+        step = { tool, label: pendingLabel, firstLine: line, lastLine: line, seconds: 0, cutLength: 0, minZ: null, feedRange: null };
+        steps.push(step);
+    };
+    const include = (p) => {
+        for (const a of AXES) {
+            if (p[a] < min[a])
+                min[a] = p[a];
+            if (p[a] > max[a])
+                max[a] = p[a];
+        }
+    };
+    const lines = gcode.split(/\r?\n/);
+    for (let i = 0; i < lines.length; i++) {
+        const lineNo = i + 1;
+        const raw = lines[i];
+        const comments = [...raw.matchAll(/\(([^)]*)\)|;(.*)$/g)].map((c) => (c[1] ?? c[2] ?? "").trim()).filter(Boolean);
+        if (comments.length)
+            lastComment = comments.join(" ");
+        const code = raw.replace(/\([^)]*\)/g, " ").replace(/;.*$/, "").toUpperCase().replace(/^\s*N\d+/, "");
+        if (!code.trim() || code.trim().startsWith("%"))
+            continue;
+        const { g, m, v } = parseWords(code);
+        for (const n of g) {
+            if (n === 20) {
+                scale = 25.4;
+                units = "inch";
+            }
+            else if (n === 21) {
+                scale = 1;
+                units = "mm";
+            }
+            else if (n === 90)
+                absolute = true;
+            else if (n === 91)
+                absolute = false;
+            else if (n === 17 || n === 18 || n === 19)
+                plane = n;
+            else if (n >= 0 && n <= 3 && Number.isInteger(n))
+                motion = n;
+            else if (n >= 81 && n <= 89) {
+                const kind = controllerKind(machine);
+                if (kind === "grbl")
+                    flag("canned-cycle", "problem", "Uses drilling cycles (G81–G89), which Grbl doesn't support. Post the program with cycles expanded to plain moves.", lineNo);
+                else if (kind !== "grblhal")
+                    flag("canned-cycle", "check", "Uses drilling cycles (G81–G89). Plain Grbl doesn't support them; grblHAL does.", lineNo);
+            }
+            else if (n === 41 || n === 42) {
+                flag("cutter-comp", "problem", "Uses cutter radius compensation (G41/G42), which Grbl doesn't support. Post the program with compensation in the computer.", lineNo);
+            }
+            else if (n === 28 || n === 30) {
+                flag("stored-position", "check", "Moves to a stored position (G28/G30). Check where it is set before running.", lineNo);
+            }
+            else if (n === 53) {
+                flag("machine-coords", "check", "Has moves in machine coordinates (G53), which ignore your zero.", lineNo);
+            }
+            else if (n >= 38 && n < 39) {
+                flag("probe", "check", "Probes (G38). Make sure the probe is connected.", lineNo);
+            }
+        }
+        if (v.F !== undefined)
+            feed = v.F * scale;
+        if (v.S !== undefined && v.S > 0)
+            speeds.add(v.S);
+        if (v.T !== undefined) {
+            pendingTool = v.T;
+            // CAM comments usually repeat the tool number ("T1 6 mm flat end mill").
+            pendingLabel = lastComment?.replace(/^T\d+\s*[:·-]?\s*/i, "") || null;
+        }
+        for (const n of m) {
+            if (n === 3 || n === 4)
+                spindleOn = true;
+            else if (n === 5)
+                spindleOn = false;
+            else if (n === 6) {
+                const next = pendingTool;
+                if (next !== null && next !== tool) {
+                    if (tool !== null || steps.length)
+                        toolChanges++;
+                    tool = next;
+                    if (!tools.includes(next))
+                        tools.push(next);
+                    step = null; // the next move opens a step for the new tool
+                }
+            }
+        }
+        // A T word with no M6 still names the tool, for programs that rely on the sender.
+        if (pendingTool !== null && tool === null && !m.includes(6)) {
+            tool = pendingTool;
+            if (!tools.includes(tool))
+                tools.push(tool);
+        }
+        // G28/G30/G53 moves don't land at the program's own coordinates; skip them.
+        if (g.some((n) => n === 28 || n === 30 || n === 53 || n === 92 || n === 10))
+            continue;
+        const hasAxis = v.X !== undefined || v.Y !== undefined || v.Z !== undefined;
+        if (!hasAxis)
+            continue;
+        const target = { ...pos };
+        for (const a of AXES) {
+            const val = v[a.toUpperCase()];
+            if (val === undefined)
+                continue;
+            target[a] = absolute ? val * scale : pos[a] + val * scale;
+        }
+        if (!step)
+            openStep(lineNo);
+        const s = step;
+        const runFeed = motion === 0 ? null : feed;
+        const lastRun = runs[runs.length - 1];
+        if (!lastRun || lastRun.feed !== runFeed || lastRun.tool !== tool)
+            runs.push({ line: lineNo, feed: runFeed, tool });
+        s.lastLine = lineNo;
+        const dx = target.x - pos.x;
+        const dy = target.y - pos.y;
+        const dz = target.z - pos.z;
+        if (motion === 0) {
+            const len = Math.hypot(dx, dy, dz);
+            rapidLength += len;
+            const t = rapidKnown
+                ? Math.max(Math.abs(dx) / rapid.x, Math.abs(dy) / rapid.y, Math.abs(dz) / rapid.z) * 60
+                : (len / ASSUMED_RAPID) * 60;
+            rapidSeconds += t;
+            s.seconds += t;
+            if (moved && target.z < 0 && (dx !== 0 || dy !== 0 || dz < 0)) {
+                flag("rapid-in-stock", "check", "Has rapid moves below Z 0, which may plunge or travel through the stock at full speed.", lineNo);
+            }
+        }
+        else {
+            let len = Math.hypot(dx, dy, dz);
+            if ((motion === 2 || motion === 3) && plane === 17) {
+                const cx = v.I !== undefined ? pos.x + v.I * scale : null;
+                const cy = v.J !== undefined ? pos.y + v.J * scale : null;
+                if (cx !== null || cy !== null || v.R !== undefined) {
+                    const ccx = cx ?? pos.x;
+                    const ccy = cy ?? pos.y;
+                    const r = v.R !== undefined ? Math.abs(v.R * scale) : Math.hypot(pos.x - ccx, pos.y - ccy);
+                    let sweep;
+                    if (v.R !== undefined) {
+                        const chord = Math.min(Math.hypot(dx, dy), 2 * r);
+                        sweep = 2 * Math.asin(chord / (2 * r || 1));
+                        if (v.R < 0)
+                            sweep = 2 * Math.PI - sweep;
+                    }
+                    else {
+                        const a0 = Math.atan2(pos.y - ccy, pos.x - ccx);
+                        const a1 = Math.atan2(target.y - ccy, target.x - ccx);
+                        sweep = motion === 2 ? a0 - a1 : a1 - a0;
+                        while (sweep <= 1e-9)
+                            sweep += 2 * Math.PI;
+                        // Arc bounds: include the circle's extreme points the sweep passes.
+                        for (let k = 0; k < 4; k++) {
+                            const ang = (k * Math.PI) / 2;
+                            const rel = motion === 2 ? a0 - ang : ang - a0;
+                            let d = rel % (2 * Math.PI);
+                            if (d < 0)
+                                d += 2 * Math.PI;
+                            if (d < sweep)
+                                include({ x: ccx + r * Math.cos(ang), y: ccy + r * Math.sin(ang), z: target.z });
+                        }
+                    }
+                    len = Math.hypot(r * sweep, dz);
+                }
+            }
+            cutLength += len;
+            s.cutLength += len;
+            if (feed === null || feed <= 0) {
+                flag("no-feed", "problem", "Has a cutting move before any feed rate (F) is set. Grbl refuses it.", lineNo);
+            }
+            else {
+                feeds.add(round(feed, 1));
+                const t = (len / feed) * 60;
+                cuttingSeconds += t;
+                s.seconds += t;
+                const f = feed;
+                s.feedRange = s.feedRange ? [Math.min(s.feedRange[0], f), Math.max(s.feedRange[1], f)] : [f, f];
+            }
+            if (!spindleOn && Math.min(pos.z, target.z) < 0) {
+                flag("spindle-off", "problem", "Cuts below Z 0 with the spindle off (no M3 before it).", lineNo);
+            }
+        }
+        include(pos);
+        include(target);
+        const lowZ = Math.min(pos.z, target.z);
+        s.minZ = s.minZ === null ? lowZ : Math.min(s.minZ, lowZ);
+        pos = target;
+        moved = true;
+    }
+    if (toolChanges > 0) {
+        found.set("tool-changes", {
+            severity: "check",
+            message: `Changes tool ${toolChanges} time${toolChanges === 1 ? "" : "s"}. Grbl doesn't stop for M6 by itself; CNCjs's tool change setting has to pause the job so you can swap the tool and set its length.`,
+            lines: steps.slice(1).map((s) => s.firstLine).slice(0, LINE_SAMPLES),
+        });
+    }
+    const bounds = Number.isFinite(min.x) ? { min: roundVec(min), max: roundVec(max) } : null;
+    const fit = fitCheck(bounds, machine, setting);
+    if (fit.status === "over") {
+        for (const a of fit.axes) {
+            found.set(`travel-${a.axis}`, {
+                severity: "problem",
+                message: `Goes ${round(a.over, 1)} mm past the ${a.axis.toUpperCase()} travel. From the current zero it runs past the machine's ${a.direction} ${a.axis.toUpperCase()} end; move the zero or the stock.`,
+                lines: [],
+            });
+        }
+    }
+    const checks = [...found.entries()]
+        .map(([code, c]) => ({ code, ...c }))
+        .sort((a, b) => (a.severity === b.severity ? 0 : a.severity === "problem" ? -1 : 1));
+    const feedList = [...feeds].sort((a, b) => a - b);
+    return {
+        units,
+        bounds,
+        size: bounds ? roundVec({ x: bounds.max.x - bounds.min.x, y: bounds.max.y - bounds.min.y, z: bounds.max.z - bounds.min.z }) : null,
+        deepestZ: bounds ? bounds.min.z : null,
+        time: {
+            totalSeconds: Math.round(cuttingSeconds + rapidSeconds),
+            cuttingSeconds: Math.round(cuttingSeconds),
+            rapidSeconds: Math.round(rapidSeconds),
+            rapidRate: rapidKnown ? "machine" : "assumed",
+        },
+        cutLength: round(cutLength, 1),
+        rapidLength: round(rapidLength, 1),
+        feedRange: feedList.length ? [feedList[0], feedList[feedList.length - 1]] : null,
+        spindleSpeeds: [...speeds].sort((a, b) => a - b),
+        tools,
+        toolChanges,
+        steps: steps.map((s) => ({
+            ...s,
+            seconds: Math.round(s.seconds),
+            cutLength: round(s.cutLength, 1),
+            minZ: s.minZ === null ? null : round(s.minZ, 3),
+            feedRange: s.feedRange ? [round(s.feedRange[0], 1), round(s.feedRange[1], 1)] : null,
+        })),
+        fit,
+        checks,
+        runs,
+    };
+}
+function roundVec(p) {
+    return { x: round(p.x, 3), y: round(p.y, 3), z: round(p.z, 3) };
+}
+/**
+ * Whether the program stays inside the machine's travel from the current
+ * work zero. Grbl's machine coordinates run from 0 at the homed corner into
+ * minus by $130-$132, unless $23 flips an axis to home towards minus. Without
+ * homing ($22 off) machine coordinates mean nothing, so the fit is unknown.
+ */
+function fitCheck(bounds, machine, setting) {
+    const unknown = (reason) => ({ status: "unknown", axes: [], reason });
+    if (!bounds)
+        return unknown("The program has no moves.");
+    if (!machine?.controller)
+        return unknown("No machine is connected.");
+    if (!/grbl/i.test(machine.controller))
+        return unknown("Only Grbl machines report their travel.");
+    if (!machine.mpos || !machine.wpos)
+        return unknown("The machine hasn't reported its position yet.");
+    const travel = { x: setting(130), y: setting(131), z: setting(132) };
+    if (travel.x === null || travel.y === null || travel.z === null)
+        return unknown("The machine hasn't reported its travel settings ($130–$132).");
+    if (!((setting(22) ?? 0) & 1))
+        return unknown("Homing is off ($22), so the machine doesn't know where its travel ends.");
+    const dirMask = setting(23) ?? 0;
+    const axes = [];
+    AXES.forEach((a, bit) => {
+        const offset = machine.mpos[a] - machine.wpos[a];
+        const towardsMinus = (dirMask >> bit) & 1;
+        const lo = towardsMinus ? 0 : -travel[a];
+        const hi = towardsMinus ? travel[a] : 0;
+        const from = bounds.min[a] + offset;
+        const to = bounds.max[a] + offset;
+        const tolerance = 0.01;
+        if (from < lo - tolerance)
+            axes.push({ axis: a, over: lo - from, direction: "minus" });
+        if (to > hi + tolerance)
+            axes.push({ axis: a, over: to - hi, direction: "plus" });
+    });
+    return axes.length
+        ? { status: "over", axes, reason: "From the current zero, the program leaves the machine's travel." }
+        : { status: "fits", axes, reason: "From the current zero, the program stays inside the machine's travel." };
+}

package/dist/server/autostart.js

@@ -40,14 +40,14 @@ export function enableAutostart(cliPath) {
     if (process.platform === "darwin") {
         const plist = path.join(os.homedir(), "Library", "LaunchAgents", `${LABEL}.plist`);
         fs.mkdirSync(path.dirname(plist), { recursive: true });
-        fs.writeFileSync(plist, `<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0"><dict>
-  <key>Label</key><string>${LABEL}</string>
-  <key>ProgramArguments</key><array>${cmd.map((c) => `<string>${c}</string>`).join("")}</array>
-  <key>RunAtLoad</key><true/>
-  <key>KeepAlive</key><true/>
-</dict></plist>
+        fs.writeFileSync(plist, `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0"><dict>
+  <key>Label</key><string>${LABEL}</string>
+  <key>ProgramArguments</key><array>${cmd.map((c) => `<string>${c}</string>`).join("")}</array>
+  <key>RunAtLoad</key><true/>
+  <key>KeepAlive</key><true/>
+</dict></plist>
 `);
         quiet("launchctl", ["unload", plist]);
         execFileSync("launchctl", ["load", "-w", plist], { stdio: "ignore" });
@@ -55,16 +55,16 @@ export function enableAutostart(cliPath) {
     }
     const unit = path.join(os.homedir(), ".config", "systemd", "user", `${PRODUCT.name}.service`);
     fs.mkdirSync(path.dirname(unit), { recursive: true });
-    fs.writeFileSync(unit, `[Unit]
-Description=${PRODUCT.displayName} agent
-
-[Service]
-ExecStart=${cmd.map((c) => `"${c}"`).join(" ")}
-Restart=always
-RestartSec=5
-
-[Install]
-WantedBy=default.target
+    fs.writeFileSync(unit, `[Unit]
+Description=${PRODUCT.displayName} agent
+
+[Service]
+ExecStart=${cmd.map((c) => `"${c}"`).join(" ")}
+Restart=always
+RestartSec=5
+
+[Install]
+WantedBy=default.target
 `);
     execFileSync("systemctl", ["--user", "daemon-reload"], { stdio: "ignore" });
     execFileSync("systemctl", ["--user", "enable", "--now", `${PRODUCT.name}.service`], { stdio: "ignore" });

package/dist/server/cncjs.js

@@ -13,6 +13,7 @@ const require = createRequire(import.meta.url);
 export const CNCJS_URL = process.env.CNCJS_URL ?? "http://127.0.0.1:8000";
 import { STATE_DIR } from "./paths.js";
 import { ROOT } from "./product.js";
+import { programHash } from "./program.js";
 const MANAGED_CONFIG = path.join(STATE_DIR, "cncrc");
 const USER_CONFIG = process.env.CNCJS_CONFIG ?? path.join(os.homedir(), ".cncrc");
 /** Telemetry older than this is shown as stale rather than live. */
@@ -30,18 +31,72 @@ class CNCjsLink {
     lastFailure = 0;
     port = null;
     controller = null;
+    baudrate = null;
     status = null;
     parserState = null;
     workflow = "idle";
     sender = null;
     alarm = null;
+    settings = null;
+    /** Firmware name from the controller's startup line ("Grbl", "GrblHAL"). */
+    firmware = null;
+    /** Grbl's $# parameters: saved zeros (G54-G59, G28, G30, G92), tool length offset. */
+    parameters = null;
+    onMachineListeners = [];
     gcodeName = null;
+    gcodeHash = null;
     telemetryAt = 0;
     ports = [];
     onLoadListeners = [];
+    onRunEndListeners = [];
+    // The sender as it stood during the run: CNCjs rewinds it to zero when the
+    // workflow stops, so the outcome is read from this, not the live sender.
+    runSender = null;
     onGcodeLoad(fn) {
         this.onLoadListeners.push(fn);
     }
+    onRunEnd(fn) {
+        this.onRunEndListeners.push(fn);
+    }
+    /** Called when the controller reports its settings, parameters or an alarm. */
+    onMachine(fn) {
+        this.onMachineListeners.push(fn);
+    }
+    reportMachine() {
+        if (!this.port)
+            return;
+        const report = {
+            port: this.port,
+            controller: this.controller,
+            firmware: this.firmware,
+            version: this.settings?.version ?? null,
+            baudrate: this.baudrate,
+            settings: this.settings?.values ?? null,
+            parameters: this.parameters,
+            alarm: this.alarm,
+        };
+        for (const fn of this.onMachineListeners)
+            fn(report);
+    }
+    /** Called when the workflow leaves running/paused: finished, stopped, or halted by an alarm. */
+    endRun() {
+        const s = this.runSender;
+        this.runSender = null;
+        if (!s || !s.name)
+            return;
+        const finished = s.finishTime > 0 || (s.total > 0 && s.received >= s.total);
+        const alarmed = this.status?.activeState === "Alarm" || this.alarm !== null;
+        const run = {
+            name: s.name,
+            outcome: finished ? "complete" : alarmed ? "alarm" : "stopped",
+            received: s.received,
+            total: s.total,
+            elapsedMs: s.startTime ? (s.finishTime || Date.now()) - s.startTime : s.elapsedTime,
+            alarm: alarmed ? this.alarm : null,
+        };
+        for (const fn of this.onRunEndListeners)
+            fn(run);
+    }
     /** Connects (starting a bundled CNCjs if needed). Safe to call repeatedly. */
     ensure() {
         if (this.connected)
@@ -140,14 +195,36 @@ class CNCjsLink {
         socket.on("serialport:open", (o) => {
             this.port = o?.port ?? null;
             this.controller = o?.controllerType ?? null;
+            this.baudrate = typeof o?.baudrate === "number" ? o.baudrate : null;
         });
         socket.on("serialport:close", () => {
+            if (this.workflow !== "idle")
+                this.endRun();
             this.port = null;
             this.controller = null;
+            this.baudrate = null;
             this.status = null;
+            this.settings = null;
+            this.firmware = null;
+            this.parameters = null;
             this.sender = null;
             this.workflow = "idle";
         });
+        // Grbl's $$ settings (travel, rapid rates, homing), which CNCjs asks for on connect.
+        socket.on("controller:settings", (_type, s) => {
+            const values = s?.settings && typeof s.settings === "object" ? s.settings : null;
+            if (values) {
+                const first = !this.settings;
+                this.settings = { version: typeof s.version === "string" ? s.version : null, values };
+                const params = s?.parameters && typeof s.parameters === "object" ? s.parameters : null;
+                if (params && Object.keys(params).length)
+                    this.parameters = params;
+                this.reportMachine();
+                // Ask once for the saved zeros ($#); Grbl answers at once and nothing moves.
+                if (first && this.workflow === "idle")
+                    this.socket?.emit("command", this.port, "gcode", "$#");
+            }
+        });
         socket.on("controller:state", (type, state) => {
             this.controller = type;
             this.status = state?.status ?? this.status;
@@ -161,27 +238,43 @@ class CNCjsLink {
         });
         socket.on("serialport:read", (data) => {
             const m = /ALARM:(\d+)(.*)/.exec(data ?? "");
-            if (m)
+            if (m) {
                 this.alarm = `ALARM:${m[1]}${m[2]}`.trim();
+                this.reportMachine();
+            }
+            const startup = /^(Grbl\w*)\s+v?\d/i.exec(data ?? "");
+            if (startup)
+                this.firmware = startup[1];
         });
         socket.on("workflow:state", (s) => {
+            const wasRunning = this.workflow !== "idle";
             this.workflow = s;
+            if (wasRunning && s === "idle")
+                this.endRun();
         });
         socket.on("sender:status", (s) => {
             this.sender = s;
+            if (this.workflow !== "idle" && (s.sent > 0 || s.finishTime > 0))
+                this.runSender = { ...s };
         });
         socket.on("gcode:load", (name, gcode) => {
             this.gcodeName = name;
             // CNCjs appends its own "%wait" dwell line; drop it from the preview.
             const program = gcode.replace(/\n%wait ; Wait for the planner to empty\s*$/, "");
+            this.gcodeHash = programHash(program);
             for (const fn of this.onLoadListeners)
                 fn(name, program);
         });
         socket.on("gcode:unload", () => {
             this.gcodeName = null;
+            this.gcodeHash = null;
             this.sender = null;
         });
     }
+    /** The controller's own settings ($$ for Grbl), or null before it has reported them. */
+    controllerSettings() {
+        return this.port ? this.settings : null;
+    }
     snapshot() {
         const age = Date.now() - this.telemetryAt;
         // CNCjs emits controller:state only when the state changes, so a quiet
@@ -205,6 +298,7 @@ class CNCjsLink {
             cncjs: { url: CNCJS_URL, managed: this.managed, connected: this.connected, error: this.error },
             port: this.port,
             controller: this.controller,
+            baudrate: this.baudrate,
             activeState: this.status?.activeState ?? null,
             workflow: this.workflow,
             mpos: toVec(this.status?.mpos),
@@ -213,6 +307,7 @@ class CNCjsLink {
             alarm: this.alarm,
             sender: this.sender,
             loadedFile: this.gcodeName,
+            loadedHash: this.gcodeHash,
             telemetryAt: this.telemetryAt ? new Date(this.telemetryAt).toISOString() : null,
         };
     }

package/dist/server/history.js

@@ -0,0 +1,48 @@
+// How each job file last ran on this computer, so the Jobs page can show
+// Complete or Stopped for files CNCjs no longer has loaded. CNCjs itself only
+// knows the program loaded right now. Kept beside the app's other state.
+import fs from "node:fs";
+import path from "node:path";
+import { STATE_DIR } from "./paths.js";
+const FILE = path.join(STATE_DIR, "job-history.json");
+let runs = null;
+function load() {
+    if (runs)
+        return runs;
+    try {
+        runs = JSON.parse(fs.readFileSync(FILE, "utf-8"));
+    }
+    catch {
+        runs = {};
+    }
+    return runs;
+}
+function save() {
+    try {
+        fs.mkdirSync(STATE_DIR, { recursive: true });
+        fs.writeFileSync(FILE, JSON.stringify(runs, null, 2));
+    }
+    catch {
+        // History is a convenience; a write failure must never affect a run.
+    }
+}
+export function lastRun(name) {
+    return load()[name] ?? null;
+}
+export function recordRun(run) {
+    load()[run.name] = {
+        outcome: run.outcome,
+        endedAt: new Date().toISOString(),
+        elapsedMs: run.elapsedMs,
+        received: run.received,
+        total: run.total,
+        alarm: run.alarm,
+    };
+    save();
+}
+export function forgetRun(name) {
+    if (!(name in load()))
+        return;
+    delete runs[name];
+    save();
+}