@codyswann/lisa 4.84.11 → 4.86.0

package/plugins/lisa/skills/lisa-session-manager/scripts/launch.mjs

@@ -1,6 +1,8 @@
 /**
  * Starting and stopping the session manager, and the Telegram bot token it
- * needs.
+ * needs when Telegram is its notification channel. Telegram is optional
+ * (#4555): with `notify.provider` `"none"` the manager launches with no
+ * channel, no state dir and no plugin, and none of the isolation below applies.
  *
  * The official Telegram plugin keeps its token, pairing list, inbox and
  * `bot.pid` in one state dir (`TELEGRAM_STATE_DIR`, else
@@ -11,16 +13,20 @@
  *   env, and the shared default dir is refused outright;
  * - the plugin is enabled only through the manager's own `--settings`, never
  *   at user scope, so worker sessions never start a poller;
- * - the token lives in `<stateDir>/.env` (dir 0700, file 0600), is read from
- *   the operator's terminal with echo off, and never appears in argv, a
- *   return value, an error message or a log line.
+ * - the token lives in the project's secrets provider when one is configured
+ *   (token-store.mjs, #4555), reaching the manager's tmux session through
+ *   `source-file -` on stdin ({@link buildSourcedLaunch}); with no provider it
+ *   lives in `<stateDir>/.env` (dir 0700, file 0600). Either way it is read
+ *   from the operator's terminal with echo off (or the clipboard), and never
+ *   appears in argv, a return value, an error message or a log line.
  *
  * The tmux argv is returned as an array and handed straight to `spawnSync`.
  * With more than one command argument tmux runs the command directly rather
  * than through `sh -c`, so the settings JSON and the loop prompt are never
  * re-parsed by a shell.
  *
- * The state dir lives in state-dir.mjs and the token in token.mjs; both are
+ * The state dir lives in state-dir.mjs, the token in token.mjs, and the
+ * foreground and stdin renderings of the launch in launch-shell.mjs; all are
  * re-exported here so callers keep one import.
  *
  * Everything here is pure or takes injected seams. This module never reads
@@ -33,6 +39,11 @@ import path from "node:path";
 import { parseLoopInterval } from "./config.mjs";
 import { LaunchError } from "./state-dir.mjs";
 
+export {
+  buildForegroundCommand,
+  buildSourcedLaunch,
+  tmuxQuote,
+} from "./launch-shell.mjs";
 export {
   LaunchError,
   realpathExisting,
@@ -42,6 +53,8 @@ export {
   assertTokenPresent,
   buildStoreTokenCommand,
   loadPromptSecret,
+  readTokenFromClipboard,
+  readTokenFromPrompt,
   storeToken,
   storeTokenFromClipboard,
   validateBotToken,
@@ -54,26 +67,28 @@ export const TELEGRAM_PLUGIN_ID = "telegram@claude-plugins-official";
 /** Same slug rule the config validator applies to `sessionManager.name`. */
 const SESSION_NAME_PATTERN = /^[a-z0-9][a-z0-9_-]{0,63}$/;
 
-/** A `'` inside a single-quoted shell word: close, escaped quote, reopen. */
-const ESCAPED_QUOTE = "'\\''";
-
-/** An argument a POSIX shell reads back unchanged without quotes. */
-const SHELL_SAFE = /^[A-Za-z0-9_@%+=:,./-]+$/;
-
 /** The skill command each manager loop iteration runs. */
 const CYCLE_COMMAND = "/lisa:session-manager cycle";
 
+/** The notification providers a launch can be built for. */
+const LAUNCH_NOTIFY = new Set(["none", "telegram"]);
+
 /**
- * Settings blob for the manager session only: the Telegram plugin on, and
- * workers' messages accepted.
+ * Settings blob for the manager session only: workers' messages accepted,
+ * and the Telegram plugin on when Telegram is the notification channel. With
+ * no channel (`"none"`) the plugin is left out entirely, so the manager never
+ * starts a poller (#4555).
+ * @param {string} [notify] - Notification provider: "telegram" (default) or "none"
  * @returns {{ crossSessionInbound: "accept",
- *   enabledPlugins: Record<string, boolean> }} Fresh settings object
+ *   enabledPlugins?: Record<string, boolean> }} Fresh settings object
  */
-export function buildManagerSettings() {
-  return {
-    crossSessionInbound: "accept",
-    enabledPlugins: { [TELEGRAM_PLUGIN_ID]: true },
-  };
+export function buildManagerSettings(notify = "telegram") {
+  return notify === "telegram"
+    ? {
+        crossSessionInbound: "accept",
+        enabledPlugins: { [TELEGRAM_PLUGIN_ID]: true },
+      }
+    : { crossSessionInbound: "accept" };
 }
 
 /**
@@ -111,9 +126,15 @@ function assertAbsolute(label, value) {
  * `TELEGRAM_STATE_DIR` goes only into this session's env so no other session
  * ever sees it. `SM_SCRIPTS_DIR` lets every cycle's Bash find these scripts
  * without re-resolving the plugin root.
- * @param {{ name: string, root: string, stateDir: string, scriptsDir: string,
- *   interval: string }} input - Session name, project root, resolved state
- *   dir, this scripts dir, and the loop interval (e.g. "5m")
+ *
+ * With `notify: "none"` there is no channel: no `TELEGRAM_STATE_DIR`, no
+ * `--channels` and no plugin in the settings, and a `stateDir` is refused
+ * because only the telegram provider uses one (#4555).
+ * @param {{ name: string, root: string, stateDir?: string,
+ *   scriptsDir: string, interval: string,
+ *   notify?: string }} input - Session name, project root,
+ *   resolved state dir (telegram only), this scripts dir, the loop interval
+ *   (e.g. "5m") and the notification provider (default telegram)
  * @returns {string[]} argv for `spawnSync("tmux", argv)`
  */
 export function buildManagerLaunch({
@@ -122,10 +143,11 @@ export function buildManagerLaunch({
   stateDir,
   scriptsDir,
   interval,
+  notify = "telegram",
 }) {
   assertSessionName(name);
   assertAbsolute("root", root);
-  assertAbsolute("stateDir", stateDir);
+  const telegram = assertNotify(notify, stateDir) === "telegram";
   assertAbsolute("scriptsDir", scriptsDir);
   if (parseLoopInterval(interval) === null) {
     throw new LaunchError(
@@ -139,8 +161,7 @@ export function buildManagerLaunch({
     name,
     "-c",
     root,
-    "-e",
-    `TELEGRAM_STATE_DIR=${stateDir}`,
+    ...(telegram ? ["-e", `TELEGRAM_STATE_DIR=${stateDir}`] : []),
     "-e",
     `SM_SCRIPTS_DIR=${scriptsDir}`,
     "claude",
@@ -148,50 +169,38 @@ export function buildManagerLaunch({
     name,
     "--dangerously-skip-permissions",
     "--settings",
-    JSON.stringify(buildManagerSettings()),
-    "--channels",
-    `plugin:${TELEGRAM_PLUGIN_ID}`,
+    JSON.stringify(buildManagerSettings(notify)),
+    ...(telegram ? ["--channels", `plugin:${TELEGRAM_PLUGIN_ID}`] : []),
     // `--channels` is variadic (claude 2.1.296): without `--` it takes the
     // prompt as a second channel entry and claude exits 1 ("--channels
-    // entries must be tagged") before the session starts.
+    // entries must be tagged") before the session starts. Kept with no
+    // channel too, so the prompt is never read as an option.
     "--",
     `/loop ${interval} ${CYCLE_COMMAND}`,
   ];
 }
 
 /**
- * Quote one argument for a POSIX shell, for display only.
- * @param {string} value - Argument
- * @returns {string} Single-quoted argument
- */
-function shellQuote(value) {
-  return `'${value.replaceAll("'", ESCAPED_QUOTE)}'`;
-}
-
-/**
- * The shell line an operator runs to start the manager in the foreground,
- * from the tmux argv {@link buildManagerLaunch} returned: same cwd, the same
- * two session variables, the same claude argv. `start` prints it when the
- * tmux session dies at once, because tmux closes the window and claude's own
- * error goes with it. It is display text only and is never executed here.
- * The token is not in the argv, so it is not in this line either.
- * @param {readonly string[]} argv - Result of {@link buildManagerLaunch}
- * @returns {string} One shell line
+ * Refuse an unsupported provider, a telegram launch without an absolute state
+ * dir, and a state dir on a launch with no channel.
+ * @param {unknown} notify - Notification provider
+ * @param {unknown} stateDir - Resolved state dir, if any
+ * @returns {"telegram" | "none"} The provider
  */
-export function buildForegroundCommand(argv) {
-  const claudeAt = argv.indexOf("claude");
-  const head = argv.slice(0, claudeAt);
-  const cwd = head[head.indexOf("-c") + 1];
-  const vars = head
-    .filter((_, index) => head[index - 1] === "-e")
-    .map(entry => {
-      const at = entry.indexOf("=");
-      return `${entry.slice(0, at)}=${shellQuote(entry.slice(at + 1))}`;
-    });
-  const command = argv
-    .slice(claudeAt)
-    .map(arg => (SHELL_SAFE.test(arg) ? arg : shellQuote(arg)));
-  return `cd ${shellQuote(cwd)} && ${[...vars, ...command].join(" ")}`;
+function assertNotify(notify, stateDir) {
+  if (!LAUNCH_NOTIFY.has(notify)) {
+    throw new LaunchError(
+      `notify "${String(notify)}" is not supported; use "none" or "telegram".`
+    );
+  }
+  if (notify === "telegram") {
+    assertAbsolute("stateDir", stateDir);
+  } else if (stateDir !== undefined) {
+    throw new LaunchError(
+      `stateDir is only used with the telegram provider; notify is "none".`
+    );
+  }
+  return notify;
 }
 
 /**

package/plugins/lisa/skills/lisa-session-manager/scripts/ledger-questions.mjs

@@ -0,0 +1,252 @@
+/**
+ * The ledger side of "mark and move on" (CodySwannGT/lisa#4555, part 3):
+ * recording that an item's human-needed mark was read back on the tracker,
+ * queueing a human's answer for the next cycle to deliver, and listing what
+ * is waiting on a person.
+ *
+ * The manager records a question in the ledger BEFORE it writes the tracker
+ * marker, then records `marked` once the marker is read back. A crash in
+ * between leaves a pending question with `markedAt: null`, which the next
+ * cycle (and `lisa doctor`) can see and finish, rather than a marker on the
+ * tracker the ledger knows nothing about and so would never remove.
+ *
+ * Recording and clearing the question itself ({@link setPendingQuestion},
+ * {@link clearPendingQuestion}) lives here too; ledger.mjs re-exports both.
+ * Writes go through ledger.mjs's atomic read-transform-write.
+ * @module session-manager/ledger-questions
+ */
+import { HUMAN_NEEDED_KINDS } from "./human-needed.mjs";
+import {
+  placeholderItem,
+  requireItem,
+  updateLedger,
+  withItem,
+} from "./ledger.mjs";
+
+/** Ways an item can be marked human-needed. */
+const MARKER_TYPES = new Set(["label", "role"]);
+
+/** A tracker comment id: GitHub numeric or node id, Jira id, Linear uuid. */
+const COMMENT_ID = /^[A-Za-z0-9_.:-]{1,200}$/;
+
+/** Where a queued answer came from. */
+const ANSWER_SOURCES = new Set(["cli", "item", "channel"]);
+
+/**
+ * The item's pending question, or a refusal naming the ref.
+ * @param {import("./ledger.mjs").LedgerItem} entry - Ledger item
+ * @param {string} ref - Its ref
+ * @returns {NonNullable<import("./ledger.mjs").LedgerItem["pendingQuestion"]>}
+ *   The pending question
+ */
+function requirePending(entry, ref) {
+  if (!entry.pendingQuestion) {
+    throw new Error(`${ref} has no pending question in the ledger`);
+  }
+  return entry.pendingQuestion;
+}
+
+/**
+ * Record that the item's human-needed marker was applied and read back.
+ * @param {string} projectRoot - Absolute project root
+ * `commentId` is the id of the question comment the manager posted, read
+ * back from `lisa-tracker-write`. It is kept in `managerCommentIds` so
+ * `item-answer` never takes the manager's own comment as an answer, whoever
+ * the tracker says wrote it and whatever it says.
+ * @param {{ref: string, markerType: string, marker: string,
+ *   commentId?: string}} mark - The mark
+ * @param {import("./ledger.mjs").LedgerSeams} [seams] - Injected seams
+ * @returns {Promise<import("./ledger.mjs").LedgerItem>} The updated item
+ */
+export function recordMarked(
+  projectRoot,
+  { ref, markerType, marker, commentId },
+  seams
+) {
+  if (!MARKER_TYPES.has(markerType)) {
+    return Promise.reject(new Error("--marker-type must be label or role."));
+  }
+  if (typeof marker !== "string" || marker.trim() === "") {
+    return Promise.reject(new Error("--marker must name the label or role."));
+  }
+  if (commentId !== undefined && !COMMENT_ID.test(commentId)) {
+    return Promise.reject(
+      new Error("--comment-id must be the tracker's comment id.")
+    );
+  }
+  return updateLedger(projectRoot, seams, (ledger, at) => {
+    const previous = requireItem(ledger, ref);
+    const pending = requirePending(previous, ref);
+    return withItem(ledger, ref, {
+      ...previous,
+      pendingQuestion: {
+        ...pending,
+        markerType,
+        marker,
+        markedAt: at,
+        managerCommentIds: [
+          ...new Set([
+            ...(pending.managerCommentIds ?? []),
+            ...(commentId === undefined ? [] : [commentId]),
+          ]),
+        ],
+      },
+      history: [
+        ...(previous.history ?? []),
+        { event: "marked", at, markerType, marker },
+      ],
+    });
+  });
+}
+
+/**
+ * Queue a human's answer on a pending question. The manager delivers it on
+ * its next cycle (SendMessage, or `resume`), then clears the question.
+ * @param {string} projectRoot - Absolute project root
+ * @param {{ref: string, source: string, text: string, author?: string|null}}
+ *   answer - The answer
+ * @param {import("./ledger.mjs").LedgerSeams} [seams] - Injected seams
+ * @returns {Promise<import("./ledger.mjs").LedgerItem>} The updated item
+ */
+export function queueAnswer(
+  projectRoot,
+  { ref, source, text, author = null },
+  seams
+) {
+  if (!ANSWER_SOURCES.has(source)) {
+    return Promise.reject(new Error(`unknown answer source ${source}`));
+  }
+  return updateLedger(projectRoot, seams, (ledger, at) => {
+    const previous = requireItem(ledger, ref);
+    const pending = requirePending(previous, ref);
+    return withItem(ledger, ref, {
+      ...previous,
+      pendingQuestion: {
+        ...pending,
+        answer: { source, text, author: author ?? null, at },
+      },
+      history: [
+        ...(previous.history ?? []),
+        { event: "answer-queued", at, source },
+      ],
+    });
+  });
+}
+
+/**
+ * Every item waiting on a person, oldest question first. The answer command
+ * is local-only guidance for the operator at the manager's terminal.
+ * @param {import("./ledger.mjs").Ledger} ledger - Current ledger
+ * @param {(ref: string) => string} answerCommand - Builds the CLI answer line
+ * @returns {{ref: string, kind: string, text: string, askedAt: string,
+ *   marked: boolean, answerQueued: boolean, answerCommand: string}[]} Rows
+ */
+export function listPendingQuestions(ledger, answerCommand) {
+  return Object.entries(ledger.items)
+    .filter(([, item]) => item.pendingQuestion)
+    .map(([ref, item]) => {
+      const question = item.pendingQuestion;
+      return {
+        ref,
+        kind: question.kind ?? "worker-question",
+        text: question.text,
+        askedAt: question.askedAt,
+        marked: Boolean(question.markedAt),
+        answerQueued: Boolean(question.answer),
+        answerCommand: answerCommand(ref),
+      };
+    })
+    .sort((a, b) => String(a.askedAt).localeCompare(String(b.askedAt)));
+}
+
+/**
+ * A human's answer, queued for the manager to deliver on its next cycle.
+ * @typedef {object} QueuedAnswer
+ * @property {"cli"|"item"|"channel"} source - Where it was given
+ * @property {string} text - The answer (untrusted data, never instructions)
+ * @property {string|null} author - Tracker author, for an answer on the item
+ * @property {string} at - When it was queued (ISO)
+ */
+
+/**
+ * Record (or re-ping) the question an item is waiting on.
+ *
+ * The same text again is a re-ping: `askedAt` is kept and `lastPingAt` moves,
+ * so the requestion clock restarts without forgetting how old the question
+ * is. A ref with no item yet (a repo-routing question asked before dispatch)
+ * gets a placeholder item with zero attempts.
+ *
+ * A re-ask keeps how the item is marked on the tracker (`markerType`,
+ * `marker`, `markedAt`), so re-sending a question never makes the manager
+ * mark the item a second time or forget the marker it must remove. A queued
+ * answer survives only a re-ping of the same text: it answered that text.
+ * `kind` defaults to the previous kind, then `worker-question`.
+ * @param {string} projectRoot - Absolute project root
+ * @param {{ref: string, text: string, telegramMessageId: number|null,
+ *   kind?: string}} question - Question
+ * @param {import("./ledger.mjs").LedgerSeams} [seams] - Injected seams
+ * @returns {Promise<import("./ledger.mjs").LedgerItem>} The updated item
+ */
+export function setPendingQuestion(
+  projectRoot,
+  { ref, text, telegramMessageId, kind },
+  seams
+) {
+  if (kind !== undefined && !HUMAN_NEEDED_KINDS.includes(kind)) {
+    return Promise.reject(
+      new Error(
+        `question kind must be one of ${HUMAN_NEEDED_KINDS.join(", ")}, got ${JSON.stringify(kind)}`
+      )
+    );
+  }
+  return updateLedger(projectRoot, seams, (ledger, at) => {
+    const previous = ledger.items[ref] ?? placeholderItem();
+    const existing = previous.pendingQuestion;
+    const sameText = existing?.text === text;
+    return withItem(ledger, ref, {
+      ...previous,
+      pendingQuestion: {
+        text,
+        kind: kind ?? existing?.kind ?? "worker-question",
+        askedAt: sameText ? existing.askedAt : at,
+        lastPingAt: at,
+        telegramMessageId: telegramMessageId ?? null,
+        markerType: existing?.markerType ?? null,
+        marker: existing?.marker ?? null,
+        markedAt: existing?.markedAt ?? null,
+        managerCommentIds: existing?.managerCommentIds ?? [],
+        answer: sameText ? (existing.answer ?? null) : null,
+      },
+      history: [...(previous.history ?? []), { event: "question", at }],
+    });
+  });
+}
+
+/**
+ * Clear an item's pending question, once its answer has been delivered and
+ * the manager's own marker removed. `resetAttempts` zeroes the attempt count:
+ * an `exhausted` item a human has answered starts again from attempt one
+ * instead of being exhausted again on its first stall.
+ * @param {string} projectRoot - Absolute project root
+ * @param {{ref: string, resetAttempts?: boolean}} target - Item
+ * @param {import("./ledger.mjs").LedgerSeams} [seams] - Injected seams
+ * @returns {Promise<import("./ledger.mjs").LedgerItem>} The updated item
+ */
+export function clearPendingQuestion(
+  projectRoot,
+  { ref, resetAttempts = false },
+  seams
+) {
+  return updateLedger(projectRoot, seams, (ledger, at) => {
+    const previous = requireItem(ledger, ref);
+    return withItem(ledger, ref, {
+      ...previous,
+      pendingQuestion: null,
+      ...(resetAttempts ? { attempts: 0 } : {}),
+      history: [
+        ...(previous.history ?? []),
+        { event: "answered", at, ...(resetAttempts ? { reset: true } : {}) },
+      ],
+    });
+  });
+}

package/plugins/lisa/skills/lisa-session-manager/scripts/ledger.mjs

@@ -21,6 +21,14 @@ import { randomUUID } from "node:crypto";
 import * as nodeFs from "node:fs/promises";
 import { dirname, join } from "node:path";
 
+// The question writers live in ledger-questions.mjs (#4555), re-exported so
+// callers keep one import. They are called, never evaluated, at load time, so
+// the import cycle back to this module's primitives is safe.
+export {
+  clearPendingQuestion,
+  setPendingQuestion,
+} from "./ledger-questions.mjs";
+
 /** Shape version, bumped only on an incompatible change. */
 const LEDGER_VERSION = 1;
 
@@ -43,6 +51,16 @@ const FINISH_STATUSES = new Set(["DONE", "FAILED"]);
  * @property {string} askedAt - When it was first asked (ISO)
  * @property {string} lastPingAt - When it was last (re-)sent (ISO)
  * @property {number|null} telegramMessageId - Telegram message carrying it
+ * @property {string} [kind] - Why a human is needed: worker-question |
+ *   repo-route | exhausted | decision (#4555)
+ * @property {"label"|"role"|null} [markerType] - How the item is marked
+ *   human-needed on the tracker, once the manager has read the mark back
+ * @property {string|null} [marker] - The label or role value it carries
+ * @property {string|null} [markedAt] - When the mark was read back (ISO);
+ *   null means recorded but not yet marked on the tracker
+ * @property {string[]} [managerCommentIds] - Ids of the comments the manager
+ *   posted on the item (its question comment), never read as an answer
+ * @property {import("./ledger-questions.mjs").QueuedAnswer|null} [answer] - An answer waiting to be delivered
  */
 
 /**
@@ -199,7 +217,7 @@ export async function writeLedger(projectRoot, ledger, seams) {
  * @param {(ledger: Ledger, at: string) => {ledger: Ledger, result: T}} transform - Pure update
  * @returns {Promise<T>} The transform's result
  */
-async function updateLedger(projectRoot, seams, transform) {
+export async function updateLedger(projectRoot, seams, transform) {
   const { now } = resolveSeams(seams);
   const current = await readLedger(projectRoot, seams);
   const { ledger, result } = transform(current, now().toISOString());
@@ -214,7 +232,7 @@ async function updateLedger(projectRoot, seams, transform) {
  * @param {LedgerItem} entry - New item
  * @returns {{ledger: Ledger, result: LedgerItem}} Update
  */
-function withItem(ledger, ref, entry) {
+export function withItem(ledger, ref, entry) {
   return {
     ledger: { ...ledger, items: { ...ledger.items, [ref]: entry } },
     result: entry,
@@ -227,7 +245,7 @@ function withItem(ledger, ref, entry) {
  * @param {string} ref - Item key
  * @returns {LedgerItem} The item
  */
-function requireItem(ledger, ref) {
+export function requireItem(ledger, ref) {
   const entry = ledger.items[ref];
   if (!entry)
     throw new Error(
@@ -240,7 +258,7 @@ function requireItem(ledger, ref) {
  * A ledger item for a ref the manager has asked about but not dispatched.
  * @returns {LedgerItem} Placeholder item
  */
-function placeholderItem() {
+export function placeholderItem() {
   return {
     repo: null,
     worker: null,
@@ -291,58 +309,6 @@ export function recordSpawn(
   });
 }
 
-/**
- * Record (or re-ping) the question an item is waiting on.
- *
- * The same text again is a re-ping: `askedAt` is kept and `lastPingAt` moves,
- * so the requestion clock restarts without forgetting how old the question
- * is. A ref with no item yet (a repo-routing question asked before dispatch)
- * gets a placeholder item with zero attempts.
- * @param {string} projectRoot - Absolute project root
- * @param {{ref: string, text: string, telegramMessageId: number|null}} question - Question
- * @param {LedgerSeams} [seams] - Injected seams
- * @returns {Promise<LedgerItem>} The updated item
- */
-export function setPendingQuestion(
-  projectRoot,
-  { ref, text, telegramMessageId },
-  seams
-) {
-  return updateLedger(projectRoot, seams, (ledger, at) => {
-    const previous = ledger.items[ref] ?? placeholderItem();
-    const existing = previous.pendingQuestion;
-    const askedAt = existing?.text === text ? existing.askedAt : at;
-    return withItem(ledger, ref, {
-      ...previous,
-      pendingQuestion: {
-        text,
-        askedAt,
-        lastPingAt: at,
-        telegramMessageId: telegramMessageId ?? null,
-      },
-      history: [...(previous.history ?? []), { event: "question", at }],
-    });
-  });
-}
-
-/**
- * Clear an item's pending question, once its answer has been delivered.
- * @param {string} projectRoot - Absolute project root
- * @param {{ref: string}} target - Item
- * @param {LedgerSeams} [seams] - Injected seams
- * @returns {Promise<LedgerItem>} The updated item
- */
-export function clearPendingQuestion(projectRoot, { ref }, seams) {
-  return updateLedger(projectRoot, seams, (ledger, at) => {
-    const previous = requireItem(ledger, ref);
-    return withItem(ledger, ref, {
-      ...previous,
-      pendingQuestion: null,
-      history: [...(previous.history ?? []), { event: "answered", at }],
-    });
-  });
-}
-
 /**
  * Record this cycle's hash of the worker's logs. `lastProgressAt` moves only
  * when the hash changed, which is what "no output for N minutes" measures.