@melaya/runner 1.0.98 → 1.0.101

package/dist/assistantHost.py

@@ -72,6 +72,28 @@ def _memory_watermark(agent) -> int:
         return 0
 
 
+def _config_hash() -> str:
+    """PR4 config-drift: a stable hash over the config env that determines host
+    behaviour, canonicalized IDENTICALLY to the server (runnerNamespace.ts
+    _assistantConfigHash): pipe-delimited provider|model|language|connectors|
+    hitl|phoneReady, language default 'en', connectors lowercased+sorted,
+    phoneReady 1/0. Reported in `ready` so the server can detect env divergence."""
+    import hashlib
+    raw_conn = os.environ.get("MEL_ASSISTANT_CONNECTORS", "") or ""
+    connectors = ",".join(sorted(c.lower() for c in raw_conn.split(",") if c.strip()))
+    hitl = os.environ.get("MEL_ASSISTANT_HITL_MODE", "safe") or "safe"
+    if hitl not in ("safe", "autonomous", "payments_only"):
+        hitl = "safe"
+    phone = "1" if (os.environ.get("MEL_ASSISTANT_PHONE_READY", "") or "") else "0"
+    canon = "|".join([
+        os.environ.get("MEL_ASSISTANT_PROVIDER", "") or "",
+        os.environ.get("MEL_ASSISTANT_MODEL", "") or "",
+        os.environ.get("MEL_ASSISTANT_LANGUAGE", "en") or "en",
+        connectors, hitl, phone,
+    ])
+    return hashlib.sha256(canon.encode("utf-8")).hexdigest()[:32]
+
+
 def _render_summary_text(summary) -> str:
     """Render a server AssistantSummary ({facts, provenance}) to a data-only text
     block for the compressed-summary slot. Never policy — reference only."""
@@ -561,7 +583,7 @@ def main() -> int:
     except Exception:
         _log("compaction hooks unavailable (non-fatal)")
 
-    _emit("", "ready", memoryWatermark=_memory_watermark(agent), hostInstanceId=_HOST_ID, generation=_GENERATION)
+    _emit("", "ready", memoryWatermark=_memory_watermark(agent), hostInstanceId=_HOST_ID, generation=_GENERATION, configHash=_config_hash())
     _log("ready")
 
     q: "queue.Queue[str]" = queue.Queue()
@@ -592,7 +614,8 @@ def main() -> int:
                 gen = int(req.get("generation") or 0)
             except Exception:
                 gen = 0
-            if _GENERATION and gen and gen != _GENERATION:
+            # Strict: gen 0 is a real generation (pre-migration), not a wildcard.
+            if gen != _GENERATION:
                 _log(f"restore for stale generation {gen} (mine={_GENERATION}) — ignored")
                 continue
             mem = _agent_memory(agent)

package/dist/connection.js

@@ -885,10 +885,16 @@ export async function connect(opts) {
             return;
         const generation = Number(payload.generation ?? 0) || 0;
         const emitEv = (ev) => socket.emit("runner:assistant_event", { sessionId: sid, turnId: "", ...ev });
-        // A live host already exists — report ready (with its watermark so the server
-        // can decide whether to re-offer a rehydrate). No second spawn.
-        if (activeAssistants.has(sid)) {
-            emitEv({ kind: "ready" });
+        // A live host already exists — report ready WITH its last-known memory
+        // watermark so the server doesn't needlessly re-offer a rehydrate (a bare
+        // ready would read as watermark 0). No second spawn.
+        const live = activeAssistants.get(sid);
+        // Report the live host's ACTUAL boot generation (not just its watermark) so a
+        // server that restarted (its in-memory session map wiped) can DETECT a host
+        // that booted under an older generation and reboot it instead of serving the
+        // next turn from stale memory/config. A bare ready hid this.
+        if (live) {
+            emitEv({ kind: "ready", memoryWatermark: live.memoryWatermark || 0, generation: live.generation });
             return;
         }
         // A boot is already in flight for this sid (concurrent start / server restart
@@ -987,7 +993,7 @@ export async function connect(opts) {
                 ...(payload.credentials || {}),
             };
             const proc = spawn(envResult.pythonPath, ["-u", stagedHost], { cwd: workDir, env, stdio: ["pipe", "pipe", "pipe"] });
-            const session = { proc, lastActivity: Date.now(), stdoutBuf: "", generation };
+            const session = { proc, lastActivity: Date.now(), stdoutBuf: "", generation, memoryWatermark: 0 };
             activeAssistants.set(sid, session);
             console.log(chalk.hex("#7c6ff0")(`  ◆ Assistant session ${sid.slice(0, 10)}… (${payload.provider})`));
             proc.stdout?.on("data", (data) => {
@@ -999,7 +1005,13 @@ export async function connect(opts) {
                     const t = line.trim();
                     if (t.startsWith("MELASSIST ")) {
                         try {
-                            socket.emit("runner:assistant_event", { sessionId: sid, ...JSON.parse(t.slice("MELASSIST ".length)) });
+                            const parsed = JSON.parse(t.slice("MELASSIST ".length));
+                            // Track the host's latest memory watermark (ready / rehydrated
+                            // frames report it) so a re-`start` of the live host reports a
+                            // truthful watermark and the server skips a needless rehydrate.
+                            if (typeof parsed?.memoryWatermark === "number")
+                                session.memoryWatermark = parsed.memoryWatermark;
+                            socket.emit("runner:assistant_event", { sessionId: sid, ...parsed });
                         }
                         catch { /* skip malformed */ }
                     }
@@ -1046,10 +1058,11 @@ export async function connect(opts) {
         const s = activeAssistants.get(sid);
         if (!s)
             return;
-        // Bind to the boot generation — a frame for an older/newer generation than the
-        // live host is dropped (the host also re-checks).
+        // Bind to the boot generation — a frame whose generation differs from the
+        // live host's is dropped (the host also re-checks). Strict equality: gen 0 is
+        // a real generation (pre-migration conversations), not a wildcard.
         const gen = Number(payload.generation ?? 0) || 0;
-        if (gen && s.generation && gen !== s.generation)
+        if (gen !== s.generation)
             return;
         s.lastActivity = Date.now();
         try {
@@ -1071,6 +1084,15 @@ export async function connect(opts) {
             socket.emit("runner:assistant_event", { sessionId: payload.sessionId, turnId: payload.turnId, kind: "error", message: "session_not_found" });
             return;
         }
+        // Generation gate (defense-in-depth): refuse to serve a turn stamped with a
+        // generation that doesn't match this host's boot generation — the server has
+        // moved on (restart / takeover) and this host is stale. session_not_found
+        // triggers the server's clean re-boot path. Backward-compatible: a turn with
+        // no generation (older server) is served as before.
+        if (payload.generation != null && Number(payload.generation) !== s.generation) {
+            socket.emit("runner:assistant_event", { sessionId: payload.sessionId, turnId: payload.turnId, kind: "error", message: "session_not_found" });
+            return;
+        }
         s.lastActivity = Date.now();
         // Per-turn hitl_mode: the host applies it to os.environ["MEL_ASSISTANT_HITL_MODE"]
         // (mirrored to MEL_HITL_MODE) BEFORE running the turn, so a mid-session flip

package/dist/modelLoader.js

@@ -378,6 +378,27 @@ export async function preflightOllama(modelName, onProgress = () => { }) {
             };
         }
         const profile = classifyModel(modelName);
+        // PR5: read the REAL trained context via /api/show and expose it as
+        // contextTokens (clamped to the operator cap, mirroring the Python
+        // detect_ollama_context). connection.ts forwards this as
+        // MEL_MODEL_CONTEXT_TOKENS so the TS profile matches the Python-detected
+        // window (the Python side self-detects too, so this is belt-and-suspenders).
+        try {
+            const cap = Number(process.env.MEL_OLLAMA_MAX_CTX || 16384) || 16384;
+            const show = await fetchWithTimeout(`${OLLAMA_BASE}/api/show`, {
+                timeoutMs: 3_000, method: "POST", body: JSON.stringify({ model: modelName }),
+                headers: { "content-type": "application/json" },
+            });
+            if (show.ok) {
+                const sj = await show.json();
+                const info = sj.model_info || {};
+                const key = Object.keys(info).find((k) => k.endsWith(".context_length"));
+                const trained = key ? Number(info[key]) : 0;
+                if (trained > 0)
+                    profile.contextTokens = Math.max(2048, Math.min(trained, cap));
+            }
+        }
+        catch { /* best-effort — Python self-detects if this is missing */ }
         if (profile.tier !== "agentic-capable") {
             onProgress(`⚠ ${modelName} classified ${profile.tier} (${profile.reason})`);
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@melaya/runner",
-  "version": "1.0.98",
+  "version": "1.0.101",
   "description": "Run Melaya AI pipelines locally with your own LM Studio or Ollama models",
   "license": "UNLICENSED",
   "private": false,