@aiaiai-pt/martha-cli 0.29.0 → 0.31.0

package/CHANGELOG.md

@@ -4,6 +4,18 @@ All notable changes to `@aiaiai-pt/martha-cli`. Format: [Keep a Changelog](https
 
 ## [Unreleased]
 
+## [0.30.0] — 2026-07-03
+
+### Added — #761 runner heartbeat + poll-based cancel
+- `martha runner` now runs each task's goal **asynchronously with a heartbeat loop** (every `min(lease_timeout_s/3, 60)`s). Heartbeats renew the lease, so a task longer than its lease is no longer reclaimed by the lease reaper while still executing on the host (the Slice-0 double-execution hazard).
+- Cancelling a claimed task (`martha tasks cancel <id>` or the admin route) now actually stops it: the heartbeat reply carries `signal: "cancel"`, the runner kills the goal's **entire process tree** (SIGTERM the group, SIGKILL after 5s), and reports the partial output with `status: "cancelled"` — accepted idempotently server-side. Worst-case kill latency is one heartbeat interval (≤60s).
+- Heartbeat failures (network blips, 409s) never affect the running job — only an explicit `signal: "cancel"` kills.
+
+### Changed
+- The runner no longer "backgrounds" goals after 20s (a Slice-0 artifact that reported long tasks as `completed` while they were still running) — it now waits for real completion, kept alive by the heartbeat loop.
+
+<!-- 0.29.0 shipped 2026-07-02 (#751 asks + trigger-tasking) without a CHANGELOG section — see git history. -->
+
 ## [0.28.0] — 2026-06-30
 
 ### Added — #714 Slice 1 external-agent `event.emit` binding surfaces

package/dist/index.js

@@ -3528,6 +3528,7 @@ var require_stringify = __commonJS((exports) => {
       nullStr: "null",
       simpleKeys: false,
       singleQuote: null,
+      trailingComma: false,
       trueStr: "true",
       verifyAliasOrder: true
     }, doc.schema.toStringOptions, options);
@@ -4036,13 +4037,20 @@ ${indent}${line}` : `
       if (comment)
         reqNewline = true;
       let str = stringify.stringify(item, itemCtx, () => comment = null);
-      if (i < items.length - 1)
+      reqNewline || (reqNewline = lines.length > linesAtValue || str.includes(`
+`));
+      if (i < items.length - 1) {
         str += ",";
+      } else if (ctx.options.trailingComma) {
+        if (ctx.options.lineWidth > 0) {
+          reqNewline || (reqNewline = lines.reduce((sum, line) => sum + line.length + 2, 2) + (str.length + 2) > ctx.options.lineWidth);
+        }
+        if (reqNewline) {
+          str += ",";
+        }
+      }
       if (comment)
         str += stringifyComment.lineComment(str, itemIndent, commentString(comment));
-      if (!reqNewline && (lines.length > linesAtValue || str.includes(`
-`)))
-        reqNewline = true;
       lines.push(str);
       linesAtValue = lines.length;
     }
@@ -6837,17 +6845,22 @@ var require_compose_node = __commonJS((exports) => {
       case "block-map":
       case "block-seq":
       case "flow-collection":
-        node = composeCollection.composeCollection(CN, ctx, token, props, onError);
-        if (anchor)
-          node.anchor = anchor.source.substring(1);
+        try {
+          node = composeCollection.composeCollection(CN, ctx, token, props, onError);
+          if (anchor)
+            node.anchor = anchor.source.substring(1);
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          onError(token, "RESOURCE_EXHAUSTION", message);
+        }
         break;
       default: {
         const message = token.type === "error" ? token.message : `Unsupported token (type: ${token.type})`;
         onError(token, "UNEXPECTED_TOKEN", message);
-        node = composeEmptyNode(ctx, token.offset, undefined, null, props, onError);
         isSrcToken = false;
       }
     }
+    node ?? (node = composeEmptyNode(ctx, token.offset, undefined, null, props, onError));
     if (anchor && node.anchor === "")
       onError(anchor, "BAD_ALIAS", "Anchor cannot be an empty string");
     if (atKey && ctx.options.stringKeys && (!identity.isScalar(node) || typeof node.value !== "string" || node.tag && node.tag !== "tag:yaml.org,2002:str")) {
@@ -11063,7 +11076,7 @@ init_config();
 init_errors();
 
 // src/version.ts
-var CLI_VERSION = "0.29.0";
+var CLI_VERSION = "0.31.0";
 
 // src/commands/sessions.ts
 function relativeTime(iso) {
@@ -11421,6 +11434,68 @@ async function runHostCommand(command, toolCallId, opts) {
 function safeName(s) {
   return s.replace(/[^a-zA-Z0-9_.-]/g, "_").slice(0, 120) || "task";
 }
+async function startHostCommand(command, toolCallId, opts) {
+  const dir = runnerDir(opts.cwd);
+  await fs5.mkdir(dir, { recursive: true });
+  const logPath = path4.join(dir, `${safeName(toolCallId)}.log`);
+  await fs5.writeFile(logPath, "");
+  const fd = openSync(logPath, "a");
+  const cap = opts.maxOutputBytes ?? MAX_OUTPUT;
+  const readLog = async () => {
+    try {
+      const buf = await fs5.readFile(logPath);
+      return buf.subarray(-cap).toString("utf8");
+    } catch {
+      return "";
+    }
+  };
+  const child = spawn(command, {
+    shell: true,
+    cwd: opts.cwd,
+    detached: true,
+    stdio: ["ignore", fd, fd]
+  });
+  closeSync(fd);
+  let exited = false;
+  const done = new Promise((resolve, reject) => {
+    let settled = false;
+    child.on("error", (e) => {
+      if (settled)
+        return;
+      settled = true;
+      exited = true;
+      reject(e);
+    });
+    child.on("close", async (code) => {
+      if (settled)
+        return;
+      settled = true;
+      exited = true;
+      resolve({
+        stdout: await readLog(),
+        stderr: "",
+        exit_code: code ?? -1,
+        log_path: logPath
+      });
+    });
+  });
+  const kill = (graceMs = 5000) => {
+    if (exited || !child.pid)
+      return;
+    try {
+      process.kill(-child.pid, "SIGTERM");
+    } catch {}
+    const escalate = setTimeout(() => {
+      if (exited || !child.pid)
+        return;
+      try {
+        process.kill(-child.pid, "SIGKILL");
+      } catch {}
+    }, graceMs);
+    escalate.unref?.();
+  };
+  return { pid: child.pid, done, kill };
+}
 function mintExecSecret() {
   return randomBytes2(32).toString("hex");
 }
@@ -16897,7 +16972,7 @@ ${source_default.red("Error:")}`);
     }
     console.log(`Cancelled task ${id}`);
   });
-  cmd.command("poll").description("Poll for open tasks available for claiming").option("--agent <id>", "Filter by agent definition ID").option("--limit <n>", "Max results", "10").action(async (opts) => {
+  cmd.command("poll").description("Poll for open tasks available for claiming").option("--agent <id>", "Filter by agent definition ID (human tokens only; ignored under agent auth)").option("--team <name>", "Poll a team's queue (name or UUID)").option("--limit <n>", "Max results", "10").action(async (opts) => {
     const ctx = getCtx();
     const limitN = parseInt(opts.limit, 10);
     if (isNaN(limitN) || limitN < 1) {
@@ -16906,6 +16981,8 @@ ${source_default.red("Error:")}`);
     const params = { limit: String(limitN) };
     if (opts.agent)
       params.agent_id = opts.agent;
+    if (opts.team)
+      params.team_id = opts.team;
     const items = await ctx.api.get("/api/tasks/poll", { params });
     if (isJson()) {
       console.log(JSON.stringify(items, null, 2));
@@ -17152,45 +17229,99 @@ init_errors();
 function sleep5(ms) {
   return new Promise((r) => setTimeout(r, ms));
 }
-async function runOnce(ctx, opts, handled) {
-  const tasks = await ctx.api.get("/api/tasks/poll", {
-    params: { agent_id: opts.agent, limit: String(opts.pollLimit ?? 5) }
+function sleepUnref(ms) {
+  return new Promise((r) => {
+    const t = setTimeout(r, ms);
+    t.unref?.();
   });
+}
+var DEFAULT_LEASE_S = 300;
+function heartbeatIntervalMs(leaseTimeoutS) {
+  const lease = typeof leaseTimeoutS === "number" && leaseTimeoutS > 0 ? leaseTimeoutS : DEFAULT_LEASE_S;
+  return Math.min(lease / 3, 60) * 1000;
+}
+async function runOnce(ctx, opts, handled) {
+  const params = { limit: String(opts.pollLimit ?? 5) };
+  if (opts.team)
+    params.team_id = opts.team;
+  const tasks = await ctx.api.get("/api/tasks/poll", { params });
   const candidates = Array.isArray(tasks) ? tasks : [];
-  const task = candidates.find((t) => (t.status ?? "open") === "open" && !handled?.has(t.id));
+  const matchesAgent = (t) => !opts.agent || t.assigned_agent_id === opts.agent || t.agent_definition_id === opts.agent;
+  const task = candidates.find((t) => (t.status ?? "open") === "open" && !handled?.has(t.id) && matchesAgent(t));
   if (!task)
     return { ran: false };
-  if (!opts.autoYes) {
+  if (!opts.allowHostExec) {
     process.stderr.write(source_default.yellow(`
-[runner] refused task ${task.id} — re-run with --yes to allow host execution
+[runner] refused task ${task.id} — re-run with --allow-host-exec to allow host execution
 `));
     return { ran: false, taskId: task.id, status: "refused" };
   }
   handled?.add(task.id);
   const claimed = await ctx.api.post(`/api/tasks/${encodeURIComponent(task.id)}/claim`, {});
   const goal = claimed.goal ?? task.goal ?? "";
+  const intervalMs = heartbeatIntervalMs(claimed.lease_timeout_s ?? DEFAULT_LEASE_S);
   process.stderr.write(source_default.dim(`
-[runner] claimed ${task.id} — running: ${goal}
+[runner] claimed ${task.id} — running: ${goal} (heartbeat every ${Math.round(intervalMs / 1000)}s)
 `));
   let result;
+  let cancelled = false;
   try {
-    result = await runHostCommand(goal, `task-${task.id}`, { cwd: opts.cwd });
+    const handle = await startHostCommand(goal, `task-${task.id}`, {
+      cwd: opts.cwd
+    });
+    const done = handle.done.catch((e) => ({
+      stdout: "",
+      stderr: String(e),
+      exit_code: -1
+    }));
+    for (;; ) {
+      const raced = await Promise.race([
+        done,
+        sleepUnref(intervalMs).then(() => null)
+      ]);
+      if (raced !== null) {
+        result = raced;
+        break;
+      }
+      let reply;
+      try {
+        reply = await ctx.api.post(`/api/tasks/${encodeURIComponent(task.id)}/heartbeat`, {});
+      } catch (e) {
+        process.stderr.write(source_default.yellow(`[runner] heartbeat failed for ${task.id} (job unaffected): ${String(e)}
+`));
+        continue;
+      }
+      if (reply && reply.signal === "cancel") {
+        process.stderr.write(source_default.yellow(`[runner] cancel signal for ${task.id} — killing process tree
+`));
+        handle.kill();
+        result = await done;
+        cancelled = true;
+        break;
+      }
+    }
   } catch (e) {
     result = { stdout: "", stderr: String(e), exit_code: -1 };
   }
   const exit_code = result.exit_code;
   const stdout = result.stdout || result.stderr || "";
-  const status = exit_code === 0 ? "completed" : "failed";
+  const status = cancelled ? "cancelled" : exit_code === 0 ? "completed" : "failed";
   await ctx.api.post(`/api/tasks/${encodeURIComponent(task.id)}/complete`, {
-    outcome: { stdout, exit_code },
+    outcome: cancelled ? { stdout, exit_code, cancelled: true } : { stdout, exit_code },
     status
   });
   process.stderr.write(source_default.dim(`[runner] completed ${task.id} — ${status} (exit ${exit_code})
 `));
   return { ran: true, taskId: task.id, status, exitCode: exit_code };
 }
+function startupEchoLine(who, opts) {
+  const identity2 = who ? who.kind === "agent" ? `agent ${who.agent_name ?? "?"} (${(who.agent_id ?? "").slice(0, 8)}…)` : `${who.kind} ${who.sub ?? ""}`.trim() : "identity unknown (whoami unavailable)";
+  const scope = opts.team ? `team:${opts.team}` : "direct";
+  const exec = opts.allowHostExec ? "host exec allowed" : "host exec refused (pass --allow-host-exec)";
+  return `[runner] authenticated as ${identity2}, scope ${scope}, cwd ${opts.cwd}, ${exec}${opts.once ? " — once" : ""}`;
+}
 function registerRunnerCommand(program2) {
-  program2.command("runner").description("Run as an external agent's executor: claim tasks and run them on this host.").requiredOption("--agent <id>", "Agent definition id this runner serves").option("--once", "Claim + run a single task, then exit").option("--poll-interval <ms>", "Poll interval when idle (ms)", "3000").option("--cwd <dir>", "Scoped workspace for task execution", process.cwd()).option("--yes", "Consent to run host commands (required to execute)").action(async (opts) => {
+  program2.command("runner").description("Run as an external agent's executor: claim tasks and run them on this host.").option("--agent <id>", "Deprecated: identity comes from the API token; applied as a client-side filter only").option("--team <name>", "Poll this team's queue (name or UUID) instead of direct-only").option("--once", "Claim + run a single task, then exit").option("--poll-interval <ms>", "Poll interval when idle (ms)", "3000").option("--cwd <dir>", "Scoped workspace for task execution", process.cwd()).option("--allow-host-exec", "Consent to run host commands (required to execute)").option("--yes", "Deprecated alias for --allow-host-exec").action(async (opts) => {
     const ctx = createContext({
       profileOverride: program2.opts().profile,
       verbose: program2.opts().verbose
@@ -17201,12 +17332,21 @@ function registerRunnerCommand(program2) {
     if (isNaN(pollInterval) || pollInterval < 250) {
       throw new CLIError("--poll-interval must be >= 250 (ms)", 4 /* Validation */);
     }
+    if (opts.agent) {
+      process.stderr.write(source_default.yellow(`[runner] --agent is deprecated — identity comes from the API token; the value is applied as a client-side filter only
+`));
+    }
     const runOpts = {
       agent: opts.agent,
+      team: opts.team,
       cwd: opts.cwd,
-      autoYes: !!opts.yes
+      allowHostExec: !!(opts.allowHostExec || opts.yes)
     };
-    process.stderr.write(source_default.dim(`[runner] serving agent ${opts.agent} (cwd ${opts.cwd})${opts.once ? " — once" : ""}
+    let who;
+    try {
+      who = await ctx.api.get("/api/tasks/whoami");
+    } catch {}
+    process.stderr.write(source_default.dim(`${startupEchoLine(who, { team: opts.team, cwd: opts.cwd, allowHostExec: runOpts.allowHostExec, once: !!opts.once })}
 `));
     if (opts.once) {
       await runOnce(ctx, runOpts);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aiaiai-pt/martha-cli",
-  "version": "0.29.0",
+  "version": "0.31.0",
   "description": "Terminal-first client for the Martha AI platform",
   "homepage": "https://docs.martha.nomadriver.co",
   "repository": {