@smartmemory/compose 0.2.58-beta → 0.3.1-beta

package/server/lifecycle-guard.js

@@ -312,7 +312,7 @@ export async function ensureGuard(featureCode, currentPhase, workspaceRoot, mode
       workspaceRoot,
     });
   } catch (e) {
-    // A thrown spawn failure (e.g. stratum-mcp not installed) must NOT escape as
+    // A thrown Stratum CLI failure must NOT escape as
     // a generic 500/400 — normalise to a fail-closed error result.
     return { error: { code: 'GUARD_UNREACHABLE', message: e.message } };
   }

package/server/pipeline-routes.js

@@ -184,14 +184,23 @@ function flowNamesOf(parsed) {
  * src/lib/pipeline-model.js `denormalizeStep` (kept in sync; server cannot import
  * the frontend module). `id` leads; surfaced fields override `_extra` on clash.
  */
-function denormalizeModelStep(step) {
+// D2/D3: the physical instruction key is VERSION-derived — `do` for TS v1,
+// `intent` for v0.3 — never presence-derived. Mirrors src/lib/pipeline-model.js.
+function intentKeyForVersion(version) {
+  return version === 1 ? 'do' : 'intent';
+}
+
+function denormalizeModelStep(step, version) {
   const out = { id: step.id };
   if (step._extra && typeof step._extra === 'object') {
     for (const key of Object.keys(step._extra)) out[key] = step._extra[key];
   }
   if (step.agent !== undefined) out.agent = step.agent;
   if (step.function !== undefined) out.function = step.function;
-  if (step.intent !== undefined) out.intent = step.intent;
+  // C3/D2/D3: write the instruction to its physical field so a serialized v1 step
+  // never carries an undeclared `intent`. A NEW step (no `_intentKey`) defaults to
+  // the spec version's key, not `intent`.
+  if (step.intent !== undefined) out[step._intentKey || intentKeyForVersion(version)] = step.intent;
   if (step.inputs && Object.keys(step.inputs).length > 0) out.inputs = { ...step.inputs };
   if (step.output_contract !== undefined) out.output_contract = step.output_contract;
   if (Array.isArray(step.ensure) && step.ensure.length > 0) out.ensure = [...step.ensure];
@@ -210,6 +219,33 @@ function modelFlow(model, flowName) {
   return model.flows.find(f => f && f.name === flowName) || null;
 }
 
+/**
+ * F2: is this a GENUINE full-document (spec-wide) save? An omitted `flowName` is
+ * NOT sufficient — a partial model (e.g. `{flows:[oneFlow]}`) with no flowName would
+ * otherwise perform a one-flow write through the hash-OPTIONAL spec-wide branch,
+ * bypassing E1's staleness guard. A true spec-wide save carries the authoritative
+ * full document (`model._doc`) AND covers EVERY flow present on disk (flows with a
+ * steps[] array, plus a workflow.steps single flow). Anything missing a disk flow
+ * is a flow-scoped write in disguise → classified flow-scoped (baseHash required).
+ */
+function coversFullDocument(model, diskParsed) {
+  if (!model || !model._doc || typeof model._doc !== 'object') return false;
+  const diskFlowNames = new Set();
+  if (diskParsed && diskParsed.flows && typeof diskParsed.flows === 'object') {
+    for (const n of Object.keys(diskParsed.flows)) {
+      if (Array.isArray(diskParsed.flows[n]?.steps)) diskFlowNames.add(n);
+    }
+  }
+  if (Array.isArray(diskParsed?.workflow?.steps)) {
+    diskFlowNames.add(diskParsed.workflow.name || 'workflow');
+  }
+  const modelFlowNames = new Set((model.flows || []).map(f => f && f.name).filter(Boolean));
+  for (const n of diskFlowNames) {
+    if (!modelFlowNames.has(n)) return false;
+  }
+  return true;
+}
+
 // The reserved built-in contract — never written as a user contract (mirrors
 // src/lib/pipeline-model.js serializeContracts; server can't import the FE module).
 const RESERVED_CONTRACT = 'TaskGraph';
@@ -470,14 +506,32 @@ function surfacedValue(step, key) {
  */
 function mergeStepNode(doc, mapNode, step, specWide = false) {
   const extra = (step._extra && typeof step._extra === 'object') ? step._extra : {};
+  // C3/D2: the surfaced `intent` is written to its PHYSICAL field — `do` for TS v1,
+  // `intent` for v0.3. Prefer the model's remembered key; fall back to the spec
+  // VERSION (never the disk node's presence — a v1 step carrying both fields must
+  // resolve to `do`, and the stray `intent` is cleaned up below).
+  const intentKey = step._intentKey || (intentKeyForVersion(doc.get('version')));
   if (!specWide) {
-    // Additive: add only missing keys.
+    // D4: DIFF-DRIVEN, and NEVER delete. A key absent from an incomplete client
+    // _extra is preserved (finding 2); a key PRESENT and CHANGED is written back —
+    // whatever it is. This persists every field a renameStep rewrote (C4: after[],
+    // nested gate routes, AND `when`/`set`/fanout.over/with templates) without an
+    // allowlist, so new template-bearing fields are future-proofed. Unchanged keys
+    // are left untouched, preserving their comments.
     for (const k of Object.keys(extra)) {
-      if (!mapNode.has(k)) mapNode.set(k, doc.createNode(extra[k]));
+      if (!mapNode.has(k)) {
+        mapNode.set(k, doc.createNode(extra[k]));
+      } else {
+        const diskNode = mapNode.get(k, true);
+        const diskJs = diskNode && typeof diskNode.toJSON === 'function' ? diskNode.toJSON() : mapNode.get(k);
+        if (!deepEqual(diskJs, extra[k])) mapNode.set(k, doc.createNode(extra[k]));
+      }
     }
   } else {
-    // Full reconcile of unsurfaced fields.
-    const surfacedSet = new Set(['id', ...SURFACED_STEP_KEYS]);
+    // Full reconcile of unsurfaced fields. The physical intent key is surfaced
+    // (below), so it must be treated as surfaced here too — never deleted as an
+    // unknown extra.
+    const surfacedSet = new Set(['id', ...SURFACED_STEP_KEYS, intentKey]);
     // Add / update changed extra keys (skip unchanged to preserve their comments).
     for (const k of Object.keys(extra)) {
       if (!mapNode.has(k)) {
@@ -500,8 +554,15 @@ function mergeStepNode(doc, mapNode, step, specWide = false) {
   if (mapNode.get('id') !== step.id) mapNode.set('id', step.id);
   for (const key of SURFACED_STEP_KEYS) {
     const { present, value } = surfacedValue(step, key);
-    if (present) mapNode.set(key, doc.createNode(value));
-    else if (mapNode.has(key)) mapNode.delete(key);
+    // C3: the `intent` surfaced key maps to its physical field (`do`/`intent`).
+    const diskKey = key === 'intent' ? intentKey : key;
+    if (present) mapNode.set(diskKey, doc.createNode(value));
+    else if (mapNode.has(diskKey)) mapNode.delete(diskKey);
+    // Never leave the stale sibling — e.g. a python-era `intent` on a v1 step.
+    if (key === 'intent') {
+      const stray = intentKey === 'do' ? 'intent' : 'do';
+      if (mapNode.has(stray)) mapNode.delete(stray);
+    }
   }
   return mapNode;
 }
@@ -804,18 +865,6 @@ export function attachPipelineRoutes(app, { broadcastMessage, scheduleBroadcast,
       return res.status(400).json({ error: 'model with flows[] is required' });
     }
 
-    // Determine which flows to write back. If flowName is given, write only that
-    // flow (the editor edits one flow at a time); otherwise write every flow the
-    // model carries that exists in the document.
-    const flowsToWrite = flowName
-      ? [flowName]
-      : model.flows.map(f => f && f.name).filter(Boolean);
-
-    // A SPEC-WIDE save (flowName omitted) treats model._doc as the authoritative
-    // full document: reconcilers update AND delete, not just add. The flow-scoped
-    // path (flowName given) stays additive and never touches other flows/blocks.
-    const specWide = !flowName;
-
     let doc;
     let diskParsed;
     let diskText;
@@ -825,10 +874,24 @@ export function attachPipelineRoutes(app, { broadcastMessage, scheduleBroadcast,
       return res.status(400).json({ error: `Cannot read current spec: ${e.message}` });
     }
 
-    // COMP-PIPE-EDIT-6 conflict detection: if the client sent a baseHash and the
-    // freshly-read disk text no longer matches it, the file diverged since load
-    // (another writer / external edit). Refuse to write (409) unless force:true.
-    if (baseHash && !force) {
+    // Conflict detection (COMP-PIPE-EDIT-6 + E1/G1). ANY save of an existing file
+    // resubmits a model derived from a snapshot of disk; a stale editor (loaded old,
+    // another writer saved new, this client resubmits its stale value) would SILENTLY
+    // resurrect the old value on merge. G1: proving "full-document-ness" from request
+    // shape is spoofable (an empty `_doc` + stub flow bodies covering every disk flow
+    // NAME would slip through a hash-optional spec-wide branch and destructively
+    // delete real steps), so the guard NO LONGER keys on classification: a baseHash
+    // is REQUIRED on EVERY save of an existing file — spec-wide and flow-scoped alike.
+    // Missing → 400, stale → 409. F1: ONLY strict `force === true` bypasses — a
+    // truthy-but-non-boolean `force` ("false", 1, {}) must NOT authorize the bypass.
+    // G3: this check runs on the RAW disk bytes BEFORE parsing, so a stale baseHash
+    // is a 409 even when the on-disk YAML is malformed (parse-independent semantics).
+    if (force !== true) {
+      if (typeof baseHash !== 'string' || baseHash.length === 0) {
+        return res.status(400).json({
+          error: 'baseHash is required to save an existing spec (reload the spec, or pass force:true to override)',
+        });
+      }
       const currentHash = sha256(diskText);
       if (currentHash !== baseHash) {
         return res.status(409).json({
@@ -846,6 +909,22 @@ export function attachPipelineRoutes(app, { broadcastMessage, scheduleBroadcast,
       return res.status(400).json({ error: `Failed to parse current spec: ${e.message}` });
     }
 
+    // A SPEC-WIDE save treats model._doc as the authoritative full document:
+    // reconcilers update AND delete, not just add. The flow-scoped path stays
+    // additive and never touches other flows/blocks. This classification now drives
+    // MERGE BEHAVIOR ONLY (full replace vs additive) — it never relaxes the baseHash
+    // guard above (G1). An omitted `flowName` alone does NOT make a save spec-wide:
+    // the model must genuinely cover the full document (model._doc + every disk flow),
+    // else a partial model writes additively as a flow-scoped save.
+    const specWide = !flowName && coversFullDocument(model, diskParsed);
+
+    // Determine which flows to write back. If flowName is given, write only that
+    // flow (the editor edits one flow at a time); otherwise write every flow the
+    // model carries that exists in the document.
+    const flowsToWrite = flowName
+      ? [flowName]
+      : model.flows.map(f => f && f.name).filter(Boolean);
+
     for (const name of flowsToWrite) {
       const flow = modelFlow(model, name);
       if (!flow) {
@@ -868,10 +947,13 @@ export function attachPipelineRoutes(app, { broadcastMessage, scheduleBroadcast,
         // COMP-PIPE-EDIT-5: the flow is not on disk yet (e.g. a just-collapsed
         // sub-flow that exists only in the model). CREATE the flows.<name> node —
         // steps + input + output from model._doc.flows — rather than erroring.
-        // ONLY on a SPEC-WIDE save (flowName omitted): an explicit flowName that
-        // doesn't map to a steps location is still a 400 (never auto-create a
-        // flow the caller named by mistake / clobber a workflow.steps spec).
-        const created = !flowName && createNewFlowNode(doc, model, name);
+        // ONLY on a genuine SPEC-WIDE save: G2 — gate on the computed `specWide`
+        // classification, not a bare `!flowName`. A flow-scoped-classified request
+        // (no flowName but a partial model that does NOT cover the full document)
+        // must NOT perform this documented spec-wide-only flow creation; an explicit
+        // flowName that doesn't map to a steps location is likewise a 400 (never
+        // auto-create a flow the caller named by mistake / clobber a workflow.steps).
+        const created = specWide && createNewFlowNode(doc, model, name);
         if (!created) {
           return res.status(400).json({ error: `Flow "${name}" has no steps location in the spec` });
         }
@@ -902,7 +984,7 @@ export function attachPipelineRoutes(app, { broadcastMessage, scheduleBroadcast,
         }
         return existing
           ? mergeStepNode(doc, existing, step, specWide)
-          : doc.createNode(denormalizeModelStep(step));
+          : doc.createNode(denormalizeModelStep(step, doc.get('version')));
       });
     }
 
@@ -1041,7 +1123,7 @@ function buildSpecObjectFromModel(model) {
   if (Array.isArray(doc?.workflow?.steps)) {
     const wfName = doc.workflow.name || 'workflow';
     const flow = byName.get(wfName);
-    if (flow) out.workflow = { ...doc.workflow, steps: (flow.steps || []).map(denormalizeModelStep) };
+    if (flow) out.workflow = { ...doc.workflow, steps: (flow.steps || []).map(s => denormalizeModelStep(s, doc.version)) };
   }
 
   if (doc?.flows && typeof doc.flows === 'object') {
@@ -1049,7 +1131,7 @@ function buildSpecObjectFromModel(model) {
     for (const name of Object.keys(doc.flows)) {
       const flow = byName.get(name);
       out.flows[name] = flow
-        ? { ...doc.flows[name], steps: (flow.steps || []).map(denormalizeModelStep) }
+        ? { ...doc.flows[name], steps: (flow.steps || []).map(s => denormalizeModelStep(s, doc.version)) }
         : doc.flows[name];
     }
   }

package/server/stratum-client.js

@@ -1,9 +1,9 @@
 /**
- * stratum-client.js — Single adapter for all stratum-mcp subprocess calls.
+ * stratum-client.js — Single adapter for all Stratum TS CLI subprocess calls.
  *
- * This is the ONLY module in compose that spawns stratum-mcp processes.
+ * This is the ONLY module in compose that spawns Stratum CLI processes.
  * All query and mutation calls go through the exported functions below.
- * No other file may call execFile/spawn with 'stratum-mcp' as the command.
+ * No other file may spawn the Stratum CLI directly.
  *
  * Contract:
  *   - Query calls:   5s timeout, 1 retry on timeout, no retry on error
@@ -15,9 +15,8 @@
  */
 
 import { execFile as _execFileDefault } from 'node:child_process';
-import { loadProjectConfig } from './project-root.js';
-
-const STRATUM_BIN = 'stratum-mcp';
+import { getTargetRoot } from './project-root.js';
+import { resolveStratumBin, resolveStratumEngine as resolveEngine } from '../lib/stratum-engine.js';
 
 // Injected executor — replaced by tests only. Production code never calls this setter.
 let _execFile = _execFileDefault;
@@ -28,31 +27,21 @@ const MUTATION_TIMEOUT_MS = 10_000;
 // ---------------------------------------------------------------------------
 // Engine selection (COMP-STRATUM-TS)
 //
-// The flow/gate seam is engine-selectable: Python `stratum-mcp` (default) or
-// the TS engine's `stratum` CLI, which emits the same JSON projections and
-// exit codes. Guard calls are PINNED to Python — STRAT-GUARD is not part of
-// the TS port. Resolution order: COMPOSE_STRATUM_ENGINE env override, then
-// capabilities.stratumEngine in .compose/compose.json, then "python".
-// Unknown values fail loudly; never a silent fallback.
+// All flow, gate, and guard calls use the TS CLI. The shared resolver still
+// reads the environment/project capability so a retired Python selection fails
+// loudly before any subprocess is spawned.
 // ---------------------------------------------------------------------------
 
-/** @returns {'python'|'ts'} */
+/** @returns {'ts'} */
 export function resolveStratumEngine() {
-  let value = process.env.COMPOSE_STRATUM_ENGINE;
-  if (value === undefined || value === '') {
-    try { value = loadProjectConfig()?.capabilities?.stratumEngine; } catch { value = undefined; }
-  }
-  if (value === undefined || value === '') return 'python';
-  if (value !== 'python' && value !== 'ts') {
-    throw new Error(`stratumEngine must be "python" or "ts", got ${JSON.stringify(value)}`);
-  }
-  return value;
+  return resolveEngine(getTargetRoot());
 }
 
 /** Binary for flow/gate query+mutation calls under the selected engine. */
 function flowGateBin() {
-  if (resolveStratumEngine() === 'ts') return process.env.COMPOSE_STRATUM_TS_BIN || 'stratum';
-  return STRATUM_BIN;
+  const cwd = getTargetRoot();
+  resolveEngine(cwd);
+  return resolveStratumBin('cli', cwd);
 }
 
 // ---------------------------------------------------------------------------
@@ -65,10 +54,10 @@ function flowGateBin() {
  *
  * @param {string[]} args
  * @param {number}   timeoutMs
- * @param {string}   [bin] — defaults to the Python stratum-mcp binary
+ * @param {string}   [bin] — explicit binary selected by the calling seam
  * @returns {Promise<{ stdout: string, stderr: string, code: number }>}
  */
-function spawnStratum(args, timeoutMs, bin = STRATUM_BIN) {
+function spawnStratum(args, timeoutMs, bin) {
   return new Promise((resolve) => {
     const proc = _execFile(bin, args, { timeout: timeoutMs }, (err, out, err2) => {
       resolve(_spawnResult(bin, err, out, err2));
@@ -110,9 +99,7 @@ function _spawnResult(bin, err, out, err2) {
 
 /** Binary-specific spawn-failure message with the install/path remedy. */
 function _spawnRemedy(bin, code) {
-  return bin === STRATUM_BIN
-    ? `stratum-mcp failed to spawn (${code}). Install with: pip install stratum-mcp`
-    : `${bin} (TS stratum engine) failed to spawn (${code}). Install @smartmemory/stratum or set COMPOSE_STRATUM_TS_BIN`;
+  return `${bin} (TS stratum engine) failed to spawn (${code}). Install @smartmemory/stratum or set COMPOSE_STRATUM_TS_CLI_BIN`;
 }
 
 /**
@@ -128,7 +115,7 @@ async function runQuery(args) {
     // Retry once on timeout
     result = await spawnStratum(args, QUERY_TIMEOUT_MS, bin);
     if (result.code === -1) {
-      return { error: { code: 'TIMEOUT', message: 'stratum-mcp query timed out', detail: '' } };
+      return { error: { code: 'TIMEOUT', message: 'Stratum query timed out', detail: '' } };
     }
   }
 
@@ -142,14 +129,14 @@ async function runQuery(args) {
     try {
       return JSON.parse(result.stdout);
     } catch {
-      return { error: { code: 'UNKNOWN', message: 'stratum-mcp query failed', detail: '' } };
+      return { error: { code: 'UNKNOWN', message: 'Stratum query failed', detail: '' } };
     }
   }
 
   try {
     return JSON.parse(result.stdout);
   } catch {
-    return { error: { code: 'PARSE_ERROR', message: 'stratum-mcp returned invalid JSON', detail: '' } };
+    return { error: { code: 'PARSE_ERROR', message: 'Stratum returned invalid JSON', detail: '' } };
   }
 }
 
@@ -162,7 +149,7 @@ async function runMutation(args) {
   const result = await spawnStratum(args, MUTATION_TIMEOUT_MS, flowGateBin());
 
   if (result.code === -1) {
-    return { error: { code: 'TIMEOUT', message: 'stratum-mcp gate timed out', detail: '' } };
+    return { error: { code: 'TIMEOUT', message: 'Stratum gate timed out', detail: '' } };
   }
 
   if (result.code === -2) {
@@ -183,36 +170,35 @@ async function runMutation(args) {
     try {
       return JSON.parse(result.stdout);
     } catch {
-      return { error: { code: 'UNKNOWN', message: 'stratum-mcp gate failed', detail: '' } };
+      return { error: { code: 'UNKNOWN', message: 'Stratum gate failed', detail: '' } };
     }
   }
 
   try {
     return JSON.parse(result.stdout);
   } catch {
-    return { error: { code: 'PARSE_ERROR', message: 'stratum-mcp returned invalid JSON', detail: '' } };
+    return { error: { code: 'PARSE_ERROR', message: 'Stratum returned invalid JSON', detail: '' } };
   }
 }
 
 /**
- * Spawn stratum-mcp with args and pipe `inputJson` (a string) on stdin.
+ * Spawn the TS Stratum CLI with args and pipe `inputJson` on stdin.
  * Used by the STRAT-GUARD adapter, whose CLI reads one JSON kwargs object from
- * stdin. Same resolve contract as spawnStratum. PINNED to the Python binary —
- * STRAT-GUARD is not part of the TS port and ignores the engine flag.
+ * stdin. Same resolve contract as spawnStratum.
  *
  * @param {string[]} args
  * @param {string}   inputJson
  * @param {number}   timeoutMs
  * @returns {Promise<{ stdout: string, stderr: string, code: number }>}
  */
-function spawnStratumStdin(args, inputJson, timeoutMs) {
+function spawnStratumStdin(args, inputJson, timeoutMs, bin) {
   return new Promise((resolve) => {
-    const proc = _execFile(STRATUM_BIN, args, { timeout: timeoutMs }, (err, out, err2) => {
-      resolve(_spawnResult(STRATUM_BIN, err, out, err2));
+    const proc = _execFile(bin, args, { timeout: timeoutMs }, (err, out, err2) => {
+      resolve(_spawnResult(bin, err, out, err2));
     });
     // Same both-paths-settle-identically contract as spawnStratum.
     proc.on('error', (err) => {
-      resolve(_spawnResult(STRATUM_BIN, err ?? new Error('child process error'), '', ''));
+      resolve(_spawnResult(bin, err ?? new Error('child process error'), '', ''));
     });
 
     // Feed the JSON kwargs on stdin. The test mock supplies a fake stdin; a
@@ -234,10 +220,10 @@ function spawnStratumStdin(args, inputJson, timeoutMs) {
  * @returns {Promise<any>} parsed JSON result or { error }
  */
 async function runGuard(action, kwargs, timeoutMs = MUTATION_TIMEOUT_MS) {
-  const result = await spawnStratumStdin(['guard', action], JSON.stringify(kwargs), timeoutMs);
+  const result = await spawnStratumStdin(['guard', action], JSON.stringify(kwargs), timeoutMs, flowGateBin());
 
   if (result.code === -1) {
-    return { error: { code: 'TIMEOUT', message: 'stratum-mcp guard timed out', detail: '' } };
+    return { error: { code: 'TIMEOUT', message: 'Stratum guard timed out', detail: '' } };
   }
   if (result.code === -2) {
     console.error('[stratum-client] guard spawn failure:', result.stderr);
@@ -248,13 +234,13 @@ async function runGuard(action, kwargs, timeoutMs = MUTATION_TIMEOUT_MS) {
     try {
       return JSON.parse(result.stdout);   // canonical { status:"error", ... }
     } catch {
-      return { error: { code: 'UNKNOWN', message: 'stratum-mcp guard failed', detail: '' } };
+      return { error: { code: 'UNKNOWN', message: 'Stratum guard failed', detail: '' } };
     }
   }
   try {
     return JSON.parse(result.stdout);
   } catch {
-    return { error: { code: 'PARSE_ERROR', message: 'stratum-mcp returned invalid JSON', detail: '' } };
+    return { error: { code: 'PARSE_ERROR', message: 'Stratum returned invalid JSON', detail: '' } };
   }
 }
 
@@ -334,7 +320,7 @@ export async function gateRevise(flowId, stepId, note = '', resolvedBy = 'human'
 //
 // Reaches stratum's guarded-transition primitive over the same CLI-subprocess
 // seam. Each function translates camelCase params into the snake_case JSON
-// kwargs the `stratum-mcp guard <action>` CLI forwards verbatim to the guard
+// kwargs the `stratum guard <action>` CLI forwards verbatim to the guard
 // library, and pipes them on stdin.
 // ---------------------------------------------------------------------------
 

package/server/stratum-sync.js

@@ -4,8 +4,7 @@
  * Polls stratum flow state via stratum-client (not direct file reads) and syncs
  * into the vision store on a self-scheduling, sleep-aware loop.
  *
- * Sleep behavior: each poll cold-starts a `stratum-mcp` subprocess (Python
- * interpreter spin-up — the expensive part, not the query itself). Doing that
+ * Sleep behavior: each poll cold-starts the Stratum TS CLI. Doing that
  * every few seconds generated enough periodic activity to keep the host from
  * sleeping. Two mitigations:
  *   1. Cadence widened to 60s (override with COMPOSE_STRATUM_POLL_MS).
@@ -37,7 +36,7 @@ const WAKE_GAP_FACTOR = 1.5;
 /**
  * Sleep-aware poll gate: true only when some bound vision item could still
  * change state (i.e. is bound to a flow and not settled-`complete`). When this
- * is false the poller skips the stratum-mcp spawn so an idle host can sleep.
+ * is false the poller skips the CLI spawn so an idle host can sleep.
  *
  * A bound `complete` item is steady-state (status only advances to `complete`
  * via the audit route, never back), so polling it changes nothing. Anything
@@ -97,7 +96,7 @@ export class StratumSync {
   }
 
   /**
-   * One poll tick. Skips the stratum-mcp spawn when nothing is live (lets the
+   * One poll tick. Skips the Stratum CLI spawn when nothing is live (lets the
    * host sleep); on a tick that fired far later than scheduled, notes the
    * sleep gap before resyncing.
    */

package/server/vision-server.js

@@ -275,7 +275,7 @@ export class VisionServer {
       console.log('[vision] Stratum sync enabled');
     } else {
       app.use('/api/stratum', (_req, res) => {
-        res.status(503).json({ error: 'Stratum not enabled', hint: 'pip install stratum && compose init' });
+        res.status(503).json({ error: 'Stratum not enabled', hint: 'compose init (TS engine; python retired — see python-legacy branch)' });
       });
     }
 

package/dist/assets/channel-DiJkE9og.js

@@ -1 +0,0 @@
-import{ag as o,ah as n}from"./App-s4CulNkO.js";const t=(a,r)=>o.lang.round(n.parse(a)[r]);export{t as c};

package/dist/assets/classDiagram-OUVF2IWQ-DS76VBEL.js

@@ -1 +0,0 @@
-import{s as a,c as s,a as e,C as t}from"./chunk-V7JOEXUC-DUscIydR.js";import{_ as i}from"./App-s4CulNkO.js";import"./chunk-5VM5RSS4-DcTpMdJ4.js";import"./chunk-XXDRQBXY-DIH9i8mZ.js";import"./chunk-VR4S4FIN-C4UDHq_a.js";import"./chunk-32BRIVSS-DCHhvgFV.js";import"./mobile-PV1zQVwv.js";import"./index-CBWbmG7W.js";import"./graph--wGAvskB.js";var b={parser:e,get db(){return new t},renderer:s,styles:a,init:i(r=>{r.class||(r.class={}),r.class.arrowMarkerAbsolute=r.arrowMarkerAbsolute},"init")};export{b as diagram};

package/dist/assets/classDiagram-v2-EOCWNBFH-DS76VBEL.js

@@ -1 +0,0 @@
-import{s as a,c as s,a as e,C as t}from"./chunk-V7JOEXUC-DUscIydR.js";import{_ as i}from"./App-s4CulNkO.js";import"./chunk-5VM5RSS4-DcTpMdJ4.js";import"./chunk-XXDRQBXY-DIH9i8mZ.js";import"./chunk-VR4S4FIN-C4UDHq_a.js";import"./chunk-32BRIVSS-DCHhvgFV.js";import"./mobile-PV1zQVwv.js";import"./index-CBWbmG7W.js";import"./graph--wGAvskB.js";var b={parser:e,get db(){return new t},renderer:s,styles:a,init:i(r=>{r.class||(r.class={}),r.class.arrowMarkerAbsolute=r.arrowMarkerAbsolute},"init")};export{b as diagram};