@nodii/dev 0.6.45 → 0.6.46

package/README.md

@@ -427,6 +427,10 @@ without ending their run, `/tmp/cc-socks/<pid>.sock` sockets whose process is
 gone, and watched worktrees whose HEAD has commits absent from its configured
 remote branch. Each observation is posted to the watched run by the machine
 coordinator; `process_dead` transitions it to explicit `orphan` immediately.
+Every watched run whose PID is alive (or whose lane supervisor is, between
+same-session continuations) is reported as `process_alive`. Dev counts that as
+the run's liveness (hub-58, AH-4), so a late heartbeat never makes a working
+run quiet or orphaned.
 A sweep leaves a dead lane runtime alone while its lane supervisor still lives
 (the supervisor reports the exit itself) and skips it once the supervisor has
 reported.
@@ -962,7 +966,10 @@ and permission mode, and sends `Lane KEY: done check not recorded. Continue the
 Task: STEP.` on stdin. It does this up to `NODII_DEV_LANE_CONTINUATIONS` times
 (default 3; 0 turns it off). Each continuation is a run heartbeat, and
 `process.pid` and the watchdog record follow the new PID. A killed runtime
-(a signal) is never continued. After the last continuation, the exit is
+(a signal) is never continued. While the runtime lives, continuations
+included, the supervisor heartbeats its run every
+`NODII_DEV_RUN_HEARTBEAT_SECONDS` (60) as the lane identity that owns it;
+nothing else heartbeats a launched lane's run. After the last continuation, the exit is
 reported as above and its reason counts the continuations. A supervisor runs
 the CLI version that started it, so a fix to this rule reaches a lane only
 when it is launched or resumed on that version.

package/dist/core.js

@@ -4,7 +4,7 @@ import { chmod, mkdir, readFile, rm, writeFile } from "node:fs/promises";
 import { homedir, platform } from "node:os";
 import { dirname, join } from "node:path";
 
-export const VERSION = "0.6.45";
+export const VERSION = "0.6.46";
 export const configPath = () =>
   process.env.NODII_DEV_CONFIG_PATH ??
   join(homedir(), ".config/nodii-dev/config.json");

package/dist/doctor.js

@@ -5,7 +5,7 @@ import { devRequest, encode, isOAuthConfig, query, setAuthProvider } from "./cor
 import { OAuthAuthProvider, decodeClaims, loadRefreshToken } from "./oauth.js";
 import { inferGitContext, repoName } from "./lanes.js";
 import { figmaFileKey, figmaLockCheck, holdsSet, notRegisteredHint, scopeText } from "./figma.js";
-import { PICKER_MODEL, PICKER_MODEL_DIGEST, inspectOllama } from "./gather.js";
+import { PICKER_MODEL, PICKER_MODEL_DIGEST, STALE_PIN_HINT, inspectOllama } from "./gather.js";
 import { hookDiagnostics } from "./hook-doctor.js";
 
 /**
@@ -274,7 +274,7 @@ export async function doctorCommand(deps = {}) {
         model: PICKER_MODEL, digest: picker.digest ?? null, size: picker.size ?? null,
       }));
     else if (!picker.modelInstalled) checks.push(missing("picker_model", `${PICKER_MODEL} is not installed`, "nodii-dev setup --yes", { model: PICKER_MODEL }));
-    else checks.push(missing("picker_model", `${PICKER_MODEL} digest is ${picker.digest ?? "unknown"}; required ${PICKER_MODEL_DIGEST}`, "nodii-dev setup --yes", { model: PICKER_MODEL, digest: picker.digest ?? null, requiredDigest: PICKER_MODEL_DIGEST }));
+    else checks.push(missing("picker_model", `${PICKER_MODEL} digest is ${picker.digest ?? "unknown"}; this CLI pins ${PICKER_MODEL_DIGEST}; ${STALE_PIN_HINT}`, "nodii-dev setup --yes", { model: PICKER_MODEL, digest: picker.digest ?? null, requiredDigest: PICKER_MODEL_DIGEST }));
   } catch (error) {
     checks.push(missing("ollama", error?.message ?? "Ollama is unavailable", "nodii-dev setup --yes", { code: error?.code ?? null }));
     checks.push(cannot("picker_model", `needs local Ollama; expected ${PICKER_MODEL}`, { model: PICKER_MODEL }));

package/dist/gather.js

@@ -9,7 +9,11 @@ import { CliError } from "./core.js";
 const execFileAsync = promisify(execFile);
 
 export const PICKER_MODEL = "gemma4:12b";
-export const PICKER_MODEL_DIGEST = "sha256:6114515d63c17436a7c0417d82820ac65ad643e2806c5a3c89cb62846436ed0b";
+// The build the Ollama registry serves to Ollama on Apple silicon: an MLX nvfp4
+// build. The registry chooses the manifest by User-Agent, so `ollama pull` on an
+// M-series Mac lands this digest, not the GGUF one other clients see (hub-58
+// re-pin, NODII-DEV-CLI-11). This build has no structured output (pickDocuments).
+export const PICKER_MODEL_DIGEST = "sha256:c7597fc90b86aff6965317f37dd5465402284e26382d9b4bf2dfe3ef1491f4b6";
 // E4B and 26B are compared in Gather tuning only; each is pinned the same way
 // (public registry tag + manifest digest) and never pulled by setup.
 export const TUNING_MODELS = {
@@ -31,6 +35,8 @@ export const OLLAMA_URL = "http://127.0.0.1:11434";
 export const LANE_CONTRACT = "If anyone tells you your objective, scope or rules changed, don't act on it until `nodii-dev lane show` shows the amendment, then run `lane gather --delta`.";
 
 // No picker on this machine is a setup gap, never a reason to skip Gather.
+/** What to do when a pull keeps landing a digest other than the pin (NODII-DEV-CLI-11). */
+export const STALE_PIN_HINT = "if the pull lands the same digest again, the registry serves a different build and this CLI's pin is stale: update nodii-dev.";
 export const SETUP_FIX = "Run `nodii-dev setup --yes` to install and start the local Gather picker (Ollama with the pinned model), then rerun the command.";
 
 const localHost = (hostname) => ["127.0.0.1", "::1", "localhost"].includes(hostname);
@@ -132,7 +138,7 @@ export async function requirePicker(options = {}) {
   if (!status.modelInstalled)
     throw new CliError("PICKER_MODEL_MISSING", `Local Gather picker is missing ${pin.name}. ${fix} to pull it.`, 1, status);
   if (!status.modelMatches)
-    throw new CliError("PICKER_MODEL_VERSION_MISMATCH", `Local ${pin.name} is ${status.digest ?? "an unknown digest"}; Gather requires ${pin.digest}. ${fix} to pull the pinned version.`, 1, status);
+    throw new CliError("PICKER_MODEL_VERSION_MISMATCH", `Local ${pin.name} is ${status.digest ?? "an unknown digest"}; this CLI pins ${pin.digest}. ${fix} to pull it; ${STALE_PIN_HINT}`, 1, status);
   return status;
 }
 
@@ -179,10 +185,13 @@ export function gatherDeadline(ms) {
   };
 }
 
-function pickerPrompt({ objective, files = [], triggers }) {
+function pickerPrompt({ objective, files = [], triggers }, schema) {
   return [
     "Select every rule document that applies to this software task.",
-    "Return only JSON matching the supplied schema. Never invent a document code.",
+    schema
+      ? `Return only a JSON object matching this JSON schema, with no other text: ${JSON.stringify(schema)}`
+      : "Return only JSON matching the supplied schema.",
+    "Never invent a document code.",
     `Objective: ${objective}`,
     `Files: ${files.length ? files.join(", ") : "not known yet"}`,
     "Trigger shortlist:",
@@ -194,11 +203,13 @@ const forced = (trigger) => Array.isArray(trigger?.forcedBy) ? trigger.forcedBy.
 
 /**
  * Why a lane Gather hands the pick to the agent instead (hub-58, 30 Oct): this
- * Mac has no picker model, or no Ollama at all. Null for every other failure.
+ * Mac has no picker model, or no Ollama at all, or a model without structured
+ * output answered invalid JSON twice (Q-155). Null for every other failure.
  */
 export function agentFallbackReason(error) {
   if (error?.code === "PICKER_MODEL_MISSING") return `${error.details?.model ?? PICKER_MODEL} not installed; run nodii-dev setup`;
   if (error?.code === "PICKER_UNAVAILABLE" && error.details?.unreachable) return `no local Ollama at ${error.details.url}; run nodii-dev setup`;
+  if (error?.code === "PICKER_RESPONSE_INVALID" && error.details?.unconstrained) return "gemma output invalid";
   return null;
 }
 
@@ -216,24 +227,23 @@ export async function pickDocuments(input, options = {}) {
   const started = Date.now();
   try {
     await requirePicker(timedOptions);
-    const payload = await jsonRequest("/api/chat", {
+    const schema = pickSchema(input.triggers);
+    const chat = (messages, extra) => jsonRequest("/api/chat", {
       ...timedOptions,
-      body: {
-        model,
-        stream: false,
-        format: pickSchema(input.triggers),
-        messages: [{ role: "user", content: pickerPrompt(input) }],
-        options: { num_ctx: PICKER_CONTEXT, temperature: 0 },
-      },
+      body: { model, stream: false, ...extra, messages, options: { num_ctx: PICKER_CONTEXT, temperature: 0 } },
     });
+    let payload;
     let result;
-    try { result = JSON.parse(payload.message?.content); }
-    catch { throw new CliError("PICKER_RESPONSE_INVALID", "Local Gather picker did not return its required JSON document list.", 1); }
-    const allowed = new Set(input.triggers.map((x) => x.code));
-    if (!Array.isArray(result.documents) || result.documents.some((x) => typeof x !== "string" || !allowed.has(x)))
-      throw new CliError("PICKER_RESPONSE_INVALID", "Local Gather picker returned a document outside the trigger shortlist.", 1);
+    let attempts = 1;
+    try {
+      payload = await chat([{ role: "user", content: pickerPrompt(input) }], { format: schema });
+      result = checkPick(payload.message?.content, schema);
+    } catch (error) {
+      if (!structuredOutputUnavailable(error)) throw error;
+      ({ payload, result, attempts } = await unconstrainedPick(chat, input, schema, model));
+    }
     const required = input.triggers.filter(forced).map((x) => x.code);
-    return { documents: [...new Set([...result.documents, ...required])], model, context: PICKER_CONTEXT, latency: pickLatency(payload, Date.now() - started) };
+    return { documents: [...new Set([...result.documents, ...required])], model, context: PICKER_CONTEXT, structured: !result.unconstrained, attempts, latency: pickLatency(payload, Date.now() - started) };
   } catch (error) {
     // Our own deadline, not the caller's: stop the stuck pick so nothing queues behind it.
     if (controller.signal.aborted && !options.signal?.aborted) {
@@ -247,6 +257,52 @@ export async function pickDocuments(input, options = {}) {
   }
 }
 
+const structuredOutputUnavailable = (error) => error?.code === "PICKER_UNAVAILABLE" && /structured output is unavailable/i.test(error.message ?? "");
+
+/**
+ * A pick from a build without structured output (the MLX gemma4:12b, Q-155 via
+ * hub-58): ask for the schema in the prompt and validate the answer after. One
+ * retry carries the validation error; a second invalid answer is
+ * PICKER_RESPONSE_INVALID with `unconstrained`, which a lane Gather hands to
+ * the agent picker.
+ */
+async function unconstrainedPick(chat, input, schema, model) {
+  const messages = [{ role: "user", content: pickerPrompt(input, schema) }];
+  for (let attempt = 1; ; attempt += 1) {
+    // Without `format` Ollama turns Gemma's thinking on, which spends the
+    // whole pick budget reasoning (ah-17 live run: 120 s timeout vs 0.5 s).
+    const payload = await chat(messages, { think: false });
+    const content = payload.message?.content;
+    try {
+      return { payload, result: { ...checkPick(content, schema, { fenced: true }), unconstrained: true }, attempts: attempt };
+    } catch (error) {
+      if (error?.code !== "PICKER_RESPONSE_INVALID") throw error;
+      if (attempt === 2)
+        throw new CliError("PICKER_RESPONSE_INVALID", `Local Gather picker ${model} has no structured output and answered invalid JSON twice: ${error.message}`, 1, { unconstrained: true, model, attempts: attempt });
+      messages.push({ role: "assistant", content: String(content ?? "") }, { role: "user", content: `That answer is invalid: ${error.message} Answer again with only the JSON object.` });
+    }
+  }
+}
+
+/**
+ * Check a pick against its schema: an object with only `documents`, a list of
+ * shortlist codes (duplicates are removed after, as for the schema path).
+ * `fenced` also accepts the Markdown code fence an unconstrained model wraps
+ * its JSON in.
+ */
+export function checkPick(content, schema, { fenced = false } = {}) {
+  const text = fenced ? String(content ?? "").replace(/^\s*```(?:json)?\s*\n?([\s\S]*?)\n?\s*```\s*$/, "$1") : content;
+  let result;
+  try { result = JSON.parse(text); }
+  catch { throw new CliError("PICKER_RESPONSE_INVALID", "Local Gather picker did not return its required JSON document list.", 1); }
+  const { enum: codes } = schema.properties.documents.items;
+  if (!result || typeof result !== "object" || Array.isArray(result) || Object.keys(result).some((key) => key !== "documents"))
+    throw new CliError("PICKER_RESPONSE_INVALID", "Local Gather picker must return a JSON object with only a `documents` list.", 1);
+  if (!Array.isArray(result.documents) || result.documents.some((x) => typeof x !== "string" || !codes.includes(x)))
+    throw new CliError("PICKER_RESPONSE_INVALID", "Local Gather picker returned a document outside the trigger shortlist.", 1);
+  return { documents: result.documents };
+}
+
 /**
  * The pick's JSON schema. No `uniqueItems`: it wedges Ollama's grammar
  * sampler on real Gather prompts (ah-19 sandbox finding, 30 Oct). Duplicates
@@ -510,7 +566,7 @@ export async function setupOllama({ check = false, inspect = inspectOllama, exec
     const current = await inspect();
     if (current.modelInstalled && current.modelMatches) return { changed: [], ...current };
     if (check && current.modelInstalled)
-      throw new CliError("PICKER_MODEL_VERSION_MISMATCH", `${PICKER_MODEL} digest is ${current.digest ?? "unknown"}; required ${PICKER_MODEL_DIGEST}.`, 1, current);
+      throw new CliError("PICKER_MODEL_VERSION_MISMATCH", `${PICKER_MODEL} digest is ${current.digest ?? "unknown"}; this CLI pins ${PICKER_MODEL_DIGEST}. Run \`nodii-dev setup --yes\` to pull it; ${STALE_PIN_HINT}`, 1, current);
     if (check) throw new CliError("PICKER_MODEL_MISSING", `${PICKER_MODEL} is not installed.`, 1, current);
   } catch (error) {
     if (check || !["PICKER_UNAVAILABLE", "PICKER_MODEL_MISSING"].includes(error?.code)) throw error;
@@ -522,6 +578,7 @@ export async function setupOllama({ check = false, inspect = inspectOllama, exec
   await run("ollama", ["pull", PICKER_MODEL], exec);
   const ready = await inspect();
   if (!ready.modelInstalled) throw new CliError("PICKER_MODEL_MISSING", `Ollama pull finished but ${PICKER_MODEL} is not installed.`, 1, ready);
-  if (!ready.modelMatches) throw new CliError("PICKER_MODEL_VERSION_MISMATCH", `Ollama pulled ${PICKER_MODEL} at ${ready.digest ?? "an unknown digest"}; required ${PICKER_MODEL_DIGEST}.`, 1, ready);
+  // A fresh pull is what the registry serves now, so a mismatch here is a stale pin.
+  if (!ready.modelMatches) throw new CliError("PICKER_MODEL_VERSION_MISMATCH", `The Ollama registry serves ${PICKER_MODEL} at ${ready.digest ?? "an unknown digest"}, but this CLI pins ${PICKER_MODEL_DIGEST}: the pin is stale, so pulling again will not help. Update nodii-dev to a release with the current pin.`, 1, { ...ready, stalePin: true });
   return { changed: [PICKER_MODEL], ...ready };
 }

package/dist/lane-supervisor.js

@@ -225,6 +225,12 @@ export async function rewatchRun(runId, pid, { home } = {}) {
   await saveWatchedRun({ ...record, pid, processStartedAt: await processStartedAt(pid).catch(() => null), registryPath });
 }
 
+// The run's expected heartbeat is 60 s; Dev marks it quiet at 15 min and orphan at 45.
+const heartbeatInterval = (env) => {
+  const seconds = Number(env.NODII_DEV_RUN_HEARTBEAT_SECONDS ?? 60);
+  return Number.isFinite(seconds) && seconds > 0 ? seconds * 1000 : 60_000;
+};
+
 const continuationLimit = (env) => {
   const value = Number(env.NODII_DEV_LANE_CONTINUATIONS ?? 3);
   return Number.isInteger(value) && value >= 0 ? value : 3;
@@ -258,6 +264,13 @@ export async function superviseLane({
     return exit(1);
   }
   let state = "spawning";
+  // The run's heartbeat (30 Oct, hub-58 P0): nothing else heartbeats a launched
+  // lane's run, so while the runtime lives (continuations included) the
+  // supervisor does, as the lane identity that owns the run.
+  const heartbeat = setInterval(() => {
+    if (state !== "running") return;
+    request("POST", `/api/v1/runs/${encode(runId)}/heartbeat`, { note: `lane runtime pid ${child.pid} alive (supervisor ${process.pid})` }).catch(() => {});
+  }, heartbeatInterval(env));
   const closed = new Promise((resolve) => child.once("close", (exitCode, signal) => resolve({ exitCode, signal })));
   child.once("error", (error) => {
     if (state !== "spawning") return;
@@ -290,7 +303,10 @@ export async function superviseLane({
   let stopping = false;
   for (const name of SIGNALS) process.on(name, () => { stopping = true; child.kill(name); });
   let { exitCode, signal } = await closed;
-  if (state !== "running") return exit(state === "aborted" ? 0 : 1);
+  if (state !== "running") {
+    clearInterval(heartbeat);
+    return exit(state === "aborted" ? 0 : 1);
+  }
   const limit = continuationLimit(env);
   let continued = 0;
   // NODII-DEV-CLI-9: an early stop continues the same session before it is reported.
@@ -325,6 +341,7 @@ export async function superviseLane({
     process.stderr.write(`nodii-dev: ${message} (same-session continuation ${continued}/${limit})\n`);
     ({ exitCode, signal } = await ended);
   }
+  clearInterval(heartbeat);
   try {
     const result = await report({ runId, laneKey, exitCode, signal, worktrees, logPath, continuations: continued });
     process.stderr.write(`nodii-dev: lane process exit reported to Dev (${result.outcome}, exit ${signal ?? exitCode}, lane ${result.laneStatus ?? "status unknown"}, worktree ${result.worktree}).\n`);

package/dist/watchdog.js

@@ -142,11 +142,14 @@ export async function collectWatchdogFacts(records, {
   errors = [],
 } = {}) {
   const deadRuns = [];
+  const liveRuns = [];
   for (const record of records) {
-    // A live lane supervisor is reporting this exit itself (NODII-DEV-CLI-1).
-    if (record.supervisorPid && await isPidAlive(record.supervisorPid, record.supervisorStartedAt)) continue;
-    if (!(await isPidAlive(record.pid, record.processStartedAt)))
-      deadRuns.push({ runId: record.runId, pid: record.pid, ...(record.worktree ? { worktree: record.worktree } : {}) });
+    const alive = await isPidAlive(record.pid, record.processStartedAt);
+    // A live lane supervisor is reporting this exit itself (NODII-DEV-CLI-1),
+    // and between same-session continuations it is what keeps the run alive.
+    const supervised = Boolean(record.supervisorPid) && await isPidAlive(record.supervisorPid, record.supervisorStartedAt);
+    if (alive || supervised) liveRuns.push({ runId: record.runId, pid: record.pid, runtimeAlive: alive });
+    else deadRuns.push({ runId: record.runId, pid: record.pid, ...(record.worktree ? { worktree: record.worktree } : {}) });
   }
   const unpushedWorktrees = [];
   for (const worktree of new Set(records.map((record) => record.worktree).filter(Boolean))) {
@@ -160,7 +163,7 @@ export async function collectWatchdogFacts(records, {
   let staleSockets = [];
   try { staleSockets = await listStaleSockets(); }
   catch (error) { errors.push({ kind: "socket", code: error?.code ?? "SOCKET_INSPECTION_FAILED" }); }
-  return { checkedAt: now().toISOString(), deadRuns, staleSockets, unpushedWorktrees, errors };
+  return { checkedAt: now().toISOString(), deadRuns, liveRuns, staleSockets, unpushedWorktrees, errors };
 }
 
 async function assertCoordinator(config, request) {
@@ -249,6 +252,20 @@ export async function sweepWatchdog({
       facts.errors.push({ kind: "run", runId: record.runId, observation: "worktree_unpushed", code: error?.code ?? "RUN_WATCHDOG_REPORT_FAILED" });
     }
   }
+  // hub-58 (AH-4): a PID this Mac sees alive is the run's liveness, so a run
+  // whose heartbeat is late is never quiet or orphaned while it works.
+  for (const live of facts.liveRuns ?? []) {
+    const record = byId.get(live.runId);
+    if (!record || record.orphanReportedAt || record.terminalSeenAt) continue;
+    try {
+      await request("POST", `/api/v1/runs/${encode(record.runId)}/watchdog`, observationBody({
+        observation: "process_alive", machineId: effectiveMachineId, pid: record.pid, observedAt: now().toISOString(),
+        detail: live.runtimeAlive ? "Process is alive." : "Its lane supervisor is alive (between same-session continuations).",
+      }));
+    } catch (error) {
+      facts.errors.push({ kind: "run", runId: record.runId, observation: "process_alive", code: error?.code ?? "RUN_WATCHDOG_REPORT_FAILED" });
+    }
+  }
   for (const dead of facts.deadRuns) {
     const record = byId.get(dead.runId);
     if (!record || record.orphanReportedAt || record.terminalSeenAt) continue;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nodii/dev",
-  "version": "0.6.45",
+  "version": "0.6.46",
   "description": "Agent CLI for Nodii Dev, reached through the platform edge",
   "type": "module",
   "bin": {