@assemblyline/al-control 0.1.0 → 0.3.0

package/CHANGELOG.md

@@ -7,6 +7,30 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.3.0] - 2026-10-19
+
+The first npm release after 0.1.0; it includes 0.2.0.
+
+### Added
+- Probe query `lines`: every line's stations in order, terminal, live bin counts, orphan counts
+  and summary, with no workpiece ids. The probe now holds the line model (station order,
+  terminal, summary); the CLI imports it instead of keeping a copy (decision 0006).
+- `@assemblyline/al-control/probe` export, so an app that bundles the probe can vendor it and
+  byte-check its copy against a pinned version.
+
+### Changed
+- `lines status` with no line uses the `lines` query: same output, a fraction of the data over
+  SSH.
+
+## [0.2.0] - 2026-10-19
+
+### Added
+- `-f <path>`: name a factory by its folder. `-f .` is the factory you're in, on this machine,
+  with no config needed; a configured local factory at that path keeps its name and `keep`
+  bins. With `--host`, the path is on that host.
+- `workpieces requeue --bin STATION/failed` or `requeue <id>`: move failed workpieces (or one
+  failed or done workpiece) back to their station's input. Dry run unless `--yes`.
+
 ## [0.1.0] - 2026-10-19
 
 First release as `@assemblyline/al-control`, forked from `fob-factory` 0.1.0 (FinOpsBricks).

package/README.md

@@ -3,6 +3,7 @@
 The control room CLI for [Assembly Line](https://assemblyline.sh): watch and operate factories on this machine or on machines you reach over SSH. See what's in every bin, why workpieces failed, and start or stop factory sessions.
 
 ```bash
+al-control lines status -f .                    # the factory you're in
 al-control hosts use build-box
 al-control factories list
 al-control lines status -f factory-globex
@@ -29,7 +30,7 @@ al-control workpieces errors              # why things failed, on every factory
 ```
 
 - **One config, one host at a time.** Like a kubectl context: `hosts use` picks the host, `--host` overrides it once.
-- **Factories are named, never inferred.** Per-factory commands take `-f <name>`; the current directory is ignored.
+- **Factories are named, never inferred.** Per-factory commands take `-f <name>` from the config, or a path: `-f .` is the factory you're standing in, and needs no config. The current directory is never used unless you type it.
 - **Nothing installed on remote hosts.** A small read-only script is piped to the host's `node` over your own `ssh`, so `~/.ssh/config`, keys and Tailscale SSH all just work.
 
 ## Install
@@ -73,6 +74,7 @@ Factory paths are paths on that host. Remote hosts need key-based SSH (no passwo
 | `workpieces list` / `show <id>` / `watch [id]` | yes | Where each workpiece is, its journey (and error, files), a live tail |
 | `workpieces count [failed\|done\|finished]` / `errors` | optional | Failed, done and finished counts; failures grouped by error. All factories unless `-f` |
 | `workpieces cat <id> <file>` / `open <id>` | yes | Read a file from a workpiece folder; open the folder (a shell in it, on a remote host) |
+| `workpieces requeue --bin STATION/failed` / `requeue <id>` | yes | Move failed workpieces (or one failed or done workpiece) back to their station's input to run again. Dry run unless `--yes` |
 | `workpieces clear --bin done\|finished` / `clear <id>` | yes | Delete done or finished workpieces, or one workpiece's copies; `--older-than <days>`. Dry run unless `--yes`; kept and conveyor-fed bins are skipped |
 | `procs list` | | Every factory process on the host |
 | `procs start` / `stop` / `restart` / `logs` | yes | pm2 control for one factory |

package/package.json

@@ -1,11 +1,15 @@
 {
   "name": "@assemblyline/al-control",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "description": "The control room CLI for Assembly Line: watch and operate factories across hosts, locally or over SSH",
   "type": "module",
   "bin": {
     "al-control": "./bin/al-control.js"
   },
+  "exports": {
+    "./probe": "./src/probe.js",
+    "./package.json": "./package.json"
+  },
   "scripts": {
     "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js",
     "test:watch": "node --experimental-vm-modules node_modules/jest/bin/jest.js --watch"

package/src/cli/index.js

@@ -4,7 +4,8 @@
  * Pattern: al-control <resource> <action> [target] [-f <factory>] [--host <host>]
  *
  * One host at a time (`hosts use`, or `--host` per command). Commands about a
- * single factory require `-f`; the current directory is never consulted.
+ * single factory require `-f`: a configured name, or a path (`-f .` for the factory
+ * you're in). The current directory is never used unless you type it.
  */
 
 import { readFileSync } from 'node:fs';
@@ -27,6 +28,7 @@ import { errorsHandler } from './workpieces/errors.js';
 import { catHandler } from './workpieces/cat.js';
 import { openHandler } from './workpieces/open.js';
 import { clearHandler } from './workpieces/clear.js';
+import { requeueHandler } from './workpieces/requeue.js';
 import { listProcsHandler } from './procs/list.js';
 import {
   startFactoryHandler,
@@ -88,7 +90,7 @@ function withFactories(handler) {
 function optionalFactoryOption(yargs) {
   return localOptions(yargs).option('factory', {
     alias: 'f',
-    describe: 'Only this factory (default: every factory on the host)',
+    describe: 'Only this factory: a name, or a path such as . (default: every factory on the host)',
     type: 'string',
   });
 }
@@ -96,7 +98,7 @@ function optionalFactoryOption(yargs) {
 function factoryOption(yargs) {
   return localOptions(yargs).option('factory', {
     alias: 'f',
-    describe: 'Factory name on the current host (required)',
+    describe: 'Factory: a name on the current host, or a path such as . (required)',
     type: 'string',
   });
 }
@@ -217,7 +219,20 @@ export function run(args) {
           }),
         withFactory(clearHandler, { frame: false }),
       )
-      .demandCommand(1, 'Specify an action: list, show, watch, count, errors, cat, open, clear'))
+      .command(
+        'requeue [id]',
+        'Move failed workpieces (--bin STATION/failed), or one failed or done workpiece (id), back to their station\'s input. Dry run unless --yes.',
+        (y) => factoryOption(y.positional('id', { describe: 'One workpiece (exact or unique substring) in a failed or done bin', type: 'string' }))
+          .option('bin', { describe: 'Every workpiece in this failed bin (STATION/failed)', type: 'string' })
+          .option('yes', { describe: 'Actually move (default: dry run)', type: 'boolean' })
+          .check((a) => {
+            if (!a.id && !a.bin) throw new Error('Give --bin STATION/failed, or a workpiece id.');
+            if (a.id && a.bin) throw new Error('Give either --bin or a workpiece id, not both.');
+            return true;
+          }),
+        withFactory(requeueHandler, { frame: false }),
+      )
+      .demandCommand(1, 'Specify an action: list, show, watch, count, errors, cat, open, clear, requeue'))
     .command('procs', 'Factory processes on the current host (pm2)', (yargs) => yargs
       .usage('$0 procs <action> [-f <factory>]')
       .command('list', 'Every running factory on the host', (y) => localOptions(y).option('json', jsonOption), withHost(listProcsHandler))
@@ -237,7 +252,7 @@ export function run(args) {
         factories: ['list'],
         lines: ['list', 'show', 'status'],
         stations: ['status'],
-        workpieces: ['list', 'show', 'watch', 'count', 'errors', 'cat', 'open', 'clear'],
+        workpieces: ['list', 'show', 'watch', 'count', 'errors', 'cat', 'open', 'clear', 'requeue'],
         procs: ['list', 'start', 'stop', 'restart', 'logs', 'monit'],
         config: ['show'],
       };

package/src/cli/lines/status.js

@@ -1,6 +1,6 @@
 import { formatTable, formatHeader, formatField } from '../../utils/format.js';
 import { summarizeLine, LIVE_BINS } from '../../utils/line-state.js';
-import { loadLines } from '../../utils/factory-data.js';
+import { loadLines, loadLineSummaries } from '../../utils/factory-data.js';
 import { watchRender, DEFAULT_WATCH_INTERVAL_SECS } from '../../utils/watch-render.js';
 
 /**
@@ -23,20 +23,25 @@ export async function statusLineHandler(argv, factory) {
   }
   const interval_secs = typeof interval === 'number' ? interval : DEFAULT_WATCH_INTERVAL_SECS;
 
-  const renderOnce = () => {
-    const { lines } = loadLines(factory);
-
-    if (Object.keys(lines).length === 0) {
-      if (json) console.log(JSON.stringify({}, null, 2));
-      else console.log(`No lines in ${factory.name}/.orchestrator/stations/. Run "al-orc stations pull --all" in the factory repo.`);
-      return;
-    }
+  const noLines = () => {
+    if (json) console.log(JSON.stringify({}, null, 2));
+    else console.log(`No lines in ${factory.name}/.orchestrator/stations/. Run "al-orc stations pull --all" in the factory repo.`);
+  };
 
+  const renderOnce = () => {
     if (!line_arg) {
-      renderLineSummary(lines, json);
+      // Counts only: the probe computes each line's summary.
+      const { lines } = loadLineSummaries(factory);
+      if (Object.keys(lines).length === 0) return noLines();
+      const summaries = {};
+      for (const [code, line] of Object.entries(lines)) summaries[code] = line.summary;
+      renderLineSummary(summaries, json);
       return;
     }
 
+    const { lines } = loadLines(factory);
+    if (Object.keys(lines).length === 0) return noLines();
+
     const ls = lines[line_arg];
     if (!ls) {
       const msg = `Line "${line_arg}" not found. Available: ${Object.keys(lines).sort().join(', ')}`;
@@ -58,9 +63,7 @@ export async function statusLineHandler(argv, factory) {
   renderOnce();
 }
 
-function renderLineSummary(lines, json) {
-  const summaries = {};
-  for (const ls of Object.values(lines)) summaries[ls.code] = summarizeLine(ls);
+function renderLineSummary(summaries, json) {
 
   if (json) {
     console.log(JSON.stringify(summaries, null, 2));

package/src/cli/workpieces/requeue.js

@@ -0,0 +1,98 @@
+// @ts-check
+
+import { probe } from '../../transport.js';
+import { formatTable } from '../../utils/format.js';
+import { loadLines } from '../../utils/factory-data.js';
+
+/**
+ * `al-control workpieces requeue [id] --bin STATION/failed -f <factory> [--yes]` — move
+ * workpieces back to their station's `input` to run that station again. With `--bin`, every
+ * workpiece in that station's `failed` bin; with an id, that one workpiece from `failed` or
+ * `done`. Dry run unless `--yes`. The probe re-checks each folder, drops its stale
+ * `error.json`/`error.txt` and logs a `requeued` event; the station's next run picks it up.
+ */
+
+/**
+ * @typedef {object} RequeueEntry
+ * @property {string} id
+ * @property {string} from - `STATION/BIN`
+ * @property {string} rel - folder relative to temp/stations/
+ */
+
+/**
+ * Which workpieces a requeue would move. Throws a user-facing Error when the request can't be
+ * met (unknown station, ambiguous id, nothing found).
+ *
+ * @param {Object<string, import('../../utils/line-state.js').LineState>} lines
+ * @param {{id?: string, bin?: string}} argv
+ * @returns {RequeueEntry[]}
+ */
+export function planRequeue(lines, argv) {
+  if (argv.bin) {
+    const m = argv.bin.match(/^([^/]+)\/failed\/?$/);
+    if (!m) throw new Error(`--bin takes STATION/failed (e.g. EX1/failed); to retry a done workpiece, give its id.`);
+    const station = m[1];
+    const line = Object.values(lines).find((l) => l.stations.includes(station));
+    if (!line) throw new Error(`Station "${station}" not found.`);
+    const map = line.bins[station].failed;
+    return [...(map ?? new Map())].map(([id, sub]) => ({ id, from: `${station}/failed`, rel: `${station}/failed/${sub}` }));
+  }
+
+  /** @type {RequeueEntry[]} */
+  const all = [];
+  for (const line of Object.values(lines)) {
+    for (const station of line.stations) {
+      for (const bin of ['failed', 'done']) {
+        for (const [id, sub] of line.bins[station][bin] ?? new Map()) {
+          all.push({ id, from: `${station}/${bin}`, rel: `${station}/${bin}/${sub}` });
+        }
+      }
+    }
+  }
+  const query = /** @type {string} */ (argv.id);
+  const exact = all.filter((e) => e.id === query);
+  const ids = exact.length > 0 ? [query] : [...new Set(all.filter((e) => e.id.includes(query)).map((e) => e.id))].sort();
+  if (ids.length === 0) throw new Error(`No failed or done workpiece matches "${query}".`);
+  if (ids.length > 1) {
+    const shown = ids.slice(0, 10);
+    throw new Error(`"${query}" matches ${ids.length} workpieces; use the full id:\n  ${shown.join('\n  ')}${ids.length > 10 ? `\n  … +${ids.length - 10} more` : ''}`);
+  }
+  const copies = all.filter((e) => e.id === ids[0]);
+  if (copies.length > 1) {
+    throw new Error(`${ids[0]} is in ${copies.map((c) => c.from).join(' and ')}; requeue one bin with --bin STATION/failed.`);
+  }
+  return copies;
+}
+
+/**
+ * @param {{id?: string, bin?: string, yes?: boolean}} argv
+ * @param {import('../../config.js').FactoryContext} factory
+ */
+export async function requeueHandler(argv, factory) {
+  const { lines } = loadLines(factory);
+  let plan;
+  try {
+    plan = planRequeue(lines, argv);
+  } catch (err) {
+    console.error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+  const where = `${factory.host.name} / ${factory.name}`;
+  if (plan.length === 0) {
+    console.log(`Nothing to requeue: ${argv.bin} is empty on ${where}.`);
+    return;
+  }
+
+  const counts = new Map();
+  for (const e of plan) counts.set(e.from, (counts.get(e.from) ?? 0) + 1);
+  console.log(formatTable(['FROM', 'TO', 'WORKPIECES'], [...counts].map(([from, n]) => [from, `${from.split('/')[0]}/input`, String(n)])));
+  if (plan.length === 1) console.log(`\n${plan[0].id}`);
+  console.log('');
+
+  if (!argv.yes) {
+    console.log(`Dry run: would requeue ${plan.length} workpiece${plan.length === 1 ? '' : 's'} on ${where}. Re-run with --yes to move.`);
+    return;
+  }
+  const { requeued } = probe(factory.host, { type: 'requeue', path: factory.path, dirs: plan.map((e) => e.rel) });
+  console.log(`Requeued ${requeued.length} workpiece${requeued.length === 1 ? '' : 's'} on ${where}. The station's next run picks them up.`);
+}

package/src/config.js

@@ -25,7 +25,7 @@
 
 import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'node:fs';
 import { homedir } from 'node:os';
-import { join } from 'node:path';
+import { join, resolve, basename } from 'node:path';
 import yaml from 'js-yaml';
 
 export const LOCAL_HOST = 'local';
@@ -174,16 +174,62 @@ export function resolveHost(argv) {
  */
 
 /**
- * Resolve host + the `-f` factory on it. `-f` is always required — the current
- * directory is never consulted.
+ * Whether a `-f` value is a path rather than a configured name. Names never hold a `/`.
+ * @param {string} value
+ * @returns {boolean}
+ */
+export function isPathTarget(value) {
+  return value === '.' || value === '..' || value.startsWith('~') || value.includes('/');
+}
+
+/** @param {string} p */
+function expandHome(p) {
+  return p === '~' || p.startsWith('~/') ? join(homedir(), p.slice(1)) : p;
+}
+
+/**
+ * `-f <path>`: a factory named by its folder. Without `--host` the path is on this machine
+ * (relative to the current directory) and needs no config; a configured local factory at the
+ * same path lends its name and `keep` bins. With `--host`, the path is on that host as written.
+ * Typing the path is the explicit target decision 0003 asks for; nothing falls back to the cwd.
+ * @param {{host?: string, factory: string}} argv
+ * @returns {FactoryContext}
+ */
+function resolvePathTarget(argv) {
+  if (argv.host) {
+    const host = resolveHost(argv);
+    const name = basename(argv.factory.replace(/\/+$/, '')) || argv.factory;
+    host.factories = { ...host.factories, [name]: argv.factory };
+    host.keep = { ...host.keep, [name]: host.keep[name] ?? [] };
+    return { ...factoryContext(host, name, argv.host), flags: `-f ${argv.factory} --host ${argv.host}` };
+  }
+  const abs = resolve(expandHome(argv.factory));
+  let name = basename(abs);
+  let keep = [];
+  if (existsSync(configPath())) {
+    const local = loadConfig().hosts[LOCAL_HOST];
+    for (const [n, entry] of Object.entries(local?.factories ?? {})) {
+      const e = factoryEntry(entry);
+      if (resolve(expandHome(e.path)) === abs) ({ name, keep } = { name: n, keep: e.keep });
+    }
+  }
+  /** @type {HostContext} */
+  const host = { name: LOCAL_HOST, is_local: true, factories: { [name]: abs }, keep: { [name]: keep } };
+  return { host, name, path: abs, keep, flags: `-f ${argv.factory}` };
+}
+
+/**
+ * Resolve host + the `-f` factory on it: a configured name, or a path (`-f .`). `-f` is always
+ * required — the current directory is never consulted on its own.
  * @param {{host?: string, factory?: string}} argv
  * @returns {FactoryContext}
  */
 export function resolveFactory(argv) {
+  if (argv.factory && isPathTarget(argv.factory)) return resolvePathTarget({ ...argv, factory: argv.factory });
   const host = resolveHost(argv);
   const names = Object.keys(host.factories);
   if (!argv.factory) {
-    throw new Error(`Specify a factory with -f <name>. Factories on ${host.name}: ${names.join(', ') || '(none)'}`);
+    throw new Error(`Specify a factory with -f <name>, or -f . for the one you're in. Factories on ${host.name}: ${names.join(', ') || '(none)'}`);
   }
   const p = host.factories[argv.factory];
   if (!p) {

package/src/probe.js

@@ -5,7 +5,12 @@
  * can send this file verbatim over SSH and run it with `node -` on a host that
  * has no al-control installed (see transport.js). Locally the client imports
  * `runQuery` in-process. Either way the result is plain JSON — no Maps, no
- * formatting. Grouping lines, topo ordering and position resolution happen
+ * formatting.
+ *
+ * It also owns the line model (station order, terminal station, per-line
+ * summary) so every client renders the same answer from the `lines` query: the
+ * CLI imports these functions, and the control-room desktop app vendors this
+ * file byte for byte instead of porting the logic. Positions and formatting stay
  * client-side (utils/line-state.js).
  *
  * Adapted from al-factory's station-files.js, line-state.js and
@@ -18,7 +23,8 @@ import os from 'node:os';
 import path from 'node:path';
 import { execSync } from 'node:child_process';
 
-const ALL_BINS = ['input', 'doing', 'output', 'failed', 'done'];
+export const ALL_BINS = ['input', 'doing', 'output', 'failed', 'done'];
+export const LIVE_BINS = ['input', 'doing', 'output', 'failed'];
 const MAX_BIN_DEPTH = 4; // depth limit for sub-bin walks (output/invoices/hi-1/ = depth 2)
 const ERROR_MESSAGE_CAP = 2000;
 const READ_FILE_CAP = 20 * 1024 * 1024;
@@ -503,6 +509,210 @@ function listRunningFactories() {
   return { procs: rows, pm2_found: apps !== null };
 }
 
+// ---------------------------------------------------------------------------
+// Line model (pure; shared with the CLI and vendored by control-room)
+// ---------------------------------------------------------------------------
+
+/**
+ * @typedef {{line: string|null, data: any}} StationDef
+ */
+
+/**
+ * Stable code for a station def — short_code, falling back to id.
+ * @param {StationDef} s
+ * @returns {string}
+ */
+export const codeOf = (s) => s.data.short_code || s.data.id;
+
+/**
+ * Index station defs by every reference form they answer to, so a dependency
+ * edge written as short_code or id finds its peer.
+ * @param {StationDef[]} members
+ * @returns {Map<string, StationDef>}
+ */
+export function indexStationsByRef(members) {
+  const by_ref = new Map();
+  for (const s of members) {
+    by_ref.set(codeOf(s), s);
+    if (s.data.id) by_ref.set(s.data.id, s);
+    if (s.data.short_code) by_ref.set(s.data.short_code, s);
+  }
+  return by_ref;
+}
+
+/**
+ * Normalise one `dependencies` entry (bare id string, or object with
+ * short_code/id) to a reference string.
+ * @param {any} dep
+ * @returns {string|undefined}
+ */
+export function dependencyRef(dep) {
+  return typeof dep === 'string' ? dep : dep?.short_code || dep?.id;
+}
+
+/**
+ * Resolve a station reference (short_code or orchestrator id) to its display
+ * code; unchanged when the peer isn't among `stations`.
+ * @param {string} ref
+ * @param {Map<string, StationDef>|StationDef[]} stations
+ * @returns {string}
+ */
+export function resolveStationRef(ref, stations) {
+  const by_ref = stations instanceof Map ? stations : indexStationsByRef(stations);
+  const match = by_ref.get(ref);
+  return match ? codeOf(match) : ref;
+}
+
+/**
+ * Topologically sort one line's station defs by `dependencies`, with an
+ * alphabetical pre-sort for stable sibling order.
+ * @param {StationDef[]} members
+ * @returns {StationDef[]}
+ */
+export function topoSortStations(members) {
+  const by_ref = indexStationsByRef(members);
+  /** @param {StationDef} s */
+  const depsOf = (s) => (s.data.dependencies || [])
+    .map(dependencyRef)
+    .map((/** @type {string} */ ref) => by_ref.get(ref))
+    .filter(Boolean);
+
+  const sorted = [...members].sort((a, b) => codeOf(a).localeCompare(codeOf(b)));
+  const visited = new Set();
+  /** @type {StationDef[]} */
+  const result = [];
+  /** @param {StationDef} s */
+  const visit = (s) => {
+    const code = codeOf(s);
+    if (visited.has(code)) return;
+    visited.add(code);
+    for (const dep of depsOf(s)) visit(dep);
+    result.push(s);
+  };
+  for (const s of sorted) visit(s);
+  return result;
+}
+
+/**
+ * Terminal = station no in-line peer depends on. With several sinks, the one
+ * latest in topo order.
+ * @param {StationDef[]} ordered - From topoSortStations
+ * @returns {string}
+ */
+export function computeTerminal(ordered) {
+  if (ordered.length === 0) return '';
+  const by_ref = indexStationsByRef(ordered);
+  const depended_on = new Set();
+  for (const s of ordered) {
+    for (const d of s.data.dependencies || []) {
+      const ref = dependencyRef(d);
+      if (ref && by_ref.has(ref)) depended_on.add(resolveStationRef(ref, by_ref));
+    }
+  }
+  for (let i = ordered.length - 1; i >= 0; i--) {
+    const c = codeOf(ordered[i]);
+    if (!depended_on.has(c)) return c;
+  }
+  return codeOf(ordered[ordered.length - 1]);
+}
+
+/**
+ * Station defs grouped by line, each line's stations in dependency order.
+ * @param {StationDef[]} stations
+ * @returns {Object<string, {stations: string[], terminal: string}>}
+ */
+export function groupLines(stations) {
+  /** @type {Map<string, StationDef[]>} */
+  const grouped = new Map();
+  for (const def of stations) {
+    if (!def.line) continue;
+    if (!grouped.has(def.line)) grouped.set(def.line, []);
+    grouped.get(def.line)?.push(def);
+  }
+  /** @type {Object<string, {stations: string[], terminal: string}>} */
+  const lines = {};
+  for (const [code, members] of grouped) {
+    const ordered = topoSortStations(members);
+    lines[code] = { stations: ordered.map(codeOf), terminal: computeTerminal(ordered) };
+  }
+  return lines;
+}
+
+/**
+ * @typedef {object} LineSummary
+ * @property {number} in_flight - input + doing + output, excluding terminal output
+ * @property {number} stuck - failed across the line
+ * @property {number} finished - terminal-station output
+ * @property {string[]} stuck_locations - e.g. '3 at VM2/failed'
+ * @property {{count: number, at: string|null}} biggest_flow - fullest in-flight bin
+ */
+
+/**
+ * Per-line totals from live bin counts (`done` ignored).
+ * @param {{stations: string[], terminal: string}} line
+ * @param {Object<string, Object<string, number|null>>} counts - counts[station][bin], null when the bin is missing
+ * @returns {LineSummary}
+ */
+export function summarizeCounts(line, counts) {
+  let in_flight = 0;
+  let stuck = 0;
+  let finished = 0;
+  /** @type {string[]} */
+  const stuck_locations = [];
+  /** @type {{count: number, at: string|null}} */
+  let biggest_flow = { count: 0, at: null };
+
+  for (const station of line.stations) {
+    const is_terminal = station === line.terminal;
+    for (const bin of LIVE_BINS) {
+      const n = counts[station]?.[bin];
+      if (n === null || n === undefined) continue;
+      if (bin === 'failed') {
+        stuck += n;
+        if (n > 0) stuck_locations.push(`${n} at ${station}/failed`);
+      } else if (is_terminal && bin === 'output') {
+        finished += n;
+      } else {
+        in_flight += n;
+        if (n > biggest_flow.count) biggest_flow = { count: n, at: `${station}/${bin}` };
+      }
+    }
+  }
+  return { in_flight, stuck, finished, stuck_locations, biggest_flow };
+}
+
+/**
+ * The `lines` query: every line with its stations in order, terminal, live bin
+ * counts and summary, from one read of the factory. Counts only, no workpiece
+ * ids, so it stays small enough to poll.
+ * @param {string} root
+ */
+function readLines(root) {
+  const { stations, lines: line_defs, factory, bins, orphans } = readState(root);
+  /** @type {Object<string, Object<string, number|null>>} */
+  const counts = {};
+  for (const [code, by_bin] of Object.entries(bins)) {
+    counts[code] = {};
+    for (const [bin, ids] of Object.entries(by_bin)) counts[code][bin] = ids === null ? null : Object.keys(ids).length;
+  }
+  const lines = {};
+  for (const [code, line] of Object.entries(groupLines(stations))) {
+    const def = line_defs[code] ?? {};
+    const line_counts = Object.fromEntries(line.stations.map((st) => [st, counts[st] ?? {}]));
+    lines[code] = {
+      code,
+      name: def.name ?? null,
+      location: def.location ?? null,
+      stations: line.stations,
+      terminal: line.terminal,
+      counts: line_counts,
+      orphans: Object.fromEntries(line.stations.filter((st) => orphans[st]).map((st) => [st, Object.keys(orphans[st]).length])),
+      summary: summarizeCounts(line, line_counts),
+    };
+  }
+  return { factory, lines };
+}
+
 // ---------------------------------------------------------------------------
 // Entry points
 // ---------------------------------------------------------------------------
@@ -510,6 +720,7 @@ function listRunningFactories() {
 /**
  * @typedef {{type: 'defs', path: string}
  *   | {type: 'state', path: string}
+ *   | {type: 'lines', path: string}
  *   | {type: 'logs', path: string, dirs: string[]}
  *   | {type: 'errors', path: string, dirs: string[]}
  *   | {type: 'ages', path: string, dirs: string[]}
@@ -536,6 +747,10 @@ export function runQuery(query) {
       const root = requireFactoryRoot(query.path);
       return { root, ...readState(root) };
     }
+    case 'lines': {
+      const root = requireFactoryRoot(query.path);
+      return { root, ...readLines(root) };
+    }
     case 'logs': {
       const root = requireFactoryRoot(query.path);
       return { root, logs: readLogs(root, query.dirs) };

package/src/utils/factory-data.js

@@ -17,6 +17,16 @@ export function loadDefs(factory) {
   return probe(factory.host, { type: 'defs', path: factory.path });
 }
 
+/**
+ * Every line's station order, terminal, live bin counts and summary — the
+ * probe's `lines` query. Counts only, so it is cheap to poll over SSH.
+ * @param {import('../config.js').FactoryContext} factory
+ * @returns {{root: string, factory: object|null, lines: Object<string, {code: string, name: string|null, location: string|null, stations: string[], terminal: string, counts: Object<string, Object<string, number|null>>, orphans: Object<string, number>, summary: import('../probe.js').LineSummary}>}}
+ */
+export function loadLineSummaries(factory) {
+  return probe(factory.host, { type: 'lines', path: factory.path });
+}
+
 /**
  * Live per-line state, plus the station defs it was built from and the
  * orphaned failed folders (no pointer.json) per station.

package/src/utils/line-state.js

@@ -13,16 +13,29 @@
  *   - Position rule: walk stations terminal → source; at each, check
  *     output > doing > input > failed; first match wins. done ignored.
  *
- * Pure logic copied from al-factory's line-state.js; the filesystem half lives
- * in ../probe.js.
+ * Station order, terminal and summaries come from ../probe.js (one copy, shared
+ * with control-room); this module adds the Map view and workpiece positions.
  */
 
-export const ALL_BINS = ['input', 'doing', 'output', 'failed', 'done'];
-export const LIVE_BINS = ['input', 'doing', 'output', 'failed'];
+import {
+  ALL_BINS,
+  LIVE_BINS,
+  codeOf,
+  indexStationsByRef,
+  dependencyRef,
+  resolveStationRef,
+  topoSortStations,
+  computeTerminal,
+  groupLines,
+  summarizeCounts,
+} from '../probe.js';
+
+export { ALL_BINS, LIVE_BINS, codeOf, indexStationsByRef, dependencyRef, resolveStationRef, topoSortStations, computeTerminal };
+
 const LIVE_PRIORITY = ['output', 'doing', 'input', 'failed']; // most-advanced first
 
 /**
- * @typedef {{line: string|null, data: object}} StationDef
+ * @typedef {import('../probe.js').StationDef} StationDef
  */
 
 /**
@@ -46,119 +59,23 @@ const LIVE_PRIORITY = ['output', 'doing', 'input', 'failed']; // most-advanced f
  * @property {boolean} [anomaly] - true when only present in done (not live)
  */
 
-/** Stable code for a station def — short_code, falling back to id. */
-export const codeOf = (s) => s.data.short_code || s.data.id;
-
-/**
- * Index station defs by every reference form they answer to, so a dependency
- * edge written as short_code or id finds its peer.
- * @param {StationDef[]} members
- * @returns {Map<string, StationDef>}
- */
-export function indexStationsByRef(members) {
-  const by_ref = new Map();
-  for (const s of members) {
-    by_ref.set(codeOf(s), s);
-    if (s.data.id) by_ref.set(s.data.id, s);
-    if (s.data.short_code) by_ref.set(s.data.short_code, s);
-  }
-  return by_ref;
-}
-
-/**
- * Normalise one `dependencies` entry (bare id string, or object with
- * short_code/id) to a reference string.
- */
-export function dependencyRef(dep) {
-  return typeof dep === 'string' ? dep : dep?.short_code || dep?.id;
-}
-
-/**
- * Resolve a station reference (short_code or orchestrator id) to its display
- * code; unchanged when the peer isn't among `stations`.
- * @param {string} ref
- * @param {Map<string, StationDef>|StationDef[]} stations
- */
-export function resolveStationRef(ref, stations) {
-  const by_ref = stations instanceof Map ? stations : indexStationsByRef(stations);
-  const match = by_ref.get(ref);
-  return match ? codeOf(match) : ref;
-}
-
-/**
- * Topologically sort one line's station defs by `dependencies`, with an
- * alphabetical pre-sort for stable sibling order.
- * @param {StationDef[]} members
- * @returns {StationDef[]}
- */
-export function topoSortStations(members) {
-  const by_ref = indexStationsByRef(members);
-  const depsOf = (s) => (s.data.dependencies || [])
-    .map(dependencyRef)
-    .map((ref) => by_ref.get(ref))
-    .filter(Boolean);
-
-  const sorted = [...members].sort((a, b) => codeOf(a).localeCompare(codeOf(b)));
-  const visited = new Set();
-  const result = [];
-  const visit = (s) => {
-    const code = codeOf(s);
-    if (visited.has(code)) return;
-    visited.add(code);
-    for (const dep of depsOf(s)) visit(dep);
-    result.push(s);
-  };
-  for (const s of sorted) visit(s);
-  return result;
-}
-
-/**
- * Terminal = station no in-line peer depends on. With several sinks, the one
- * latest in topo order.
- */
-function computeTerminal(ordered) {
-  if (ordered.length === 0) return '';
-  const by_ref = indexStationsByRef(ordered);
-  const depended_on = new Set();
-  for (const s of ordered) {
-    for (const d of s.data.dependencies || []) {
-      const ref = dependencyRef(d);
-      if (by_ref.has(ref)) depended_on.add(resolveStationRef(ref, by_ref));
-    }
-  }
-  for (let i = ordered.length - 1; i >= 0; i--) {
-    const c = codeOf(ordered[i]);
-    if (!depended_on.has(c)) return c;
-  }
-  return codeOf(ordered[ordered.length - 1]);
-}
-
 /**
  * Build per-line state from a probe `state` result.
  * @param {{stations: StationDef[], bins: Object<string, Object<string, Object<string, string>|null>>}} state
  * @returns {Object<string, LineState>} keyed by line code
  */
 export function buildLineState(state) {
-  const grouped = new Map();
-  for (const def of state.stations) {
-    if (!def.line) continue;
-    if (!grouped.has(def.line)) grouped.set(def.line, []);
-    grouped.get(def.line).push(def);
-  }
-
   const lines = {};
-  for (const [line_code, members] of grouped) {
-    const ordered = topoSortStations(members);
-    const station_codes = ordered.map(codeOf);
+  for (const [line_code, line] of Object.entries(groupLines(state.stations))) {
     const bins = {};
-    for (const station of station_codes) {
+    for (const station of line.stations) {
       bins[station] = {};
       for (const bin of ALL_BINS) {
         const listing = state.bins[station]?.[bin];
         bins[station][bin] = listing ? new Map(Object.entries(listing)) : null;
       }
     }
-    lines[line_code] = { code: line_code, stations: station_codes, terminal: computeTerminal(ordered), bins };
+    lines[line_code] = { code: line_code, stations: line.stations, terminal: line.terminal, bins };
   }
   return lines;
 }
@@ -296,29 +213,13 @@ export function workpieceRelDir(pos, workpiece_id) {
  * @param {LineState} line
  */
 export function summarizeLine(line) {
-  let in_flight = 0;
-  let stuck = 0;
-  let finished = 0;
-  const stuck_locations = [];
-  let biggest_flow = { count: 0, at: null };
-
+  const counts = {};
   for (const station of line.stations) {
-    const bins = line.bins[station];
-    const is_terminal = station === line.terminal;
+    counts[station] = {};
     for (const bin of LIVE_BINS) {
-      const map = bins[bin];
-      if (!map) continue;
-      const n = map.size;
-      if (bin === 'failed') {
-        stuck += n;
-        if (n > 0) stuck_locations.push(`${n} at ${station}/failed`);
-      } else if (is_terminal && bin === 'output') {
-        finished += n;
-      } else {
-        in_flight += n;
-        if (n > biggest_flow.count) biggest_flow = { count: n, at: `${station}/${bin}` };
-      }
+      const map = line.bins[station][bin];
+      counts[station][bin] = map ? map.size : null;
     }
   }
-  return { in_flight, stuck, finished, stuck_locations, biggest_flow };
+  return summarizeCounts(line, counts);
 }