zelpi 0.1.0

package/dist/pios-engine.mjs

@@ -0,0 +1,948 @@
+// lib/intent.ts
+var COLORS = ["red", "blue", "green", "yellow", "orange", "purple"];
+function st(label, agent, kind) {
+  return { label, agent, kind };
+}
+function parseIntent(raw, items) {
+  const text = raw.toLowerCase().trim();
+  const aisle = matchAisle(text);
+  const color = COLORS.find((c) => text.includes(c));
+  const wantsLocate = /\b(locate|find|identify|where|search)\b/.test(text);
+  const wantsPick = /\b(pick|grab|retrieve|grasp|fetch|lift|move the|bring)\b/.test(text);
+  const wantsInventory = /\b(inventory|count|catalog|stock|audit|scan)\b/.test(text);
+  const wantsGo = /\b(go|walk|drive|navigate|patrol|head)\b/.test(text);
+  let target;
+  if (color) {
+    const pool = items.filter(
+      (it) => it.color === hex(color) && (aisle ? it.aisle === aisle : true)
+    );
+    target = pool[0];
+  }
+  if (wantsInventory && aisle) {
+    return {
+      summary: `Inventory Aisle ${aisle}: traverse the lane, perceive every shelf face, and catalog detected items.`,
+      load: 0.55,
+      targetAisle: aisle,
+      subtasks: [
+        st(`Navigate to head of Aisle ${aisle}`, "spatial", "navigate"),
+        st(`Sweep-scan all shelf faces in Aisle ${aisle}`, "vision", "perceive"),
+        st("Reconcile detections against spatial map", "spatial", "map"),
+        st("Catalog item manifest", "vision", "perceive"),
+        st("Settle inventory job & aggregate to global model", "settlement", "settle")
+      ]
+    };
+  }
+  if (wantsPick && (color || target)) {
+    const what = color ? `the ${color} box` : "the target object";
+    return {
+      summary: `Retrieve ${what}${aisle ? ` from Aisle ${aisle}` : ""}: locate, plan a grasp, and execute under safety supervision.`,
+      load: 0.8,
+      targetAisle: aisle ?? target?.aisle,
+      targetItemId: target?.id,
+      subtasks: [
+        st(`Navigate toward ${what}`, "spatial", "navigate"),
+        st(`Visually confirm ${what}`, "vision", "perceive"),
+        st("Plan whole-body grasp trajectory", "kinematic", "manipulate"),
+        st("Execute grasp (Safety Broker gated)", "kinematic", "manipulate"),
+        st("Settle handling job", "settlement", "settle")
+      ]
+    };
+  }
+  if (wantsLocate || color) {
+    const what = color ? `the ${color} box` : "the requested object";
+    return {
+      summary: `Locate ${what}${aisle ? ` in Aisle ${aisle}` : ""}: walk to the shelf and visually identify it.`,
+      load: 0.5,
+      targetAisle: aisle ?? target?.aisle,
+      targetItemId: target?.id,
+      subtasks: [
+        st(`Navigate toward ${aisle ? `Aisle ${aisle}` : "candidate shelves"}`, "spatial", "navigate"),
+        st(`Visually scan for ${what}`, "vision", "perceive"),
+        st(`Identify & flag ${what}`, "vision", "perceive")
+      ]
+    };
+  }
+  if (wantsGo) {
+    return {
+      summary: `Navigate the floor${aisle ? ` to Aisle ${aisle}` : ""} and hold position for further intent.`,
+      load: 0.3,
+      targetAisle: aisle,
+      subtasks: [
+        st(`Plan path${aisle ? ` to Aisle ${aisle}` : " across floor"}`, "spatial", "navigate"),
+        st("Drive route with live obstacle avoidance", "spatial", "navigate")
+      ]
+    };
+  }
+  return {
+    summary: `Interpret "${raw}" as an exploratory directive: survey the nearest aisle and report findings.`,
+    load: 0.4,
+    targetAisle: aisle,
+    subtasks: [
+      st("Plan exploratory route", "spatial", "navigate"),
+      st("Survey environment", "vision", "perceive"),
+      st("Update spatial map", "spatial", "map")
+    ]
+  };
+}
+function matchAisle(text) {
+  const m = text.match(/aisle\s*(\d+)/) || text.match(/\b(?:lane|row)\s*(\d+)/);
+  if (m) return clampAisle(parseInt(m[1], 10));
+  return void 0;
+}
+function clampAisle(n) {
+  return Math.min(4, Math.max(1, n));
+}
+function hex(color) {
+  return {
+    red: "#ef4444",
+    blue: "#3b82f6",
+    green: "#22c55e",
+    yellow: "#eab308",
+    orange: "#f97316",
+    purple: "#a855f7"
+  }[color];
+}
+
+// lib/types.ts
+var PROFILE_META = {
+  balanced: {
+    label: "Balanced (Kernel default)",
+    glyph: "\u25C7",
+    desc: "Neutral routing \u2014 the kernel's baseline scheduler.",
+    speed: 1,
+    scrutiny: 1,
+    color: "#94a3b8"
+  },
+  robustness: {
+    label: "Robustness",
+    glyph: "\u25A3",
+    desc: "Handle many SOCs, buses & hardware; multi-system spread, extra checks.",
+    speed: 0.95,
+    scrutiny: 1.2,
+    color: "#60a5fa"
+  },
+  optimisation: {
+    label: "Optimisation",
+    glyph: "\u26A1",
+    desc: "Fastest response for routine tasks where speed beats deliberation.",
+    speed: 1.4,
+    scrutiny: 0.5,
+    color: "#34d399"
+  },
+  "system-critical": {
+    label: "System-Critical",
+    glyph: "\u25C6",
+    desc: "Precise, high-integrity work \u2014 maximum Safety Broker scrutiny.",
+    speed: 0.82,
+    scrutiny: 1.8,
+    color: "#f87171"
+  }
+};
+
+// lib/world.ts
+var FLOOR = { w: 100, h: 60 };
+var COLOR_POOL = [
+  { name: "red", hex: "#ef4444" },
+  { name: "blue", hex: "#3b82f6" },
+  { name: "green", hex: "#22c55e" },
+  { name: "yellow", hex: "#eab308" },
+  { name: "orange", hex: "#f97316" },
+  { name: "purple", hex: "#a855f7" }
+];
+var ITEM_LABELS = ["pallet", "tote", "carton", "drum", "crate", "bin"];
+function buildWorld(seed = 7) {
+  const rng = mulberry32(seed);
+  const shelves = [];
+  const items = [];
+  const aisles = 4;
+  for (let a = 1; a <= aisles; a++) {
+    const x = 14 + (a - 1) * 24;
+    const perAisle = 4;
+    for (let s = 0; s < perAisle; s++) {
+      const y = 8 + s * 12;
+      const shelf = { id: `sh-${a}-${s}`, aisle: a, pos: { x, y }, w: 10, h: 7 };
+      shelves.push(shelf);
+      const count = 1 + Math.floor(rng() * 2);
+      for (let i = 0; i < count; i++) {
+        const c = COLOR_POOL[Math.floor(rng() * COLOR_POOL.length)];
+        const label = ITEM_LABELS[Math.floor(rng() * ITEM_LABELS.length)];
+        items.push({
+          id: `it-${a}-${s}-${i}`,
+          label: `${c.name} ${label}`,
+          color: c.hex,
+          pos: { x: x + (i === 0 ? -2.5 : 2.5), y: y + 1 },
+          aisle: a,
+          found: false
+        });
+      }
+    }
+  }
+  return { shelves, items };
+}
+function buildFleet() {
+  const base = (i) => ({ x: 4, y: 8 + i * 14 });
+  return [
+    mkRobot("rb-01", "Atlas-01", "Humanoid biped", "EtherCAT", base(0)),
+    mkRobot("rb-02", "Mule-02", "AMR cart", "CAN", base(1)),
+    mkRobot("rb-03", "Arm-03", "6-DoF industrial arm", "CAN", base(2)),
+    mkRobot("rb-04", "Scout-04", "Quadruped", "EtherCAT", base(3))
+  ];
+}
+function mkRobot(id, name, chassis, bus, pos) {
+  return {
+    id,
+    name,
+    chassis,
+    bus,
+    pos,
+    heading: 0,
+    battery: 70 + Math.random() * 28,
+    status: "idle",
+    joints: Array.from({ length: 7 }, () => 0.5),
+    torque: 0
+  };
+}
+function dist(a, b) {
+  return Math.hypot(a.x - b.x, a.y - b.y);
+}
+function angle(from, to) {
+  return Math.atan2(to.y - from.y, to.x - from.x);
+}
+function mulberry32(seed) {
+  let a = seed >>> 0;
+  return function() {
+    a |= 0;
+    a = a + 1831565813 | 0;
+    let t = Math.imul(a ^ a >>> 15, 1 | a);
+    t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+}
+
+// lib/engine.ts
+var LOG_CAP = 170;
+var MOVE_SPEED = 13;
+var SAFETY_TRIGGER_P = 0.45;
+var TRAIN_SECONDS = 26;
+var TRAIN_EPOCHS = 60;
+var BASELINE_Q = 0.42;
+var PiOsEngine = class {
+  constructor() {
+    this.tasks = [];
+    this.logs = [];
+    this.models = [];
+    this.safety = null;
+    this.paused = false;
+    /** Active Kernel execution profile (the diagram's QoS router). Biases Safety
+     *  Broker scrutiny + execution speed. Set via the CLI/console kernel layer. */
+    this.profile = "balanced";
+    /** When true (Phase 4), an external robot (ROS 2 via rosbridge) owns the pose;
+     *  the engine stops integrating motion internally and accepts setRobotPose(). */
+    this.externalControl = false;
+    /** Bumped on reset / fleet change so the ROS bridge can re-seed robot poses. */
+    this.fleetGeneration = 0;
+    /** Demo aid: force the next gated manipulation to trip the Safety/HITL gate. */
+    this.forceSafetyNext = false;
+    this.listeners = /* @__PURE__ */ new Set();
+    this.logId = 1;
+    this.taskSeq = 1;
+    this.safetyId = 1;
+    this.modelSeq = 1;
+    this.robotSeq = 5;
+    // factory fleet uses 01..04
+    this.clock = 0;
+    this.version = 0;
+    this.rr = 0;
+    // round-robin pointer for robot assignment
+    this.sub = /* @__PURE__ */ new Map();
+    this.acc = { s0: 0, s1: 0, s2: 0, s3: 0 };
+    // ambient log accumulators
+    this.settlements = 0;
+    this.dataAggregated = 0;
+    this.snap = null;
+    // ── subscription API ───────────────────────────────────────────────────────
+    this.subscribe = (fn) => {
+      this.listeners.add(fn);
+      return () => this.listeners.delete(fn);
+    };
+    this.getSnapshot = () => {
+      if (!this.snap) this.rebuildSnapshot();
+      return this.snap;
+    };
+    const w = buildWorld();
+    this.shelves = w.shelves;
+    this.items = w.items;
+    this.robots = buildFleet();
+    this.models = this.seedModels();
+    this.log("S3", "info", "Fleet & Economic Orchestrator online. 4 agents enrolled with verifiable M2M identity.");
+    this.log("S3", "info", "Factory models deployed: VLA v1, ACT v1, M-HAL v1. Awaiting operator intent.");
+  }
+  /** Ship one baseline (factory) model per layer, already deployed. */
+  seedModels() {
+    const mk = (kind, name) => ({
+      id: `M${this.modelSeq++}`,
+      name,
+      kind,
+      version: 1,
+      embodiment: "universal",
+      status: "deployed",
+      quality: BASELINE_Q,
+      trainProgress: 1,
+      epoch: TRAIN_EPOCHS,
+      totalEpochs: TRAIN_EPOCHS,
+      loss: 0.31,
+      targetLoss: 0.31,
+      lossHistory: [2.4, 1.6, 1, 0.66, 0.45, 0.31],
+      datasetMB: 1200,
+      createdAt: 0
+    });
+    return [mk("vla", "vla-omni"), mk("act", "act-chunk"), mk("mhal", "mhal-prior")];
+  }
+  emit() {
+    this.rebuildSnapshot();
+    this.listeners.forEach((l) => l());
+  }
+  rebuildSnapshot() {
+    this.snap = {
+      robots: this.robots,
+      items: this.items,
+      shelves: this.shelves,
+      tasks: this.tasks,
+      logs: this.logs,
+      models: this.models,
+      safety: this.safety,
+      paused: this.paused,
+      profile: this.profile,
+      metrics: this.metrics(),
+      version: this.version
+    };
+  }
+  // ── operator commands ──────────────────────────────────────────────────────
+  /** Conversational Command Center entry point (offline deterministic parse). */
+  submitIntent(raw) {
+    const text = raw.trim();
+    if (!text) return null;
+    return this.submitPlannedIntent(text, parseIntent(text, this.items), "fallback");
+  }
+  /**
+   * Create + dispatch a task from an already-computed plan. Lets the backend
+   * supply a plan from a real System-2 model (LLM/VLA) while sharing one code
+   * path with the offline deterministic parser.
+   */
+  submitPlannedIntent(raw, parsed, source = "llm") {
+    const text = raw.trim();
+    if (!text) return null;
+    const robot = this.pickRobot();
+    if (!robot) {
+      this.log("S3", "warn", "No fleet capacity available \u2014 all agents engaged.");
+      this.emit();
+      return null;
+    }
+    this.log("OP", "info", `Operator \u2192 "${text}"`);
+    this.log(
+      "S2",
+      source === "llm" ? "ok" : "info",
+      `VLA${source === "llm" ? " (model)" : ""} parsed intent: ${parsed.summary}`
+    );
+    const task = {
+      id: `T${this.taskSeq++}`,
+      intent: text,
+      summary: parsed.summary,
+      robotId: robot.id,
+      state: "running",
+      createdAt: this.clock,
+      targetAisle: parsed.targetAisle,
+      targetItemId: parsed.targetItemId,
+      subtasks: parsed.subtasks.map((s, i) => ({
+        ...s,
+        id: `${this.taskSeq}-${i}`,
+        state: "queued",
+        progress: 0
+      }))
+    };
+    this.tasks.unshift(task);
+    robot.taskId = task.id;
+    this.log("S3", "act", `Deployed ${task.subtasks.length}-step plan to ${robot.name} (${task.id}).`);
+    this.activateNext(task, robot);
+    this.emit();
+    return task;
+  }
+  /** Operator resolves a Safety Broker / HITL prompt. */
+  resolveSafety(option) {
+    const p = this.safety;
+    if (!p) return;
+    const robot = this.robot(p.robotId);
+    const task = this.task(p.taskId);
+    const sub = task?.subtasks.find((s) => s.id === p.subTaskId);
+    this.log("OP", "act", `Operator authorization: "${option}".`);
+    this.safety = null;
+    if (!robot || !task || !sub) {
+      this.emit();
+      return;
+    }
+    const opt = option.toLowerCase();
+    if (opt.includes("abort")) {
+      task.state = "aborted";
+      sub.state = "blocked";
+      robot.status = "idle";
+      robot.taskId = void 0;
+      robot.waypoint = void 0;
+      this.log("S3", "warn", `${task.id} aborted by operator. ${robot.name} returning to standby.`);
+    } else if (opt.includes("reroute")) {
+      this.sub.get(sub.id).gateResolved = true;
+      this.log("S1", "act", `Re-planning trajectory with new constraint envelope (operator reroute).`);
+      task.state = "running";
+      robot.status = "manipulating";
+    } else {
+      this.sub.get(sub.id).gateResolved = true;
+      this.log("SAFETY", "ok", `Override accepted. Releasing trajectory to System 0 (M-HAL).`);
+      task.state = "running";
+      robot.status = "manipulating";
+    }
+    this.emit();
+  }
+  togglePause() {
+    this.paused = !this.paused;
+    this.log("OP", "info", this.paused ? "Global execution paused." : "Global execution resumed.");
+    this.emit();
+  }
+  /** Force the next gated manipulation to raise the Safety/HITL gate (demos). */
+  forceSafety() {
+    this.forceSafetyNext = true;
+  }
+  reset() {
+    const w = buildWorld();
+    this.shelves = w.shelves;
+    this.items = w.items;
+    this.robots = buildFleet();
+    this.tasks = [];
+    this.logs = [];
+    this.safety = null;
+    this.sub.clear();
+    this.settlements = 0;
+    this.dataAggregated = 0;
+    this.clock = 0;
+    this.modelSeq = 1;
+    this.robotSeq = 5;
+    this.models = this.seedModels();
+    this.fleetGeneration++;
+    this.log("S3", "info", "Runtime reset. Fleet re-enrolled, factory models redeployed.");
+    this.emit();
+  }
+  // ── Neural Model Foundry (System 3 trains global models) ───────────────────
+  /** Kick off a training run; fits a new model on the aggregated edge experience.
+   *  When `external`, a real training job (LeRobot/GPU) drives the loss curve and
+   *  the engine's internal simulator leaves this model alone. */
+  createModel(kind, name, embodiment, external = false) {
+    const dataset = Math.max(200, this.dataAggregated);
+    const dataFactor = Math.min(1, dataset / 3200);
+    const quality = Math.min(0.98, 0.5 + dataFactor * 0.38 + Math.random() * 0.08);
+    const version = this.models.filter((m) => m.kind === kind).length + 1;
+    const model = {
+      id: `M${this.modelSeq++}`,
+      name: name.trim() || `${kind}-v${version}`,
+      kind,
+      version,
+      embodiment: embodiment || "universal",
+      status: "training",
+      quality,
+      trainProgress: 0,
+      epoch: 0,
+      totalEpochs: TRAIN_EPOCHS,
+      loss: 2.6,
+      targetLoss: 0.02 + (1 - quality) * 0.55,
+      lossHistory: [2.6],
+      datasetMB: dataset,
+      createdAt: this.clock,
+      external
+    };
+    this.models.unshift(model);
+    this.log(
+      "S3",
+      "act",
+      external ? `Training ${model.name} v${version} (${kind.toUpperCase()}) on a real dataset via external job\u2026` : `Training ${model.name} v${version} (${kind.toUpperCase()}) on ${(dataset / 1024).toFixed(2)} GB edge experience\u2026`
+    );
+    this.emit();
+    return model;
+  }
+  /** External training job → push a real training step (loss) into a model. */
+  setModelTrainingProgress(id, progress, loss, step) {
+    const m = this.models.find((x) => x.id === id);
+    if (!m) return;
+    m.trainProgress = Math.min(1, Math.max(0, progress));
+    m.loss = loss;
+    m.epoch = step ?? Math.floor(m.trainProgress * m.totalEpochs);
+    m.lossHistory.push(loss);
+    if (m.lossHistory.length > 60) m.lossHistory.splice(0, m.lossHistory.length - 60);
+    this.emit();
+  }
+  /** External training job → finished. Record real final quality/loss. */
+  completeModelTraining(id, quality, loss) {
+    const m = this.models.find((x) => x.id === id);
+    if (!m || m.status !== "training") return;
+    m.trainProgress = 1;
+    m.status = "ready";
+    m.quality = Math.min(0.99, Math.max(0, quality));
+    if (loss !== void 0) {
+      m.loss = loss;
+      m.targetLoss = loss;
+      m.lossHistory.push(loss);
+    }
+    this.log("S3", "ok", `${m.name} v${m.version} trained on real data \u2014 final loss ${m.loss.toFixed(3)}, quality ${m.quality * 100 | 0}%. Ready to deploy.`);
+    this.emit();
+  }
+  /** Promote a ready model to live; demote the previously-deployed peer. */
+  deployModel(id) {
+    const model = this.models.find((m) => m.id === id);
+    if (!model || model.status === "training") return;
+    for (const m of this.models) {
+      if (m.kind === model.kind && m.status === "deployed") m.status = "ready";
+    }
+    model.status = "deployed";
+    this.log("S3", "ok", `Rollout: ${model.name} v${model.version} now live on ${model.kind.toUpperCase()} (quality ${model.quality * 100 | 0}%). Global model pushed to fleet.`);
+    this.emit();
+  }
+  /** Enroll a new hardware embodiment; the M-HAL adapts its universal prior. */
+  enrollEmbodiment(spec) {
+    const idx = this.robots.length;
+    const robot = {
+      id: `rb-${String(this.robotSeq).padStart(2, "0")}`,
+      name: spec.name.trim() || `Unit-${this.robotSeq}`,
+      chassis: spec.chassis,
+      bus: spec.bus,
+      pos: { x: 4, y: 6 + idx * 11 % 50 },
+      heading: 0,
+      battery: 88 + Math.random() * 10,
+      status: "idle",
+      joints: Array.from({ length: Math.max(2, Math.min(28, spec.joints)) }, () => 0.5),
+      torque: 0
+    };
+    this.robotSeq++;
+    this.robots.push(robot);
+    this.fleetGeneration++;
+    this.log("S3", "ok", `Embodiment "${robot.name}" enrolled \u2014 verifiable M2M identity issued. M-HAL adapting universal prior to ${robot.chassis} over ${robot.bus}.`);
+    this.emit();
+    return robot;
+  }
+  /** Deployed-model quality for a layer (falls back to factory baseline). */
+  q(kind) {
+    const m = this.models.find((x) => x.kind === kind && x.status === "deployed");
+    return m ? m.quality : BASELINE_Q;
+  }
+  // ── Kernel: QoS profile router ───────────────────────────────────────────────
+  /** Switch the active execution profile (Robustness / Optimisation / System-Critical). */
+  setProfile(profile) {
+    if (!PROFILE_META[profile] || this.profile === profile) return;
+    this.profile = profile;
+    const p = PROFILE_META[profile];
+    this.log(
+      "S3",
+      "act",
+      `Kernel profile \u2192 ${p.label}. Execution ${p.speed >= 1 ? "+" : ""}${Math.round((p.speed - 1) * 100)}% \xB7 Safety scrutiny \xD7${p.scrutiny.toFixed(2)}.`
+    );
+    this.emit();
+  }
+  /** Speed multiplier for the active profile. */
+  get profSpeed() {
+    return PROFILE_META[this.profile].speed;
+  }
+  /** Safety-Broker scrutiny multiplier for the active profile. */
+  get profScrutiny() {
+    return PROFILE_META[this.profile].scrutiny;
+  }
+  // ── persistence (Phase 1: server-side durable state) ───────────────────────
+  /** Serialize the durable display state (no transient runtime maps). */
+  exportState() {
+    return {
+      v: 1,
+      clock: this.clock,
+      robots: this.robots,
+      items: this.items,
+      tasks: this.tasks,
+      logs: this.logs,
+      models: this.models,
+      settlements: this.settlements,
+      dataAggregated: this.dataAggregated,
+      profile: this.profile,
+      seqs: {
+        logId: this.logId,
+        taskSeq: this.taskSeq,
+        safetyId: this.safetyId,
+        modelSeq: this.modelSeq,
+        robotSeq: this.robotSeq
+      }
+    };
+  }
+  /** Restore from a previously exported state (best-effort; rebuilds runtime). */
+  importState(s) {
+    if (!s || s.v !== 1) return;
+    this.clock = s.clock ?? 0;
+    if (s.robots?.length) this.robots = s.robots;
+    if (s.items?.length) this.items = s.items;
+    this.tasks = s.tasks ?? [];
+    this.logs = s.logs ?? [];
+    if (s.models?.length) this.models = s.models;
+    this.settlements = s.settlements ?? 0;
+    this.dataAggregated = s.dataAggregated ?? 0;
+    if (s.profile && PROFILE_META[s.profile]) this.profile = s.profile;
+    if (s.seqs) {
+      this.logId = s.seqs.logId;
+      this.taskSeq = s.seqs.taskSeq;
+      this.safetyId = s.seqs.safetyId;
+      this.modelSeq = s.seqs.modelSeq;
+      this.robotSeq = s.seqs.robotSeq;
+    }
+    this.sub.clear();
+    for (const t of this.tasks) {
+      for (const st2 of t.subtasks) if (st2.state === "active") this.sub.set(st2.id, {});
+    }
+    this.log("S3", "info", "State restored from durable store.");
+    this.emit();
+  }
+  // ── Phase 4: external robot control (ROS 2 via rosbridge) ───────────────────
+  /** Toggle whether an external robot owns pose integration. */
+  setExternalControl(on) {
+    if (this.externalControl === on) return;
+    this.externalControl = on;
+    this.log(
+      "S0",
+      on ? "ok" : "warn",
+      on ? "M-HAL bridged to external robot (ROS 2 / rosbridge). Pose now driven by hardware odometry." : "External robot link lost \u2014 reverting to internal kinematic model."
+    );
+    this.emit();
+  }
+  /** Inject a pose from external odometry (called by the rosbridge client). */
+  setRobotPose(id, x, y, heading) {
+    const r = this.robot(id);
+    if (!r) return;
+    r.pos = { x, y };
+    if (heading !== void 0) r.heading = heading;
+  }
+  // ── main tick ──────────────────────────────────────────────────────────────
+  tick(dtRaw) {
+    const dt = Math.min(dtRaw, 0.05);
+    if (this.paused) {
+      this.version++;
+      this.emit();
+      return;
+    }
+    this.trainModels(dt);
+    if (this.safety) {
+      this.version++;
+      this.emit();
+      return;
+    }
+    this.clock += dt;
+    this.version++;
+    for (const task of this.tasks) {
+      if (task.state !== "running") continue;
+      const robot = this.robot(task.robotId);
+      if (!robot) continue;
+      this.stepTask(task, robot, dt);
+    }
+    this.driveActuation(dt);
+    this.ambientLogs(dt);
+    this.batteries(dt);
+    this.emit();
+  }
+  /** Advance every in-flight *simulated* training run; finalize when it converges.
+   *  Externally-trained models are driven by the real job, not here. */
+  trainModels(dt) {
+    for (const m of this.models) {
+      if (m.status !== "training" || m.external) continue;
+      const before = m.trainProgress;
+      m.trainProgress = Math.min(1, m.trainProgress + dt / TRAIN_SECONDS);
+      m.epoch = Math.floor(m.trainProgress * m.totalEpochs);
+      const decayed = m.targetLoss + (2.6 - m.targetLoss) * Math.exp(-3.2 * m.trainProgress);
+      m.loss = Math.max(m.targetLoss, decayed + (Math.random() - 0.5) * 0.05);
+      if (Math.floor(m.trainProgress * 20) > Math.floor(before * 20)) {
+        m.lossHistory.push(m.loss);
+      }
+      if (m.trainProgress >= 1) {
+        m.status = "ready";
+        m.loss = m.targetLoss;
+        m.lossHistory.push(m.targetLoss);
+        this.log("S3", "ok", `${m.name} v${m.version} converged \u2014 loss ${m.targetLoss.toFixed(3)}, quality ${m.quality * 100 | 0}%. Ready to deploy.`);
+      }
+    }
+  }
+  // ── task execution state machine ───────────────────────────────────────────
+  stepTask(task, robot, dt) {
+    let active = task.subtasks.find((s) => s.state === "active");
+    if (!active) {
+      active = this.activateNext(task, robot);
+      if (!active) {
+        this.completeTask(task, robot);
+        return;
+      }
+    }
+    const rt = this.sub.get(active.id);
+    switch (active.kind) {
+      case "navigate": {
+        const wp = robot.waypoint;
+        if (!wp) {
+          active.progress = 1;
+          break;
+        }
+        const d = dist(robot.pos, wp);
+        rt.initialDist = rt.initialDist ?? Math.max(d, 1e-3);
+        active.progress = Math.min(1, 1 - d / rt.initialDist);
+        this.moveToward(robot, wp, dt);
+        if (d < 1.6) {
+          active.progress = 1;
+          robot.pos = { ...wp };
+        }
+        break;
+      }
+      case "perceive": {
+        robot.status = "scanning";
+        robot.scanCone = Math.min(1, (robot.scanCone ?? 0) + dt * 0.5 * (0.7 + this.q("vla") * 0.7));
+        active.progress = robot.scanCone;
+        if (task.targetItemId && robot.scanCone > 0.55) {
+          const it = this.items.find((i) => i.id === task.targetItemId);
+          if (it && !it.found) {
+            it.found = true;
+            this.log("S2", "ok", `Vision Agent: ${it.label} identified and flagged on the spatial map.`);
+          }
+        }
+        break;
+      }
+      case "map": {
+        active.progress = Math.min(1, active.progress + dt * 0.7 * (0.7 + this.q("vla") * 0.5));
+        break;
+      }
+      case "manipulate": {
+        robot.status = "manipulating";
+        const gated = /grasp|execute/i.test(active.label);
+        if (gated && !rt.gateResolved) {
+          this.runSafetyBroker(task, robot, active);
+          return;
+        }
+        active.progress = Math.min(1, active.progress + dt * 0.45 * (0.7 + this.q("act") * 0.8));
+        break;
+      }
+      case "settle": {
+        active.progress = Math.min(1, active.progress + dt * 0.9);
+        break;
+      }
+    }
+    if (active.progress >= 1 && active.state === "active") {
+      this.finishSubtask(task, robot, active);
+    }
+  }
+  activateNext(task, robot) {
+    const next = task.subtasks.find((s) => s.state === "queued");
+    if (!next) return void 0;
+    next.state = "active";
+    this.sub.set(next.id, {});
+    this.onEnterSubtask(task, robot, next);
+    return next;
+  }
+  onEnterSubtask(task, robot, sub) {
+    robot.scanCone = 0;
+    switch (sub.kind) {
+      case "navigate": {
+        robot.status = "navigating";
+        robot.waypoint = this.resolveWaypoint(task);
+        this.log("S2", "info", `Spatial Mapping Agent: Sense \u2192 Reason \u2192 Plan \xB7 ${sub.label}.`);
+        break;
+      }
+      case "perceive":
+        robot.status = "scanning";
+        this.log("S2", "info", `Vision Agent engaged: ${sub.label}.`);
+        break;
+      case "map":
+        this.log("S1", "info", `Spatial Mapping Agent: ${sub.label}.`);
+        break;
+      case "manipulate":
+        robot.status = "manipulating";
+        this.log("S1", "act", `Kinematic Agent: ${sub.label} \u2014 ACT generating action chunks.`);
+        break;
+      case "settle":
+        this.log("S3", "info", `Settlement Agent: ${sub.label}.`);
+        break;
+    }
+  }
+  finishSubtask(task, robot, sub) {
+    sub.state = "done";
+    sub.progress = 1;
+    if (sub.kind === "settle") {
+      this.settlements++;
+      this.dataAggregated += 40 + Math.random() * 120;
+      this.log("S3", "ok", `M2M settlement closed on Peaq network (#${this.settlements}). Edge experience aggregated to global model.`);
+    } else if (sub.kind === "perceive") {
+      this.log("S2", "ok", `${sub.label} complete.`);
+    } else {
+      this.log("S1", "ok", `${sub.label} complete.`);
+    }
+  }
+  completeTask(task, robot) {
+    task.state = "complete";
+    robot.status = "idle";
+    robot.taskId = void 0;
+    robot.waypoint = void 0;
+    robot.scanCone = 0;
+    this.log("S3", "ok", `${task.id} complete \u2014 ${robot.name} returned to standby.`);
+  }
+  // ── Safety Broker + Human-in-the-Loop gate (Section 4) ─────────────────────
+  runSafetyBroker(task, robot, sub) {
+    this.log("SAFETY", "info", `Validating trajectory for ${robot.name}: collision check + joint-limit constraints\u2026`);
+    const triggerP = Math.min(0.95, SAFETY_TRIGGER_P * (1 - this.q("mhal") * 0.7) * this.profScrutiny);
+    if (this.forceSafetyNext || Math.random() < triggerP) {
+      this.forceSafetyNext = false;
+      const scenario = this.pickAnomaly();
+      task.state = "paused";
+      robot.status = "paused";
+      sub.state = "blocked";
+      this.safety = {
+        id: this.safetyId++,
+        robotId: robot.id,
+        taskId: task.id,
+        subTaskId: sub.id,
+        kind: scenario.kind,
+        message: scenario.message,
+        options: scenario.options,
+        t: this.clock
+      };
+      this.log("SAFETY", "alert", `HALT \u2014 ${scenario.message}`);
+      this.log("HITL", "alert", `Escalated to Live Observation Deck. Operator decision required.`);
+    } else {
+      this.sub.get(sub.id).gateResolved = true;
+      this.log("SAFETY", "ok", `Trajectory cleared \u2014 collision-free, within physical limits. Releasing to System 0.`);
+    }
+  }
+  pickAnomaly() {
+    const pool = [
+      {
+        kind: "anomaly",
+        message: "Unidentified biological object blocking heavy payload. Reroute or abort?",
+        options: ["Authorize", "Reroute", "Abort"]
+      },
+      {
+        kind: "collision",
+        message: "Predicted gripper path intersects an unmapped obstacle within 4 cm. Override?",
+        options: ["Override", "Reroute", "Abort"]
+      },
+      {
+        kind: "constraint",
+        message: "Estimated payload exceeds rated wrist torque by 12%. Authorize high-stakes lift?",
+        options: ["Authorize", "Reroute", "Abort"]
+      }
+    ];
+    return pool[Math.floor(Math.random() * pool.length)];
+  }
+  // ── low-level actuation: System 1 → System 0 (M-HAL) ───────────────────────
+  driveActuation(dt) {
+    for (const r of this.robots) {
+      const busy = r.status === "navigating" || r.status === "scanning" || r.status === "manipulating";
+      const amp = r.status === "manipulating" ? 0.42 : busy ? 0.22 : 0.05;
+      const freq = r.status === "manipulating" ? 6.5 : 3;
+      for (let j = 0; j < r.joints.length; j++) {
+        r.joints[j] = 0.5 + amp * Math.sin(this.clock * freq + j * 0.9);
+      }
+      const targetTorque = busy ? 0.35 + amp + Math.random() * 0.15 : 0.02;
+      r.torque += (targetTorque - r.torque) * Math.min(1, dt * 6);
+    }
+  }
+  moveToward(robot, wp, dt) {
+    if (this.externalControl) return;
+    const d = dist(robot.pos, wp);
+    if (d < 0.01) return;
+    robot.heading = angle(robot.pos, wp);
+    const step = Math.min(d, MOVE_SPEED * dt * (0.6 + 0.4 * (robot.battery / 100)) * (0.75 + this.q("act") * 0.5) * this.profSpeed);
+    robot.pos = {
+      x: robot.pos.x + Math.cos(robot.heading) * step,
+      y: robot.pos.y + Math.sin(robot.heading) * step
+    };
+  }
+  resolveWaypoint(task) {
+    if (task.targetItemId) {
+      const it = this.items.find((i) => i.id === task.targetItemId);
+      if (it) return { x: it.pos.x - 4, y: it.pos.y };
+    }
+    if (task.targetAisle) {
+      const x = 14 + (task.targetAisle - 1) * 24;
+      return { x: x - 5, y: FLOOR.h / 2 };
+    }
+    return { x: FLOOR.w / 2, y: FLOOR.h / 2 };
+  }
+  // ── ambient telemetry, batteries, metrics ──────────────────────────────────
+  ambientLogs(dt) {
+    const active = this.robots.filter(
+      (r) => ["navigating", "scanning", "manipulating"].includes(r.status)
+    );
+    if (active.length === 0) return;
+    this.acc.s1 += dt;
+    this.acc.s0 += dt;
+    this.acc.s2 += dt;
+    if (this.acc.s1 > 0.8) {
+      this.acc.s1 = 0;
+      const r = active[Math.floor(Math.random() * active.length)];
+      this.log("S1", "info", `ACT \u2192 ${r.name}: action chunk of 40 joint targets streamed @ ~50 Hz.`);
+    }
+    if (this.acc.s0 > 1.2) {
+      this.acc.s0 = 0;
+      const r = active[Math.floor(Math.random() * active.length)];
+      this.log("S0", "info", `M-HAL \u2192 ${r.bus}: whole-body control @ 1000 Hz \xB7 \u03C4=${(r.torque * 14).toFixed(1)} N\xB7m.`);
+    }
+    if (this.acc.s2 > 2.6) {
+      this.acc.s2 = 0;
+      this.log("S2", "info", `VLA deliberating @ ~1 Hz \xB7 cognitive bandwidth ${this.metrics().cognitiveBandwidth * 100 | 0}%.`);
+    }
+  }
+  batteries(dt) {
+    const drain = dt * 0.22 * (1 - this.q("mhal") * 0.35);
+    for (const r of this.robots) {
+      const busy = r.status !== "idle" && r.status !== "charging";
+      if (busy) r.battery = Math.max(2, r.battery - drain);
+      else if (r.battery < 100) r.battery = Math.min(100, r.battery + dt * 0.4);
+    }
+  }
+  metrics() {
+    const running = this.tasks.filter((t) => t.state === "running" || t.state === "paused");
+    const load = running.length;
+    const cognitive = Math.min(1, 0.04 + load * 0.34 * (1 - this.q("vla") * 0.4) + (this.safety ? 0.1 : 0));
+    const j = (base, spread) => base + (Math.random() - 0.5) * spread;
+    const dep = (kind) => {
+      const m = this.models.find((x) => x.kind === kind && x.status === "deployed");
+      return m ? { name: m.name, version: m.version, quality: m.quality } : null;
+    };
+    return {
+      clock: this.clock,
+      cognitiveBandwidth: cognitive,
+      activeTasks: running.length,
+      fleetOnline: this.robots.length,
+      settlements: this.settlements,
+      dataAggregated: this.dataAggregated,
+      hz: {
+        S3: load || this.models.some((m) => m.status === "training") ? j(1.4, 0.6) : 0.2,
+        S2: load ? j(1, 0.2) : 0,
+        S1: load ? j(52, 18) : 0,
+        S0: load ? j(1e3, 22) : 0,
+        SAFETY: this.safety ? 0 : load ? j(20, 6) : 0,
+        HITL: this.safety ? 1 : 0
+      },
+      deployed: { vla: dep("vla"), act: dep("act"), mhal: dep("mhal") }
+    };
+  }
+  // ── helpers ────────────────────────────────────────────────────────────────
+  pickRobot() {
+    const idle = this.robots.filter((r) => !r.taskId && r.status === "idle");
+    if (idle.length) return idle[this.rr++ % idle.length];
+    const free = this.robots.filter((r) => !r.taskId);
+    return free[0];
+  }
+  robot(id) {
+    return this.robots.find((r) => r.id === id);
+  }
+  task(id) {
+    return this.tasks.find((t) => t.id === id);
+  }
+  log(system, level, text) {
+    this.logs.push({ id: this.logId++, t: this.clock, system, level, text });
+    if (this.logs.length > LOG_CAP) this.logs.splice(0, this.logs.length - LOG_CAP);
+  }
+};
+export {
+  PiOsEngine
+};