@deeeed/metamask-harness 0.55.1 → 0.57.0

package/CHANGELOG.md

@@ -2,6 +2,25 @@
 
 ## Unreleased
 
+## 0.57.0 - 2026-09-18
+
+### Changed
+
+- The task and checklist rules the harness shares with Farmslot now come from the Farmslot packages instead of private copies, against `@farmslot/protocol` 0.29.0 and `@farmslot/agent-runtime` 0.11.0 (`@farmslot/recipe-harness` 0.17.0, `@farmslot/expo-recipe` 0.10.0 follow the protocol pin). Which signal statuses are terminal: `isTerminalWorkerSignalStatus`, so `mark` now also protects a `failed` or `done` verdict from a later non-terminal mark, and `status --watch` no longer treats an unknown status as finished. Which box is step N: `enumerateChecklistCheckboxes`, so the `check diff` gate reads the row `mark N` ticks even when an upstream checklist sits under `## Rules` or inside `<details>`. Per-row durations: `deriveChecklistStepDurations`, the same numbers Command Center shows (a task without a recorded start now shows its first row as `0:00` rather than blank). Step names: `checklistStepName`. Which task a checkout is on: `latestTaskDir`, the task written to last by signal or by checklist. File names come from the protocol constants.
+- `status --watch` reads the harness identity from the readiness record (`sandbox.json`) `prepare` writes on every surface; the `artifacts/harness-provenance.json` it looked for is the recipe-cook skill's locked-harness receipt and exists on skill runs only, so the `harness x.y.z` line was blank on every dispatched run.
+
+### Fixed
+
+- `status --watch` no longer reports `no ongoing task detected` while an agent is busy on a long step. The view judged activity only by task-dir writes (`SIGNAL.json`, row marks) and called the task silent after ten minutes, so an investigation step that ran `mm-harness call` every few seconds without ticking a row read as abandoned. The command journal (`temp/recipe/runtime/last-command.json`) now counts as activity, and the view shows it: `last command call ui.navigate · pass · 0:12 ago`. Only the command name and a leading positional argument reach the view; option values never do, and the journal is read through the same hardened reader the harness uses (symlinks and malformed records mean no command line, never a dead watch). A journal older than the task's start belongs to an earlier task and does not count. Piped output logs `command call ui.navigate pass` when the journal moves. `status` itself is not journaled, so watching a checkout never counts as its own activity.
+- `status --watch` renders a Farm checklist the way the Farmslot run view does. Steps, numbers and phases now come from `enumerateChecklistCheckboxes` in `@farmslot/protocol`, the same enumeration the gateway progress view and the `mark` helper use, instead of a private row pattern that rejected Farm's `- [x] **3. Resolve branch:**` rows and only knew `##` headings. A dispatched run therefore showed no rows at all; now it shows `Setup 5/5`, `Reproduce (BEFORE any code changes) 3/9`, … with the bold title as each step's name.
+
+## 0.56.0 - 2026-09-18
+
+### Changed
+
+- `prepare` says what it is doing while it does it. It now opens with the whole chain — `doctor`, `status`, `launch`, `fixtures`, `verify`, or just `doctor`, `status`, `verify` on Core — one line each, so the wait is bounded before the first step runs. The running step counts up in place (`… launch: running 1:23`), each finished one keeps how long it took (`✓ launch: pass (0:47)`), and the slow steps carry a dim note saying what they are waiting on: `can take minutes on Mobile: Metro bundle and app start` for `launch`, `under a minute` for `fixtures`. Where the checkout has a previous `sandbox.json`, each step also shows what it cost last time (`last run 6:52`) — the only honest estimate the harness has. Before this, a Mobile prepare printed `✓ status: pass` and then nothing for the minutes the launch step ran, which reads as a hang. The clock on screen is the wall clock: one timestamp taken at the spawn feeds both the ticker and the `durationMs` in the record, and the repaint holds the event loop awake so a step that stays quiet for minutes — `verify` waiting on its bridge probe — cannot leave the count frozen behind the wall. Piped output is a plain log — the list, then each step as it lands, then the finished list. `--json` is untouched: stdout stays a single document.
+- `sandbox.json` records `durationMs` on every readiness step (`0` for a skipped one), so a run that felt slow can be read back step by step instead of retimed by hand.
+
 ## 0.55.1 - 2026-09-18
 
 ### Fixed

package/dist/commands/checklist.js

@@ -2,6 +2,8 @@ import { spawnSync } from "node:child_process";
 import fs from "node:fs";
 import { createRequire } from "node:module";
 import path from "node:path";
+import { HANDOFF_INPUT } from "@farmslot/agent-runtime";
+import { enumerateChecklistCheckboxes, isTerminalWorkerSignalStatus } from "@farmslot/protocol";
 import { EXIT } from "./shared.js";
 const require2 = createRequire(import.meta.url);
 const MARK_SCRIPT = require2.resolve(
@@ -88,7 +90,7 @@ function runCloseout(taskDir, args, stdio) {
   }
 }
 function stageLearningPackage(taskDir, step, markArgs) {
-  if (!["complete", "no-change"].includes(step ?? "") || markArgs.includes("--skip-learnings") || !fs.existsSync(path.join(taskDir, "inputs", "handoff.json"))) {
+  if (!["complete", "no-change"].includes(step ?? "") || markArgs.includes("--skip-learnings") || !fs.existsSync(path.join(taskDir, HANDOFF_INPUT))) {
     return;
   }
   try {
@@ -108,7 +110,7 @@ function terminalSignalStatus(taskDir) {
   } catch {
     return null;
   }
-  return signal.status === "complete" || signal.status === "blocked" ? signal.status : null;
+  return isTerminalWorkerSignalStatus(signal.status) ? signal.status ?? null : null;
 }
 function preserveTerminalSignal(taskDir, step) {
   if (step !== "start" && numericMarkStep(step) === null) return false;
@@ -124,20 +126,8 @@ function numericMarkStep(step) {
   return Number.isInteger(stepNumber) && stepNumber >= 1 ? stepNumber : null;
 }
 function checklistStepRequiresDiffPass(checklist, stepNumber) {
-  let inFence = false;
-  let seen = 0;
-  for (const line of checklist.split(/\n/u)) {
-    if (/^\s*```/u.test(line)) {
-      inFence = !inFence;
-      continue;
-    }
-    if (inFence) continue;
-    const match = line.match(/^\s*[-*]\s+\[(?: |x|X)\]\s+(.*)$/u);
-    if (!match) continue;
-    seen += 1;
-    if (seen === stepNumber) return /mm-harness check diff/u.test(match[1] ?? "");
-  }
-  return false;
+  const step = enumerateChecklistCheckboxes(checklist).find((item) => item.stepNumber === stepNumber);
+  return step !== void 0 && /mm-harness check diff/u.test(step.rawLabel);
 }
 function checkDiffGateReady(taskDir, step) {
   const stepNumber = numericMarkStep(step);

package/dist/commands/prepare.js

@@ -1,14 +1,16 @@
-import { spawnSync } from "node:child_process";
+import { spawn } from "node:child_process";
 import fs from "node:fs";
 import path from "node:path";
 import {
   READINESS_RECORD
 } from "@farmslot/protocol";
+import { color, stripAnsi } from "../cli-color.js";
 import { runnerProvenance } from "../doctor.js";
 import { detectAdapter } from "../harness.js";
 import { harnessExecutable, manifestPath, recipeRuntimeDir } from "../paths.js";
 import { optionFlag, optionString, parseArgs, targetPath, usageError } from "./parse-args.js";
 import { EXIT } from "./shared.js";
+import { formatDuration } from "./status-watch.js";
 const USAGE = "mm-harness prepare [--target <checkout>] [--platform mobile|extension|core] [--mobile-platform ios|android] [--clear-metro] [--artifacts-dir <dir>] [--json]";
 const REPORT_DIR = "prepare";
 const SKIPPED_AFTER_FAILURE = "previous step failed";
@@ -26,31 +28,175 @@ function reportedError(stdout) {
   return typeof message === "string" && message ? message : void 0;
 }
 function skippedStep(id, command, reason) {
-  return { id, command, status: "skipped", exitCode: 0, reason };
+  return { id, command, status: "skipped", exitCode: 0, reason, durationMs: 0 };
 }
-const STEP_MARK = { pass: "\u2713", fail: "\u2717", skipped: "\u2013" };
-function stepLine(step) {
-  return `${STEP_MARK[step.status]} ${step.id}: ${step.status}${step.reason ? ` \u2014 ${step.reason}` : ""}`;
+const STEP_MARK = {
+  pending: "\xB7",
+  running: "\u2026",
+  pass: "\u2713",
+  fail: "\u2717",
+  skipped: "\u2013"
+};
+const STEP_STYLE = {
+  pending: "dim",
+  running: "accent",
+  pass: "ok",
+  fail: "err",
+  skipped: "dim"
+};
+const STEP_HINT = {
+  launch: "can take minutes on Mobile: Metro bundle and app start",
+  fixtures: "under a minute"
+};
+function stepChain(platform) {
+  return platform === "core" ? ["doctor", "status", "verify"] : ["doctor", "status", "launch", "fixtures", "verify"];
 }
-function runStep(executable, target, artifactsDir, id, args, { json }) {
-  const command = [executable, ...args].join(" ");
-  const result = spawnSync(executable, [...args], {
-    cwd: target,
-    encoding: "utf8",
-    // The update nudge is an interactive courtesy; it has no place in the
-    // stream a recorded readiness step captures.
-    env: { ...process.env, MM_HARNESS_NO_UPDATE_CHECK: "1" }
+function lastRunDurations(recordPath) {
+  let parsed;
+  try {
+    parsed = JSON.parse(fs.readFileSync(recordPath, "utf8"));
+  } catch {
+    return {};
+  }
+  const steps = parsed?.steps;
+  if (!Array.isArray(steps)) return {};
+  const durations = {};
+  for (const step of steps) {
+    if (typeof step?.id === "string" && typeof step.durationMs === "number" && step.durationMs > 0) {
+      durations[step.id] = step.durationMs;
+    }
+  }
+  return durations;
+}
+function stepHints(chain, lastRun) {
+  const hints = {};
+  for (const id of chain) {
+    const previous = lastRun[id];
+    const parts = [];
+    if (STEP_HINT[id]) parts.push(STEP_HINT[id]);
+    if (previous !== void 0) parts.push(`last run ${formatDuration(previous)}`);
+    if (parts.length > 0) hints[id] = parts.join(", ");
+  }
+  return hints;
+}
+function stepRowLine(row, width) {
+  const out = (style, text) => color(style, text, { stream: process.stdout });
+  const running = row.state === "pending" || row.state === "running";
+  const elapsed = row.state === "running" && row.startedAt !== void 0 ? ` ${out("dim", formatDuration(Date.now() - row.startedAt))}` : "";
+  const note = running ? row.hint : row.durationMs ? formatDuration(row.durationMs) : void 0;
+  const mark = out(STEP_STYLE[row.state], STEP_MARK[row.state]);
+  return `${mark} ${out(running ? "bold" : "dim", row.id.padEnd(width))}: ${out(STEP_STYLE[row.state], row.state)}${elapsed}${row.reason ? ` \u2014 ${row.reason}` : ""}${note ? ` ${out("dim", `(${note})`)}` : ""}`;
+}
+function createStepView(chain, hints) {
+  const rows = new Map(
+    chain.map((id) => [id, { id, state: "pending", hint: hints[id] }])
+  );
+  const width = Math.max(...chain.map((id) => id.length));
+  const tty = Boolean(process.stdout.isTTY);
+  const block = () => {
+    const terminalColumns = process.stdout.columns;
+    const columns = tty && typeof terminalColumns === "number" && terminalColumns > 0 ? terminalColumns : Number.POSITIVE_INFINITY;
+    return [...rows.values()].map((row) => {
+      const line = stepRowLine(row, width);
+      return stripAnsi(line).length <= columns ? line : stripAnsi(line).slice(0, columns);
+    });
+  };
+  let painted = 0;
+  let lastFrame = "";
+  let ended = false;
+  let timer;
+  const repaint = () => {
+    const lines = block();
+    const frame = lines.join("\n");
+    if (frame === lastFrame) return;
+    lastFrame = frame;
+    const up = painted > 0 ? `\x1B[${painted}A` : "";
+    painted = lines.length;
+    process.stdout.write(`${up}${lines.map((line) => `\x1B[2K${line}`).join("\n")}
+`);
+  };
+  const writeBlock = () => {
+    process.stdout.write(`${block().join("\n")}
+`);
+  };
+  return {
+    begin() {
+      if (tty) repaint();
+      else writeBlock();
+    },
+    start(id, startedAt) {
+      const row = rows.get(id);
+      if (!row) return;
+      row.state = "running";
+      row.startedAt = startedAt;
+      if (!tty) return;
+      repaint();
+      timer = setInterval(repaint, 250);
+    },
+    finish(step) {
+      clearInterval(timer);
+      timer = void 0;
+      const row = rows.get(step.id);
+      if (!row) return;
+      row.state = step.status;
+      row.startedAt = void 0;
+      row.reason = step.reason;
+      row.durationMs = step.durationMs;
+      if (tty) repaint();
+      else process.stdout.write(`${stepRowLine(row, width)}
+`);
+    },
+    // Idempotent: the caller ends the view where the final block belongs in the
+    // output, and a `finally` ends it again on the paths that never got there.
+    // The ticker holds the event loop awake, so this must run either way.
+    end() {
+      if (ended) return;
+      ended = true;
+      clearInterval(timer);
+      timer = void 0;
+      if (!tty) writeBlock();
+    }
+  };
+}
+function spawnStep(executable, args, target) {
+  return new Promise((resolve) => {
+    const child = spawn(executable, [...args], {
+      cwd: target,
+      stdio: ["ignore", "pipe", "pipe"],
+      // The update nudge is an interactive courtesy; it has no place in the
+      // stream a recorded readiness step captures.
+      env: { ...process.env, MM_HARNESS_NO_UPDATE_CHECK: "1" }
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout?.setEncoding("utf8");
+    child.stderr?.setEncoding("utf8");
+    child.stdout?.on("data", (chunk) => {
+      stdout += chunk;
+    });
+    child.stderr?.on("data", (chunk) => {
+      stderr += chunk;
+    });
+    child.on("error", (error) => resolve({ error, status: null, stdout, stderr }));
+    child.on("close", (status) => resolve({ status, stdout, stderr }));
   });
+}
+async function runStep(executable, target, artifactsDir, id, args, { json, onSpawn }) {
+  const command = [executable, ...args].join(" ");
+  const startedAt = Date.now();
+  onSpawn?.(startedAt);
+  const result = await spawnStep(executable, args, target);
+  const durationMs = Date.now() - startedAt;
   if (result.error) {
-    return { id, command, status: "fail", exitCode: 1, reason: result.error.message };
+    return { id, command, status: "fail", exitCode: 1, reason: result.error.message, durationMs };
   }
   const report = reportPathFor(id);
   const file = path.join(artifactsDir, report);
   fs.mkdirSync(path.dirname(file), { recursive: true });
-  fs.writeFileSync(file, result.stdout ?? "");
+  fs.writeFileSync(file, result.stdout);
   const exitCode = result.status ?? 1;
   if (exitCode === 0) {
-    return { id, command, status: "pass", exitCode, reportPath: report };
+    return { id, command, status: "pass", exitCode, reportPath: report, durationMs };
   }
   if (!json && result.stderr) process.stderr.write(result.stderr);
   return {
@@ -59,7 +205,8 @@ function runStep(executable, target, artifactsDir, id, args, { json }) {
     status: "fail",
     exitCode,
     reportPath: report,
-    reason: reportedError(result.stdout) ?? `exited ${exitCode}`
+    reason: reportedError(result.stdout) ?? `exited ${exitCode}`,
+    durationMs
   };
 }
 function readDevices(artifactsDir) {
@@ -172,41 +319,56 @@ async function handlePrepare(argv) {
   Next: ${USAGE}`);
   }
   let mobilePlatform = mobilePlatformOption(optionString(options, "mobilePlatform"));
+  const recordPath = path.join(artifactsDir, READINESS_RECORD);
+  const chain = stepChain(platform);
+  const view = json ? void 0 : createStepView(chain, stepHints(chain, lastRunDurations(recordPath)));
+  view?.begin();
   const steps = [];
   const failed = () => steps.some((step) => step.status === "fail");
   const addStep = (step) => {
     steps.push(step);
-    if (!json) console.log(stepLine(step));
+    view?.finish(step);
     return step;
   };
-  const run = (id, args) => addStep(
-    failed() ? skippedStep(id, [executable, ...args].join(" "), SKIPPED_AFTER_FAILURE) : runStep(executable, target, artifactsDir, id, args, { json })
-  );
-  run("doctor", ["doctor", "--fix", "--json", "--adapter", platform, ...targetArgs]);
-  run("status", ["status", "--json", ...targetArgs]);
-  if (platform === "mobile" && !mobilePlatform && !failed()) {
-    mobilePlatform = mobilePlatformFromConfiguredTarget(process.env, readRuntimeContextTarget(target)) ?? mobilePlatformFromDevices(readDevices(artifactsDir));
-    if (!mobilePlatform) return ambiguousMobileTarget(json);
-  }
-  if (platform === "core") {
-    const reason = "core is headless: no app surface to launch or seed";
-    addStep(skippedStep("launch", `${executable} launch`, reason));
-    addStep(skippedStep("fixtures", `${executable} fixtures set`, reason));
-  } else if (platform === "mobile") {
-    const device = mobilePlatform ? [mobilePlatform] : [];
-    run("launch", ["launch", ...device, ...clearMetro ? ["--clear-metro"] : [], "--verify", "--json", ...targetArgs]);
-    run("fixtures", [
-      "fixtures",
-      "set",
-      ...mobilePlatform ? ["--platform", mobilePlatform] : [],
-      "--json",
-      ...targetArgs
-    ]);
-  } else {
-    run("launch", ["launch", "--verify", "--json", ...targetArgs]);
-    run("fixtures", ["fixtures", "set", "--json", ...targetArgs]);
+  const run = async (id, args) => {
+    if (failed()) {
+      return addStep(skippedStep(id, [executable, ...args].join(" "), SKIPPED_AFTER_FAILURE));
+    }
+    const step = await runStep(executable, target, artifactsDir, id, args, {
+      json,
+      onSpawn: (startedAt) => view?.start(id, startedAt)
+    });
+    return addStep(step);
+  };
+  try {
+    await run("doctor", ["doctor", "--fix", "--json", "--adapter", platform, ...targetArgs]);
+    await run("status", ["status", "--json", ...targetArgs]);
+    if (platform === "mobile" && !mobilePlatform && !failed()) {
+      mobilePlatform = mobilePlatformFromConfiguredTarget(process.env, readRuntimeContextTarget(target)) ?? mobilePlatformFromDevices(readDevices(artifactsDir));
+      if (!mobilePlatform) return ambiguousMobileTarget(json);
+    }
+    if (platform === "core") {
+      const reason = "core is headless: no app surface to launch or seed";
+      addStep(skippedStep("launch", `${executable} launch`, reason));
+      addStep(skippedStep("fixtures", `${executable} fixtures set`, reason));
+    } else if (platform === "mobile") {
+      const device = mobilePlatform ? [mobilePlatform] : [];
+      await run("launch", ["launch", ...device, ...clearMetro ? ["--clear-metro"] : [], "--verify", "--json", ...targetArgs]);
+      await run("fixtures", [
+        "fixtures",
+        "set",
+        ...mobilePlatform ? ["--platform", mobilePlatform] : [],
+        "--json",
+        ...targetArgs
+      ]);
+    } else {
+      await run("launch", ["launch", "--verify", "--json", ...targetArgs]);
+      await run("fixtures", ["fixtures", "set", "--json", ...targetArgs]);
+    }
+    await run("verify", ["verify", "--json", "--adapter", platform, ...targetArgs]);
+  } finally {
+    view?.end();
   }
-  run("verify", ["verify", "--json", "--adapter", platform, ...targetArgs]);
   const provenance = runnerProvenance(manifestPath(platform));
   const record = {
     schemaVersion: 1,
@@ -222,7 +384,6 @@ async function handlePrepare(argv) {
     ready: steps.every((step) => step.status !== "fail"),
     recordedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
-  const recordPath = path.join(artifactsDir, READINESS_RECORD);
   fs.mkdirSync(artifactsDir, { recursive: true });
   fs.writeFileSync(recordPath, `${JSON.stringify(record, null, 2)}
 `);

package/dist/commands/status-watch.js

@@ -1,11 +1,11 @@
 import os from "node:os";
 import path from "node:path";
+import { isTerminalWorkerSignalStatus } from "@farmslot/protocol";
 import { color } from "../cli-color.js";
 import {
   CHECKLIST_LABEL_LIMIT,
   collectTaskView,
   findTaskDir,
-  isTerminalStatus,
   TASK_SILENT_AFTER_MS
 } from "../task-view.js";
 import { EXIT } from "./shared.js";
@@ -59,7 +59,7 @@ async function runStatusWatch(options, deps) {
 `);
     }
     previous = view;
-    const terminal = isTerminalStatus(view.signal?.status);
+    const terminal = isTerminalWorkerSignalStatus(view.signal?.status);
     if (view.activity.ongoing) sawInProgress = true;
     if (!options.watch || terminal && (sawInProgress || options.taskDir !== void 0)) return EXIT.ok;
     await deps.wait(REFRESH_MS);
@@ -106,6 +106,14 @@ function renderTaskView(view, title, explicitTask = false) {
     showTask && view.sandbox?.ready !== void 0 && `sandbox ${view.sandbox.ready ? out("ok", "ready") : out("warn", "not ready")}`
   ]);
   if (contextLine) lines.push(contextLine);
+  const last = view.lastCommand;
+  if (showTask && last) {
+    lines.push(joinParts([
+      `last command ${out("info", joinParts([last.command, last.subject], " "))}`,
+      last.verdict && statusWord(out, last.verdict),
+      last.ageMs !== void 0 && `${formatDuration(last.ageMs)} ago`
+    ]));
+  }
   lines.push("");
   if (!view.activity.ongoing) {
     lines.push(out("warn", "no ongoing task detected"));
@@ -169,6 +177,9 @@ function changedLines(previous, next) {
   if (previous.signal?.status !== next.signal?.status) {
     lines.push(`status ${next.signal?.status ?? "unknown"}`);
   }
+  if (next.lastCommand && previous.lastCommand?.at !== next.lastCommand.at) {
+    lines.push(`command ${joinParts([next.lastCommand.command, next.lastCommand.subject], " ")}${next.lastCommand.verdict ? ` ${next.lastCommand.verdict}` : ""}`);
+  }
   return lines;
 }
 function formatDuration(ms) {

package/dist/task-view.js

@@ -1,34 +1,24 @@
 import { spawnSync } from "node:child_process";
 import fs from "node:fs";
 import path from "node:path";
+import { HANDOFF_INPUT, latestTaskDir } from "@farmslot/agent-runtime";
+import {
+  checklistStepName,
+  deriveChecklistStepDurations,
+  enumerateChecklistCheckboxes,
+  INTERACTIVE_CHECKLIST_MARKDOWN,
+  isTerminalWorkerSignalStatus,
+  READINESS_RECORD,
+  WORKER_SIGNAL_FILE
+} from "@farmslot/protocol";
+import { readCommandJournal } from "./command-journal.js";
 import { resolveRuntimeContextPath } from "./harness.js";
+import { recipeRuntimeDir } from "./paths.js";
 import { parseLibraryPathEnv } from "./review/knowledge.js";
-const TASK_SEARCH_DEPTH = 3;
 const CHECKLIST_LABEL_LIMIT = 70;
-const CHECKLIST_ROW = /^\s*-\s\[([ xX])\]\s*(\d+)\.\s*(.*)$/u;
-const CHECKLIST_PHASE = /^##\s+(.+?)\s*$/u;
 const TASK_SILENT_AFTER_MS = 10 * 60 * 1e3;
 function findTaskDir(target) {
-  const root = path.join(target, "temp", "tasks");
-  let bySignal;
-  let byChecklist;
-  const consider = (best, dir, file) => {
-    const stat = fs.statSync(path.join(dir, file), { throwIfNoEntry: false });
-    if (!stat?.isFile()) return best;
-    return best && best.mtimeMs >= stat.mtimeMs ? best : { dir, mtimeMs: stat.mtimeMs };
-  };
-  const visit = (dir, depth) => {
-    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
-      if (!entry.isDirectory()) continue;
-      const child = path.join(dir, entry.name);
-      bySignal = consider(bySignal, child, "SIGNAL.json");
-      byChecklist = consider(byChecklist, child, "CHECKLIST.md");
-      if (depth < TASK_SEARCH_DEPTH) visit(child, depth + 1);
-    }
-  };
-  if (!fs.statSync(root, { throwIfNoEntry: false })?.isDirectory()) return void 0;
-  visit(root, 1);
-  return (bySignal ?? byChecklist)?.dir;
+  return latestTaskDir(path.join(target, "temp", "tasks"));
 }
 function collectTaskView(target, taskDir, now) {
   const base = {
@@ -39,20 +29,29 @@ function collectTaskView(target, taskDir, now) {
     )
   };
   if (!taskDir) return { ...base, checklist: [], activity: { ongoing: false, reason: "no-task" } };
-  const handoff = readJsonObject(path.join(taskDir, "inputs", "handoff.json"));
-  const provenance = readJsonObject(path.join(taskDir, "artifacts", "harness-provenance.json"));
+  const handoff = readJsonObject(path.join(taskDir, HANDOFF_INPUT));
   const fixtures = readJsonObject(path.join(taskDir, "artifacts", "prepare", "fixtures.json"));
-  const sandbox = readJsonObject(path.join(taskDir, "artifacts", "sandbox.json"));
-  const signal = readJsonObject(path.join(taskDir, "SIGNAL.json"));
-  const checklist = readChecklistRows(path.join(taskDir, "CHECKLIST.md"));
+  const sandbox = readJsonObject(path.join(taskDir, "artifacts", READINESS_RECORD)) ?? readJsonObject(path.join(target, recipeRuntimeDir(), READINESS_RECORD));
+  const signal = readJsonObject(path.join(taskDir, WORKER_SIGNAL_FILE));
+  const checklist = readChecklistRows(path.join(taskDir, INTERACTIVE_CHECKLIST_MARKDOWN));
   const template = asObject(handoff?.executionTemplate);
   const task = asObject(handoff?.task);
-  const startedAt = parseTime(pickString(handoff, "startedAt"));
-  const timing = applyTiming(checklist, signal, startedAt, now);
+  const startedAtIso = pickString(handoff, "startedAt");
+  const startedAt = parseTime(startedAtIso);
+  const timing = applyTiming(checklist, signal, startedAtIso, now);
   const ticket = pickString(task, "ticket");
+  const journal = readLastCommand(target, now);
+  const commandAt = parseTime(journal?.at);
+  const commandCounts = commandAt !== void 0 && (startedAt === void 0 || commandAt >= startedAt);
+  const lastCommand = commandCounts ? journal : void 0;
   const activity = taskActivity({
     status: pickString(signal, "status"),
-    lastWrites: [startedAt, parseTime(pickString(signal, "timestamp")), ...readMarkTimes(signal).values()],
+    lastWrites: [
+      startedAt,
+      parseTime(pickString(signal, "timestamp")),
+      ...readMarkEvents(signal).map((event) => Date.parse(event.checkedAt)),
+      commandCounts ? commandAt : void 0
+    ],
     branch: base.checkout.branch,
     ticket,
     now
@@ -60,9 +59,10 @@ function collectTaskView(target, taskDir, now) {
   return {
     ...base,
     taskDir,
+    // The readiness record is the only place a harness records itself for a task.
     harness: section({
-      version: pickString(asObject(provenance?.package), "version"),
-      sourceKind: pickString(asObject(provenance?.source), "kind")
+      version: pickString(asObject(sandbox?.harness), "version"),
+      sourceKind: pickString(asObject(sandbox?.harness), "source")
     }),
     template: section({
       id: pickString(template, "id"),
@@ -87,10 +87,26 @@ function collectTaskView(target, taskDir, now) {
       timestamp: pickString(signal, "timestamp"),
       attemptId: pickString(signal, "attemptId")
     }),
+    ...lastCommand ? { lastCommand } : {},
     ...timing,
     activity
   };
 }
+function readLastCommand(target, now) {
+  const { record } = readCommandJournal(target);
+  if (!record) return void 0;
+  const first = record.args[0];
+  const subject = first !== void 0 && !first.startsWith("-") ? first : void 0;
+  const at = record.finishedAt || record.startedAt;
+  const atMs = parseTime(at);
+  return {
+    command: record.command,
+    ...subject ? { subject } : {},
+    verdict: record.verdict,
+    ...at ? { at } : {},
+    ...atMs !== void 0 ? { ageMs: Math.max(0, now - atMs) } : {}
+  };
+}
 function taskActivity(input) {
   const writes = input.lastWrites.filter((value) => value !== void 0);
   const idleMs = writes.length > 0 ? input.now - Math.max(...writes) : void 0;
@@ -100,71 +116,59 @@ function taskActivity(input) {
     ...branchCarriesTicket !== void 0 ? { branchCarriesTicket } : {}
   };
   if (input.status === void 0 && writes.length === 0) return { ongoing: false, reason: "no-task", ...extra };
-  if (isTerminalStatus(input.status)) return { ongoing: false, reason: "finished", ...extra };
+  if (isTerminalWorkerSignalStatus(input.status)) return { ongoing: false, reason: "finished", ...extra };
   if (idleMs !== void 0 && idleMs > TASK_SILENT_AFTER_MS) return { ongoing: false, reason: "silent", ...extra };
   return { ongoing: true, ...extra };
 }
-function isTerminalStatus(status) {
-  return status !== void 0 && status !== "running" && status !== "started";
-}
-function applyTiming(rows, signal, startedAt, now) {
-  const marks = readMarkTimes(signal);
-  let previousAt = startedAt;
-  let lastAt;
-  let firstAt;
+function applyTiming(rows, signal, startedAtIso, now) {
+  const events = readMarkEvents(signal);
+  const durations = new Map(
+    deriveChecklistStepDurations({ schemaVersion: 1, events }, startedAtIso).map((step) => [
+      step.stepNumber,
+      step.durationMs
+    ])
+  );
+  const marks = new Map(events.map((event) => [event.stepNumber, Date.parse(event.checkedAt)]));
   for (const row of rows) {
-    const checkedAt = marks.get(row.number);
-    if (checkedAt === void 0) continue;
-    if (previousAt !== void 0) row.durationMs = checkedAt - previousAt;
-    if (firstAt === void 0) firstAt = checkedAt;
-    previousAt = checkedAt;
-    lastAt = checkedAt;
+    const durationMs = durations.get(row.number);
+    if (durationMs !== void 0) row.durationMs = durationMs;
   }
+  const instants = [...marks.values()];
+  const lastAt = instants.length > 0 ? Math.max(...instants) : void 0;
+  const firstAt = instants.length > 0 ? Math.min(...instants) : void 0;
   const current = rows.find((row) => !row.checked);
   if (current && lastAt !== void 0) current.runningMs = now - lastAt;
-  const origin = startedAt ?? firstAt;
+  const origin = parseTime(startedAtIso) ?? firstAt;
   return {
     ...current ? { currentStep: current.number } : {},
     ...origin !== void 0 ? { elapsedMs: now - origin } : {}
   };
 }
-function readMarkTimes(signal) {
-  const marks = /* @__PURE__ */ new Map();
+function readMarkEvents(signal) {
   const events = asObject(signal?.checklistTiming)?.events;
-  if (!Array.isArray(events)) return marks;
+  if (!Array.isArray(events)) return [];
+  const marks = [];
   for (const entry of events) {
     const event = asObject(entry);
     const stepNumber = pickNumber(event, "stepNumber");
-    const checkedAt = parseTime(pickString(event, "checkedAt"));
-    if (stepNumber === void 0 || checkedAt === void 0) continue;
-    marks.set(stepNumber, checkedAt);
+    const checkedAt = pickString(event, "checkedAt");
+    if (stepNumber === void 0 || parseTime(checkedAt) === void 0) continue;
+    marks.push({ stepNumber, label: "", checkedAt });
   }
   return marks;
 }
 function readChecklistRows(file) {
   const text = readTextFile(file);
   if (text === void 0) return [];
-  const rows = [];
-  let phase;
-  for (const line of text.split("\n")) {
-    const heading = CHECKLIST_PHASE.exec(line);
-    if (heading) {
-      phase = heading[1];
-      continue;
-    }
-    const match = CHECKLIST_ROW.exec(line);
-    if (!match) continue;
-    rows.push({
-      ...phase ? { phase } : {},
-      number: Number(match[2]),
-      label: trimLabel(match[3]),
-      checked: match[1].toLowerCase() === "x"
-    });
-  }
-  return rows;
+  return enumerateChecklistCheckboxes(text).map((item) => ({
+    ...item.phase ? { phase: item.phase } : {},
+    number: item.stepNumber,
+    label: trimLabel(item.rawLabel),
+    checked: item.checked
+  }));
 }
 function trimLabel(text) {
-  const plain = text.replace(/\*\*/gu, "").replace(/\s+/gu, " ").trim();
+  const plain = checklistStepName(text).replace(/\*\*/gu, "").replace(/^\d+\.\s*/u, "").replace(/\s+/gu, " ").trim();
   if (plain.length <= CHECKLIST_LABEL_LIMIT) return plain;
   return `${plain.slice(0, CHECKLIST_LABEL_LIMIT).trimEnd()}\u2026`;
 }
@@ -242,6 +246,5 @@ export {
   CHECKLIST_LABEL_LIMIT,
   TASK_SILENT_AFTER_MS,
   collectTaskView,
-  findTaskDir,
-  isTerminalStatus
+  findTaskDir
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deeeed/metamask-harness",
-  "version": "0.55.1",
+  "version": "0.57.0",
   "type": "module",
   "bin": {
     "mm-harness": "bin/mm-harness"
@@ -20,11 +20,11 @@
     "check:syntax": "find . -name '*.mjs' -print0 | xargs -0 -n1 node --check"
   },
   "dependencies": {
-    "@farmslot/agent-runtime": "0.10.0",
-    "@farmslot/expo-recipe": "0.9.2",
+    "@farmslot/agent-runtime": "0.11.0",
+    "@farmslot/expo-recipe": "0.10.0",
     "@farmslot/handoff": "^0.3.1",
-    "@farmslot/protocol": "0.28.0",
-    "@farmslot/recipe-harness": "0.16.3",
+    "@farmslot/protocol": "0.29.0",
+    "@farmslot/recipe-harness": "0.17.0",
     "agent-device": "0.19.3",
     "commander": "^12.0.0",
     "es-module-lexer": "2.3.1",