@ricsam/r5d-worker 0.0.107 → 0.0.109

package/dist/mjs/package.json

@@ -1,5 +1,5 @@
 {
   "name": "@ricsam/r5d-worker",
-  "version": "0.0.107",
+  "version": "0.0.109",
   "type": "module"
 }

package/dist/mjs/plan-lint.mjs

@@ -0,0 +1,129 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import picomatch from "picomatch";
+import { getTasksSectionRange, PLAN_TASK_LINE_REGEX } from "./plan-parser.mjs";
+import { PLAN_EXTENSION } from "./plan-paths.mjs";
+import { PLAN_TASK_ID_REGEX } from "./plan-parser.mjs";
+const LEGACY_SCHEMA_FIELD_REGEX = /^\s*(type|status|parent|phase|discovered_problem)\s*:/m;
+function lintPlanContent(planId, content) {
+  const errors = [];
+  const lines = content.split(/\r?\n/);
+  if (/^---(?:\r?\n|$)/.test(content)) {
+    errors.push({
+      planId,
+      severity: "error",
+      message: "YAML frontmatter is not supported. Use plain Markdown with a ## Tasks checklist.",
+      line: 1
+    });
+  }
+  if (LEGACY_SCHEMA_FIELD_REGEX.test(content)) {
+    errors.push({
+      planId,
+      severity: "error",
+      message: "Legacy plan schema fields are not supported. Remove type/status/parent/phase/discovered_problem metadata."
+    });
+  }
+  const titleLineIndex = lines.findIndex((line) => /^# .+\S\s*$/.test(line));
+  if (titleLineIndex === -1) {
+    errors.push({
+      planId,
+      severity: "error",
+      message: "Plan must start with or contain an H1 title, for example '# Implementation Plan'."
+    });
+  }
+  const range = getTasksSectionRange(content);
+  if (!range) {
+    errors.push({
+      planId,
+      severity: "error",
+      message: "Plan is missing a ## Tasks section."
+    });
+    return errors;
+  }
+  const taskIds = /* @__PURE__ */ new Set();
+  let taskCount = 0;
+  for (let index = range.startIndex + 1; index < range.endIndex; index += 1) {
+    const line = lines[index] ?? "";
+    if (line.trim() === "") continue;
+    const match = line.match(PLAN_TASK_LINE_REGEX);
+    if (!match || !match[3].trim()) {
+      errors.push({
+        planId,
+        severity: "error",
+        line: index + 1,
+        message: 'Malformed task line. Use "- [ ] task-id: Description" or "- [x] task-id: Description".'
+      });
+      continue;
+    }
+    taskCount += 1;
+    const taskId = match[2];
+    if (taskIds.has(taskId)) {
+      errors.push({
+        planId,
+        severity: "error",
+        line: index + 1,
+        message: `Duplicate task id "${taskId}".`
+      });
+    }
+    taskIds.add(taskId);
+  }
+  if (taskCount === 0) {
+    errors.push({
+      planId,
+      severity: "error",
+      message: "Plan must include at least one task in the ## Tasks section.",
+      line: range.startIndex + 1
+    });
+  }
+  return errors;
+}
+async function lintPlans(plansDir, glob) {
+  const errors = [];
+  let entries;
+  try {
+    entries = await fs.readdir(plansDir, { withFileTypes: true });
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+    entries = [];
+  }
+  const matches = glob ? picomatch(glob) : null;
+  let lintedPlanCount = 0;
+  for (const entry of entries) {
+    if (!entry.isFile() || !entry.name.endsWith(PLAN_EXTENSION)) continue;
+    const planId = entry.name.slice(0, -PLAN_EXTENSION.length);
+    if (!PLAN_TASK_ID_REGEX.test(planId) || matches && !matches(entry.name) && !matches(planId)) continue;
+    const content = await fs.readFile(path.join(plansDir, entry.name), "utf8");
+    lintedPlanCount += 1;
+    errors.push(...lintPlanContent(planId, content));
+  }
+  return {
+    type: "plan_lint",
+    errors,
+    errorCount: errors.filter((error) => error.severity === "error").length,
+    warningCount: errors.filter((error) => error.severity === "warning").length,
+    lintedPlanCount
+  };
+}
+function formatPlanLintErrors(errors) {
+  if (errors.length === 0) return "";
+  const lines = ["## Plan Lint Errors", ""];
+  const byPlan = /* @__PURE__ */ new Map();
+  for (const error of errors) {
+    byPlan.set(error.planId, [...byPlan.get(error.planId) ?? [], error]);
+  }
+  for (const [planId, planErrors] of byPlan) {
+    lines.push(`### ${planId}.plan.md`);
+    for (const error of planErrors) {
+      const location = error.line ? ` line ${error.line}` : "";
+      lines.push(`- ${error.severity.toUpperCase()}${location}: ${error.message}`);
+    }
+    lines.push("");
+  }
+  lines.push("Fix these issues by editing the Markdown plan file.");
+  return lines.join("\n");
+}
+export {
+  formatPlanLintErrors,
+  lintPlanContent,
+  lintPlans
+};

package/dist/mjs/plan-parser.mjs

@@ -0,0 +1,94 @@
+const PLAN_TASK_ID_REGEX = /^[a-z0-9][a-z0-9-]*$/;
+const PLAN_TASK_LINE_REGEX = /^- \[( |x)\] ([a-z0-9][a-z0-9-]*): (.+)$/;
+const PLAN_TASKS_HEADING_REGEX = /^## Tasks\s*$/;
+function getPlanMetadata(content) {
+  const title = content.split(/\r?\n/).map((line) => line.match(/^# (.+)$/)?.[1]?.trim()).find((value) => Boolean(value));
+  return { title: title || "Untitled Plan" };
+}
+function getTasksSectionRange(content) {
+  const lines = content.split(/\r?\n/);
+  const startIndex = lines.findIndex((line) => PLAN_TASKS_HEADING_REGEX.test(line));
+  if (startIndex === -1) return null;
+  let endIndex = lines.length;
+  for (let index = startIndex + 1; index < lines.length; index += 1) {
+    if (/^##\s+/.test(lines[index] ?? "")) {
+      endIndex = index;
+      break;
+    }
+  }
+  return { startIndex, endIndex };
+}
+function parseMarkdownPlan(content, planId) {
+  const lines = content.split(/\r?\n/);
+  const { title } = getPlanMetadata(content);
+  const range = getTasksSectionRange(content);
+  const tasks = [];
+  if (range) {
+    for (let index = range.startIndex + 1; index < range.endIndex; index += 1) {
+      const line = lines[index] ?? "";
+      const match = line.match(PLAN_TASK_LINE_REGEX);
+      if (!match) continue;
+      const description = match[3].trim();
+      if (!description) continue;
+      tasks.push({
+        id: match[2],
+        description,
+        checked: match[1] === "x",
+        lineNumber: index + 1
+      });
+    }
+  }
+  const currentTask = tasks.find((task) => !task.checked) ?? null;
+  return {
+    id: planId,
+    title,
+    content,
+    tasks,
+    currentTask,
+    complete: tasks.length > 0 && tasks.every((task) => task.checked),
+    tasksStartLine: range ? range.startIndex + 1 : null,
+    tasksEndLine: range ? range.endIndex : null
+  };
+}
+const parsePlan = parseMarkdownPlan;
+function createPlanMarkdown(planId, title = formatPlanTitle(planId)) {
+  return `# ${title}
+
+Brief implementation notes.
+
+## Tasks
+`;
+}
+function updateTaskCheckbox(content, taskId, checked) {
+  if (!PLAN_TASK_ID_REGEX.test(taskId)) {
+    throw new Error(`Invalid task id: ${taskId}`);
+  }
+  const lines = content.split(/\r?\n/);
+  const range = getTasksSectionRange(content);
+  if (!range) {
+    throw new Error("Plan is missing a ## Tasks section.");
+  }
+  for (let index = range.startIndex + 1; index < range.endIndex; index += 1) {
+    const line = lines[index] ?? "";
+    const match = line.match(PLAN_TASK_LINE_REGEX);
+    if (!match || match[2] !== taskId) continue;
+    lines[index] = `- [${checked ? "x" : " "}] ${match[2]}: ${match[3].trim()}`;
+    return lines.join("\n");
+  }
+  throw new Error(`Task not found in plan: ${taskId}`);
+}
+function formatPlanTitle(planId) {
+  return planId.split("-").filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join(" ");
+}
+export {
+  PLAN_TASKS_HEADING_REGEX,
+  PLAN_TASK_ID_REGEX,
+  PLAN_TASK_LINE_REGEX,
+  createPlanMarkdown,
+  formatPlanTitle,
+  getPlanMetadata,
+  getTasksSectionRange,
+  parseMarkdownPlan,
+  parsePlan,
+  updateTaskCheckbox
+};

package/dist/mjs/plan-paths.mjs

@@ -0,0 +1,25 @@
+import { PLAN_TASK_ID_REGEX } from "./plan-parser.mjs";
+const PLAN_EXTENSION = ".plan.md";
+function validatePlanId(planId) {
+  if (!PLAN_TASK_ID_REGEX.test(planId)) throw new Error(`Invalid plan id: ${planId}`);
+}
+function assertPlanTarget(target) {
+  if (target.type === "workspace" && target.rootProfile !== "visible_projects") {
+    throw new Error("Ordinary plans are unavailable in canonical synchronization sessions");
+  }
+}
+function getWorkerPlansPath(target) {
+  assertPlanTarget(target);
+  return target.type === "project" ? "$R5D_ROOT/plans/$R5D_PROJECT_ID/$R5D_BRANCH_NAME" : "$R5D_ROOT/plans/workspace";
+}
+function getWorkerPlanPath(target, planId) {
+  validatePlanId(planId);
+  return `${getWorkerPlansPath(target)}/${planId}${PLAN_EXTENSION}`;
+}
+export {
+  PLAN_EXTENSION,
+  assertPlanTarget,
+  getWorkerPlanPath,
+  getWorkerPlansPath,
+  validatePlanId
+};

package/dist/mjs/recovery-output-window.mjs

@@ -0,0 +1,53 @@
+const keyOf = (runId, stream) => `${runId}:${stream}`;
+class WorkerOutputWindow {
+  constructor(windowBytes = 1024 * 1024) {
+    this.windowBytes = windowBytes;
+  }
+  windowBytes;
+  sent = /* @__PURE__ */ new Map();
+  acknowledged = /* @__PURE__ */ new Map();
+  outstanding = 0;
+  reset(cursors) {
+    this.sent.clear();
+    this.acknowledged.clear();
+    this.outstanding = 0;
+    for (const cursor of cursors) {
+      for (const stream of ["stdout", "stderr"]) {
+        const offset = stream === "stdout" ? cursor.stdoutBytes : cursor.stderrBytes;
+        this.sent.set(keyOf(cursor.runId, stream), offset);
+        this.acknowledged.set(keyOf(cursor.runId, stream), offset);
+      }
+    }
+  }
+  send(frame, send, bufferedAmount = 0) {
+    const key = keyOf(frame.runId, frame.stream);
+    const sent = this.sent.get(key) ?? 0;
+    const bytes = Buffer.from(frame.data, "utf8");
+    const end = frame.offset + bytes.length;
+    if (end <= sent) return true;
+    if (frame.offset > sent) return false;
+    let cursor = sent;
+    while (cursor < end) {
+      let count = Math.min(end - cursor, 64 * 1024, this.windowBytes - this.outstanding);
+      while (count > 0 && ((bytes[cursor - frame.offset + count] ?? 0) & 192) === 128) count -= 1;
+      if (count <= 0 || bufferedAmount >= this.windowBytes) return false;
+      const data = bytes.subarray(cursor - frame.offset, cursor - frame.offset + count).toString("utf8");
+      if (!send({ ...frame, offset: cursor, data })) return false;
+      cursor += count;
+      this.sent.set(key, cursor);
+      this.outstanding += count;
+    }
+    return true;
+  }
+  acknowledge(runId, stream, offset) {
+    if (!Number.isSafeInteger(offset) || offset < 0) return;
+    const key = keyOf(runId, stream);
+    const previous = this.acknowledged.get(key) ?? 0;
+    const next = Math.max(previous, Math.min(this.sent.get(key) ?? 0, offset));
+    this.acknowledged.set(key, next);
+    this.outstanding = Math.max(0, this.outstanding - (next - previous));
+  }
+}
+export {
+  WorkerOutputWindow
+};

package/dist/mjs/recovery-protocol.mjs

@@ -0,0 +1,6 @@
+const WORKER_RESUMABLE_PROTOCOL = 1;
+const WORKER_RECOVERY_TIMEOUT_MS = 5 * 60 * 1e3;
+export {
+  WORKER_RECOVERY_TIMEOUT_MS,
+  WORKER_RESUMABLE_PROTOCOL
+};

package/dist/mjs/recovery-store.mjs

@@ -0,0 +1,194 @@
+import { Database } from "bun:sqlite";
+import fs from "node:fs";
+import path from "node:path";
+import { createHash } from "node:crypto";
+function workerOperationDigest(message) {
+  const canonical = (value) => {
+    if (Array.isArray(value)) return value.map(canonical);
+    if (value && typeof value === "object")
+      return Object.fromEntries(
+        Object.entries(value).filter(([, item]) => item !== void 0).sort(([a], [b]) => a.localeCompare(b)).map(([key, item]) => [key, canonical(item)])
+      );
+    return value;
+  };
+  const { requestId: _requestId, ...identity } = message;
+  return createHash("sha256").update(JSON.stringify(canonical(identity))).digest("hex");
+}
+class WorkerRecoveryStore {
+  db;
+  ledgerId;
+  constructor(filename) {
+    fs.mkdirSync(path.dirname(filename), { recursive: true, mode: 448 });
+    this.db = new Database(filename, { create: true });
+    fs.chmodSync(filename, 384);
+    this.db.exec(`PRAGMA journal_mode=WAL; PRAGMA synchronous=FULL;
+      CREATE TABLE IF NOT EXISTS metadata (key TEXT PRIMARY KEY, value TEXT NOT NULL);
+      CREATE TABLE IF NOT EXISTS operations (request_id TEXT PRIMARY KEY, run_id TEXT, session_id TEXT, request_type TEXT NOT NULL, digest TEXT NOT NULL, state TEXT NOT NULL, response TEXT);
+      CREATE UNIQUE INDEX IF NOT EXISTS operation_run_start ON operations(run_id) WHERE request_type='exec_start';
+      CREATE TABLE IF NOT EXISTS aliases (request_id TEXT PRIMARY KEY, operation_id TEXT NOT NULL);
+      CREATE TABLE IF NOT EXISTS streams (run_id TEXT NOT NULL, stream TEXT NOT NULL, bytes INTEGER NOT NULL DEFAULT 0, acknowledged INTEGER NOT NULL DEFAULT 0, PRIMARY KEY(run_id, stream));
+      CREATE TABLE IF NOT EXISTS output (run_id TEXT NOT NULL, stream TEXT NOT NULL, offset INTEGER NOT NULL, bytes INTEGER NOT NULL, data TEXT NOT NULL, PRIMARY KEY(run_id, stream, offset));
+      CREATE TABLE IF NOT EXISTS terminals (run_id TEXT PRIMARY KEY, message TEXT NOT NULL);
+      CREATE TABLE IF NOT EXISTS cancelled_requests (request_id TEXT PRIMARY KEY);
+    `);
+    this.db.run("INSERT OR IGNORE INTO metadata(key,value) VALUES ('ledgerId',?)", [crypto.randomUUID()]);
+    this.ledgerId = this.db.query("SELECT value FROM metadata WHERE key='ledgerId'").get().value;
+    this.db.run("UPDATE operations SET state='unknown' WHERE state IN ('accepted','preparing','running')");
+  }
+  close() {
+    this.db.close();
+  }
+  row(requestId) {
+    return this.db.query("SELECT * FROM operations WHERE request_id=? OR request_id=(SELECT operation_id FROM aliases WHERE request_id=?)").get(requestId, requestId);
+  }
+  admit(message) {
+    const digest = workerOperationDigest(message);
+    let existing = this.row(message.requestId);
+    if (!existing && message.type === "exec_start" && typeof message.runId === "string")
+      existing = this.db.query("SELECT * FROM operations WHERE run_id=? AND request_type='exec_start'").get(message.runId);
+    if (existing) {
+      if (existing.digest !== digest) return "conflict";
+      this.db.run("INSERT OR IGNORE INTO aliases(request_id, operation_id) VALUES (?,?)", [message.requestId, existing.request_id]);
+      return existing.state === "unknown" ? "unknown" : "duplicate";
+    }
+    this.db.run("INSERT INTO operations(request_id, run_id, session_id, request_type, digest, state) VALUES (?,?,?,?,?,'accepted')", [
+      message.requestId,
+      typeof message.runId === "string" ? message.runId : null,
+      typeof message.sessionId === "string" ? message.sessionId : null,
+      message.type,
+      digest
+    ]);
+    return "new";
+  }
+  isUnknown(requestId) {
+    return this.row(requestId)?.state === "unknown";
+  }
+  unknown(requestId) {
+    const row = this.row(requestId);
+    if (row) this.db.run("UPDATE operations SET state='unknown' WHERE request_id=?", [row.request_id]);
+  }
+  unknownRun(runId) {
+    this.db.run("UPDATE operations SET state='unknown' WHERE run_id=? AND request_type IN ('exec_start','exec')", [runId]);
+  }
+  record(message) {
+    if (message.type === "exec_output" && typeof message.runId === "string" && (message.stream === "stdout" || message.stream === "stderr") && typeof message.data === "string") {
+      const runId = message.runId, stream = message.stream, data = message.data;
+      const offset = this.db.transaction(() => {
+        this.db.run("INSERT OR IGNORE INTO streams(run_id, stream) VALUES (?,?)", [runId, stream]);
+        const offset2 = this.db.query("SELECT bytes FROM streams WHERE run_id=? AND stream=?").get(runId, stream).bytes;
+        const bytes = Buffer.byteLength(data);
+        if (bytes) {
+          this.db.run("INSERT INTO output(run_id, stream, offset, bytes, data) VALUES (?,?,?,?,?)", [runId, stream, offset2, bytes, data]);
+          this.db.run("UPDATE streams SET bytes=bytes+? WHERE run_id=? AND stream=?", [bytes, runId, stream]);
+        }
+        return offset2;
+      })();
+      return { ...message, offset };
+    }
+    if ((message.type === "exec_exit" || message.type === "exec_error") && typeof message.runId === "string") {
+      const terminal = { ...message, ...this.lengths(message.runId) };
+      this.db.transaction(() => {
+        this.db.run("INSERT OR REPLACE INTO terminals(run_id,message) VALUES (?,?)", [message.runId, JSON.stringify(terminal)]);
+        this.db.run("UPDATE operations SET state='completed' WHERE run_id=? AND request_type='exec_start'", [message.runId]);
+      })();
+      return terminal;
+    }
+    if (typeof message.requestId === "string") {
+      const row = this.row(message.requestId);
+      if (row) {
+        const state = message.type === "exec_accepted" || message.type === "operation_queued" ? "preparing" : message.type === "exec_started" ? "running" : message.type === "operation_received" ? "accepted" : "completed";
+        if (message.type !== "operation_received")
+          this.db.run("UPDATE operations SET state=?, response=? WHERE request_id=?", [state, JSON.stringify(message), row.request_id]);
+      }
+    }
+    return message;
+  }
+  operations() {
+    return this.db.query(
+      "SELECT * FROM operations WHERE response IS NOT NULL OR state!='completed' UNION ALL SELECT aliases.request_id,operations.run_id,operations.session_id,operations.request_type,operations.digest,operations.state,operations.response FROM aliases JOIN operations ON operations.request_id=aliases.operation_id WHERE aliases.request_id!=operations.request_id AND (response IS NOT NULL OR state!='completed')"
+    ).all().map((row) => ({
+      requestId: row.request_id,
+      requestType: row.request_type,
+      state: row.state,
+      ...row.run_id ? { runId: row.run_id } : {},
+      ...row.session_id ? { sessionId: row.session_id } : {}
+    }));
+  }
+  response(requestId) {
+    const row = this.row(requestId);
+    return row?.response && row.state !== "unknown" ? { ...JSON.parse(row.response), requestId } : void 0;
+  }
+  responses(requestIds) {
+    const ids = /* @__PURE__ */ new Set([...requestIds, ...this.operations().map((operation) => operation.requestId)]);
+    return [...ids].flatMap((requestId) => {
+      const response = this.response(requestId);
+      return response ? [response] : [];
+    });
+  }
+  lengths(runId) {
+    const result = { stdoutBytes: 0, stderrBytes: 0 };
+    for (const row of this.db.query("SELECT stream,bytes FROM streams WHERE run_id=?").all(runId))
+      result[row.stream === "stdout" ? "stdoutBytes" : "stderrBytes"] = row.bytes;
+    return result;
+  }
+  outputCursors() {
+    const cursors = /* @__PURE__ */ new Map();
+    for (const stream of this.db.query("SELECT run_id,stream,acknowledged FROM streams").all()) {
+      const cursor = cursors.get(stream.run_id) ?? { runId: stream.run_id, stdoutBytes: 0, stderrBytes: 0 };
+      cursor[stream.stream === "stdout" ? "stdoutBytes" : "stderrBytes"] = stream.acknowledged;
+      cursors.set(stream.run_id, cursor);
+    }
+    return [...cursors.values()];
+  }
+  *output(offsets = []) {
+    const cursors = new Map(offsets.map((offset) => [offset.runId, offset]));
+    for (const stream of this.db.query("SELECT * FROM streams WHERE NOT EXISTS (SELECT 1 FROM operations WHERE operations.run_id=streams.run_id AND operations.state='unknown') ORDER BY rowid").all()) {
+      const supplied = cursors.get(stream.run_id);
+      const cursor = supplied ? stream.stream === "stdout" ? supplied.stdoutBytes : supplied.stderrBytes : stream.acknowledged;
+      if (cursor >= stream.bytes) continue;
+      const firstOffset = this.db.query("SELECT MAX(offset) AS offset FROM output WHERE run_id=? AND stream=? AND offset<=?").get(stream.run_id, stream.stream, cursor)?.offset ?? 0;
+      let nextChunk = firstOffset;
+      while (true) {
+        const row = this.db.query("SELECT offset,data FROM output WHERE run_id=? AND stream=? AND offset>=? AND offset<? AND offset+bytes>? ORDER BY offset LIMIT 1").get(stream.run_id, stream.stream, nextChunk, stream.bytes, cursor);
+        if (!row) break;
+        nextChunk = row.offset + 1;
+        yield { type: "exec_output", runId: stream.run_id, stream: stream.stream, offset: row.offset, data: row.data };
+      }
+    }
+  }
+  terminals() {
+    return this.db.query(
+      "SELECT message FROM terminals WHERE NOT EXISTS (SELECT 1 FROM operations WHERE operations.run_id=terminals.run_id AND operations.state='unknown')"
+    ).all().map((row) => JSON.parse(row.message));
+  }
+  acknowledgeOutput(runId, stream, offset) {
+    if (!Number.isSafeInteger(offset) || offset < 0) return;
+    this.db.run("UPDATE streams SET acknowledged=MAX(acknowledged,MIN(bytes,?)) WHERE run_id=? AND stream=?", [offset, runId, stream]);
+  }
+  acknowledgeResult(requestId) {
+    const row = this.row(requestId);
+    if (row && row.request_type !== "exec_start")
+      this.db.run("UPDATE operations SET response=NULL WHERE request_id=? AND state='completed'", [row.request_id]);
+  }
+  acknowledgeTerminal(runId) {
+    this.db.transaction(() => {
+      this.db.run("DELETE FROM terminals WHERE run_id=?", [runId]);
+      this.db.run("DELETE FROM output WHERE run_id=?", [runId]);
+      this.db.run("UPDATE streams SET acknowledged=bytes WHERE run_id=?", [runId]);
+      this.db.run("UPDATE operations SET response=NULL WHERE run_id=? AND request_type='exec_start' AND state='completed'", [runId]);
+    })();
+  }
+  cancelSession(sessionId) {
+    this.db.run("INSERT OR IGNORE INTO cancelled_requests SELECT request_id FROM operations WHERE session_id=? AND state!='completed'", [
+      sessionId
+    ]);
+  }
+  isRequestCancelled(requestId) {
+    const row = this.row(requestId);
+    return !!row && this.db.query("SELECT request_id FROM cancelled_requests WHERE request_id=?").get(row.request_id) !== null;
+  }
+}
+export {
+  WorkerRecoveryStore,
+  workerOperationDigest
+};

package/dist/mjs/supervisor.mjs

@@ -6,6 +6,7 @@ const WORKER_RECONNECT_EXIT_CODE = 76;
 const WORKER_CREDENTIAL_RESTART_EXIT_CODE = 77;
 const WORKER_RECONNECT_DELAY_MS = 2e3;
 const WORKER_RECONNECT_JITTER_MS = 3e3;
+const WORKER_RECONNECT_MAX_DELAY_MS = 3e4;
 const SUPERVISOR_SIGNALS = ["SIGINT", "SIGTERM", "SIGHUP"];
 function defaultRuntimeSpawner(argv, options) {
   return Bun.spawn(argv, options);
@@ -13,9 +14,12 @@ function defaultRuntimeSpawner(argv, options) {
 function defaultRuntimeDelay(delayMs) {
   return new Promise((resolve) => setTimeout(resolve, delayMs));
 }
-function workerReconnectDelayMs(random = Math.random) {
+function workerReconnectDelayMs(random = Math.random, attempt = 0) {
   const sample = Math.max(0, Math.min(1, random()));
-  return WORKER_RECONNECT_DELAY_MS + Math.floor(sample * WORKER_RECONNECT_JITTER_MS);
+  const exponent = Math.min(20, Math.max(0, Math.floor(attempt)));
+  const ceiling = Math.min(WORKER_RECONNECT_MAX_DELAY_MS, (WORKER_RECONNECT_DELAY_MS + WORKER_RECONNECT_JITTER_MS) * 2 ** exponent);
+  const floor = Math.min(WORKER_RECONNECT_DELAY_MS * 2 ** exponent, ceiling * 0.4);
+  return floor + Math.floor(sample * (ceiling - floor));
 }
 async function defaultRuntimeReaper(runtime) {
   await terminateProcessTree(runtime);
@@ -29,10 +33,11 @@ function signalExitCode(signal) {
 function osSignalNumber(signal) {
   return osConstants.signals[signal];
 }
-async function superviseWorkerRuntime(argv, env = process.env, spawnRuntime = defaultRuntimeSpawner, waitBeforeReconnect = defaultRuntimeDelay, reapCredentialRuntime = defaultRuntimeReaper, reconnectDelay = workerReconnectDelayMs) {
+async function superviseWorkerRuntime(argv, env = process.env, spawnRuntime = defaultRuntimeSpawner, waitBeforeReconnect = defaultRuntimeDelay, reapCredentialRuntime = defaultRuntimeReaper, reconnectDelay) {
   if (!process.argv[1]) {
     throw new Error("Cannot locate the r5d-worker entrypoint");
   }
+  let reconnectAttempt = 0;
   while (true) {
     const runtime = spawnRuntime([process.execPath, process.argv[1], ...argv], {
       stdin: "inherit",
@@ -81,7 +86,7 @@ async function superviseWorkerRuntime(argv, env = process.env, spawnRuntime = de
         continue;
       }
       if (exitCode === WORKER_RECONNECT_EXIT_CODE) {
-        const reconnectDelayMs = reconnectDelay();
+        const reconnectDelayMs = reconnectDelay?.() ?? workerReconnectDelayMs(Math.random, reconnectAttempt++);
         process.stderr.write(`[r5d-worker] reconnecting in ${reconnectDelayMs}ms
 `);
         await waitBeforeReconnect(reconnectDelayMs);
@@ -100,6 +105,7 @@ export {
   WORKER_RECONNECT_DELAY_MS,
   WORKER_RECONNECT_EXIT_CODE,
   WORKER_RECONNECT_JITTER_MS,
+  WORKER_RECONNECT_MAX_DELAY_MS,
   WORKER_RELOAD_EXIT_CODE,
   WORKER_RUNTIME_ENV,
   isRetryableWorkerServerStatus,

package/dist/types/main.d.ts

@@ -1,4 +1,6 @@
 #!/usr/bin/env bun
+import type { WorkerLintPlansResult, WorkerUpdatePlanTaskResult } from "./plan-paths";
+import { WORKER_RESUMABLE_PROTOCOL, type WorkerRecoveryClientMessage, type WorkerRecoveryServerMessage } from "./recovery-protocol";
 import { Database } from "bun:sqlite";
 import type { WorkerGitIdentity } from "./git-identity";
 import { configureGitHubRegistryAuthFiles, type PreparedPrivateAuthFileGeneration } from "./registry-auth";
@@ -134,8 +136,11 @@ export type WorkerSessionTarget = {
     ownerUserId: string;
     rootProfile: "visible_projects" | "canonical_sync";
 };
-type WorkerClientMessage = {
+type WorkerClientMessage = WorkerRecoveryClientMessage | {
     type: "hello";
+    resumableProtocol: typeof WORKER_RESUMABLE_PROTOCOL;
+    runtimeId: string;
+    ledgerId: string;
     hostInfo?: Record<string, unknown>;
     startupReady?: boolean;
 } | {
@@ -277,7 +282,7 @@ type WorkerClientMessage = {
     installedR5dctlVersion?: string;
     error?: string;
 };
-type WorkerServerMessage = {
+type WorkerServerMessage = WorkerRecoveryServerMessage | {
     type: "connected";
     label: string;
     workerId: string;
@@ -414,16 +419,40 @@ type WorkerServerMessage = {
     }>;
 } | {
     type: "pty_input";
+    requestId: string;
     ptyId: string;
     data: string;
 } | {
     type: "pty_resize";
+    requestId: string;
     ptyId: string;
     cols: number;
     rows: number;
 } | {
     type: "pty_close";
+    requestId: string;
     ptyId: string;
+} | {
+    type: "read_plan";
+    requestId: string;
+    target: WorkerSessionTarget;
+    sessionId?: string;
+    planId: string;
+    createIfMissing: boolean;
+} | {
+    type: "lint_plans";
+    requestId: string;
+    target: WorkerSessionTarget;
+    sessionId?: string;
+    glob?: string;
+} | {
+    type: "update_task_status";
+    requestId: string;
+    target: WorkerSessionTarget;
+    sessionId?: string;
+    planId: string;
+    taskId: string;
+    checked: boolean;
 } | {
     type: "read";
     requestId: string;
@@ -514,6 +543,11 @@ type WorkerGitHubCredential = {
     token: string;
     missingScopes: Array<"repo" | "read:org" | "gist" | "workflow" | "read:packages" | "write:packages">;
 };
+type WorkerReadPlanResult = {
+    type: "read_plan";
+    read: WorkerReadFileResult;
+    created: boolean;
+};
 type WorkerWriteFileResult = {
     type: "write";
     file: string;
@@ -587,7 +621,10 @@ type WorkerCodeReadResult = {
     mtime: string;
     base64: string;
 };
-type WorkerOperationResult = WorkerReadFileResult | WorkerWriteFileResult | WorkerEditFileResult | WorkerGrepResult | WorkerFindResult | WorkerLsResult | WorkerViewFileBytesResult | WorkerExecStdinAck | WorkerCreateProjectBranchResult | WorkerDeleteProjectBranchResult | WorkerCodeListResult | WorkerCodeReadResult;
+type WorkerOperationResult = WorkerReadFileResult | WorkerReadPlanResult | WorkerLintPlansResult | WorkerUpdatePlanTaskResult | WorkerWriteFileResult | WorkerEditFileResult | WorkerGrepResult | WorkerFindResult | WorkerLsResult | WorkerViewFileBytesResult | WorkerExecStdinAck | WorkerCreateProjectBranchResult | WorkerDeleteProjectBranchResult | WorkerCodeListResult | WorkerCodeReadResult;
+type WorkerOperationServerMessage = Extract<WorkerServerMessage, {
+    type: "read_plan" | "lint_plans" | "update_task_status" | "read" | "write" | "edit" | "grep" | "find" | "ls" | "view_file_bytes" | "code_list" | "code_read";
+}>;
 declare class WorkspaceSyncAdmissionChangedError extends Error {
     readonly name = "WorkspaceSyncAdmissionChangedError";
 }
@@ -916,6 +953,7 @@ export declare const workerGitSecurityTestHarness: {
     workspaceSyncFailureHydrationIsSafe: typeof workspaceSyncFailureHydrationIsSafe;
     assertWorkerChildAdmission: typeof assertWorkerChildAdmission;
     executeWriteFileOperation: typeof executeWriteFileOperation;
+    executeOperation: typeof executeOperation;
     executeEditFileOperation: typeof executeEditFileOperation;
     terminateCredentialBearingChildren: typeof terminateCredentialBearingChildren;
     terminateCredentialBearingChildrenWithRetention: typeof terminateCredentialBearingChildrenWithRetention;
@@ -1010,6 +1048,14 @@ export declare function listWorkerDirectory(branchPath: string, inputPath?: stri
 export declare function listWorkerCodeDirectory(branchPath: string, inputPath: string): WorkerCodeListResult;
 export declare function readWorkerCodeFile(branchPath: string, inputPath: string): WorkerCodeReadResult;
 export declare function readWorkerImageFile(branchPath: string, filePath: string, builtInPaths?: WorkerBuiltInToolPaths): WorkerViewFileBytesResult;
+declare function executeOperation(input: {
+    message: WorkerOperationServerMessage;
+    resolvedTarget: ResolvedWorkerSessionTarget;
+    baseUrl: string;
+    token: string;
+    rootDir: string;
+    assertAdmission: () => void;
+}): Promise<WorkerOperationResult>;
 declare function targetProcessEnv(rootDir: string, target: WorkerSessionTarget): Record<string, string>;
 export declare function prepareShellEnvForTarget(input: {
     target: WorkerSessionTarget;