codetrellis 0.0.0-stage → 0.2.0

package/src/backend/services/record-chain.js

@@ -0,0 +1,162 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var record_chain_exports = {};
+__export(record_chain_exports, {
+  GENESIS: () => GENESIS,
+  beginRecord: () => beginRecord,
+  digestOf: () => digestOf,
+  linkEvent: () => linkEvent,
+  linkHash: () => linkHash,
+  recordHead: () => recordHead,
+  trimRecord: () => trimRecord,
+  verifyRecord: () => verifyRecord
+});
+module.exports = __toCommonJS(record_chain_exports);
+var import_node_crypto = require("node:crypto");
+var import_database = require("./database");
+var import_persistence = require("./persistence");
+const GENESIS = "0".repeat(64);
+const sha256 = (s) => (0, import_node_crypto.createHash)("sha256").update(s).digest("hex");
+function digestOf(e) {
+  return sha256(JSON.stringify([e.id, e.at, e.source, e.type, e.session_id, e.agent_type, e.payload]));
+}
+function linkHash(prev, seq, eventId, digest) {
+  return sha256(`${prev}
+${seq}
+${eventId}
+${digest}`);
+}
+function rowsOf(sql, params = []) {
+  const res = (0, import_database.getDb)().exec(sql, params);
+  if (!res.length) return [];
+  const { columns, values } = res[0];
+  return values.map((v) => Object.fromEntries(columns.map((c, i) => [c, v[i]])));
+}
+const EVENT_COLS = "id, at, source, type, session_id, agent_type, payload";
+function anchor() {
+  const a = rowsOf("SELECT through_seq, hash, at FROM record_anchor WHERE id = 1")[0];
+  return a ? { seq: Number(a.through_seq), hash: a.hash, at: Number(a.at) } : { seq: 0, hash: GENESIS, at: 0 };
+}
+function recordHead() {
+  const last = rowsOf("SELECT seq, hash FROM record_chain ORDER BY seq DESC LIMIT 1")[0];
+  if (last) return { seq: Number(last.seq), hash: last.hash };
+  const a = anchor();
+  return { seq: a.seq, hash: a.hash };
+}
+function linkEvent(eventId, now = Date.now()) {
+  const db = (0, import_database.getDb)();
+  if (rowsOf("SELECT 1 FROM record_chain WHERE event_id = ?", [eventId]).length) return null;
+  const e = rowsOf(`SELECT ${EVENT_COLS} FROM agent_events WHERE id = ?`, [eventId])[0];
+  if (!e) return null;
+  const head = recordHead();
+  const seq = head.seq + 1;
+  const digest = digestOf(e);
+  const last = Number(rowsOf("SELECT MAX(linked_at) AS t FROM record_chain")[0]?.t ?? 0);
+  const linkedAt = Math.max(last, Math.min(Number(e.at), now));
+  db.run(
+    "INSERT INTO record_chain (seq, event_id, linked_at, digest, prev, hash) VALUES (?, ?, ?, ?, ?, ?)",
+    [seq, eventId, linkedAt, digest, head.hash, linkHash(head.hash, seq, eventId, digest)]
+  );
+  (0, import_persistence.markDirty)();
+  return seq;
+}
+function beginRecord(now = Date.now()) {
+  if (rowsOf("SELECT 1 FROM record_chain LIMIT 1").length || anchor().seq > 0) return 0;
+  const ids = rowsOf(
+    "SELECT e.id FROM agent_events e LEFT JOIN record_chain c ON c.event_id = e.id WHERE c.event_id IS NULL ORDER BY e.at ASC, e.rowid ASC"
+  ).map((r) => r.id);
+  let n = 0;
+  for (const id of ids) if (linkEvent(id, now) !== null) n++;
+  return n;
+}
+function trimRecord(cutoff, maxRows, now = Date.now()) {
+  const db = (0, import_database.getDb)();
+  const count = Number(rowsOf("SELECT COUNT(*) AS n FROM record_chain")[0]?.n ?? 0);
+  const byTime = Number(rowsOf("SELECT MAX(seq) AS s FROM record_chain WHERE linked_at < ?", [cutoff])[0]?.s ?? 0);
+  const over = count - maxRows;
+  const byCount = over > 0 ? Number(rowsOf("SELECT seq FROM record_chain ORDER BY seq ASC LIMIT 1 OFFSET ?", [over - 1])[0]?.seq ?? 0) : 0;
+  const through = Math.max(byTime, byCount);
+  if (through <= 0) return 0;
+  const last = rowsOf("SELECT hash FROM record_chain WHERE seq = ?", [through])[0];
+  if (!last) return 0;
+  const before = Number(rowsOf("SELECT COUNT(*) AS n FROM agent_events")[0]?.n ?? 0);
+  db.run("DELETE FROM agent_events WHERE id IN (SELECT event_id FROM record_chain WHERE seq <= ?)", [through]);
+  db.run("DELETE FROM record_chain WHERE seq <= ?", [through]);
+  db.run(
+    "INSERT INTO record_anchor (id, through_seq, hash, at) VALUES (1, ?, ?, ?) ON CONFLICT(id) DO UPDATE SET through_seq = excluded.through_seq, hash = excluded.hash, at = excluded.at",
+    [through, last.hash, now]
+  );
+  (0, import_persistence.markDirty)();
+  return before - Number(rowsOf("SELECT COUNT(*) AS n FROM agent_events")[0]?.n ?? 0);
+}
+const MAX_PROBLEMS = 50;
+const PROBLEM_WORDS = {
+  changed: "its content changed after it was written",
+  removed: "it was removed",
+  relinked: "its link in the chain was changed",
+  unlinked: "it was added to the log outside the record"
+};
+const day = (ms) => new Date(ms).toISOString().slice(0, 10);
+function verifyRecord() {
+  const a = anchor();
+  const links = rowsOf("SELECT seq, event_id, linked_at, digest, prev, hash FROM record_chain ORDER BY seq ASC");
+  const events = new Map(rowsOf(`SELECT ${EVENT_COLS} FROM agent_events`).map((e) => [e.id, e]));
+  const problems = [];
+  const say = (p) => {
+    if (problems.length < MAX_PROBLEMS) problems.push(p);
+  };
+  const info = (id) => {
+    const e = events.get(id);
+    return { at: e ? Number(e.at) : null, type: e?.type ?? null, agentType: e?.agent_type ?? null };
+  };
+  let prev = a.hash;
+  let expected = a.seq + 1;
+  for (const l of links) {
+    const seq = Number(l.seq);
+    if (seq !== expected) {
+      say({ seq: expected, eventId: "", kind: "removed", at: null, type: null, agentType: null });
+    }
+    if (l.prev !== prev || linkHash(l.prev, seq, l.event_id, l.digest) !== l.hash) {
+      say({ seq, eventId: l.event_id, kind: "relinked", ...info(l.event_id) });
+    }
+    const e = events.get(l.event_id);
+    if (!e) say({ seq, eventId: l.event_id, kind: "removed", at: null, type: null, agentType: null });
+    else if (digestOf(e) !== l.digest) say({ seq, eventId: l.event_id, kind: "changed", ...info(l.event_id) });
+    events.delete(l.event_id);
+    prev = l.hash;
+    expected = seq + 1;
+  }
+  for (const e of events.values()) say({ seq: null, eventId: e.id, kind: "unlinked", at: Number(e.at), type: e.type, agentType: e.agent_type });
+  const head = links.length ? { seq: Number(links[links.length - 1].seq), hash: links[links.length - 1].hash } : { seq: a.seq, hash: a.hash };
+  const since = links.length ? Number(links[0].linked_at) : null;
+  const ok = problems.length === 0;
+  const kept = `${links.length.toLocaleString("en-GB")} entr${links.length === 1 ? "y" : "ies"}${since ? ` since ${day(since)}` : ""}`;
+  const words = ok ? links.length === 0 ? "Nothing is in the record yet." : `Intact: ${kept} match the chain${a.seq ? `; older entries were removed by retention on ${day(a.at)}` : ""}.` : `Changed after it was written: ${problems.length}${problems.length === MAX_PROBLEMS ? "+" : ""} of ${kept}. ` + problems.slice(0, 3).map((p) => `${p.seq !== null ? `#${p.seq}` : "an event"}${p.type ? ` (${p.type.replace(/_/g, " ")}${p.agentType ? ` by ${p.agentType}` : ""}${p.at ? `, ${day(p.at)}` : ""})` : ""}: ${PROBLEM_WORDS[p.kind]}`).join("; ") + ".";
+  return { ok, entries: links.length, since, trimmedThrough: a.seq, head, problems, words };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  GENESIS,
+  beginRecord,
+  digestOf,
+  linkEvent,
+  linkHash,
+  recordHead,
+  trimRecord,
+  verifyRecord
+});

package/src/backend/services/recurrence-rule.js

@@ -0,0 +1,63 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var recurrence_rule_exports = {};
+__export(recurrence_rule_exports, {
+  parseRecurrenceRule: () => parseRecurrenceRule
+});
+module.exports = __toCommonJS(recurrence_rule_exports);
+var import_recurrence = require("../../shared/lib/recurrence");
+var import_skill_model = require("./skill-model");
+const ID = /^[a-z0-9][a-z0-9-]{0,62}$/;
+const PLAYBOOK = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
+const AT = /^([01]\d|2[0-3]):[0-5]\d$/;
+function parseRecurrenceRule(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return { rule: null, problems: ["a rule must be an object"] };
+  const r = raw;
+  const problems = [];
+  const str = (k) => typeof r[k] === "string" ? r[k].trim() : "";
+  const id = str("id");
+  if (!ID.test(id)) problems.push("id must be lower-case letters, digits and dashes, at most 63");
+  const playbook = str("playbook");
+  if (!PLAYBOOK.test(playbook)) problems.push("playbook must name a playbook (a plan template id)");
+  const title = str("title");
+  if (!title || title.length > 120) problems.push("title must be 1 to 120 characters");
+  const every = r.every === "day" || r.every === "week" || r.every === "month" ? r.every : null;
+  if (!every) problems.push("every must be day, week or month");
+  let on = typeof r.on === "number" && Number.isInteger(r.on) ? r.on : every === "day" ? 1 : NaN;
+  if (every === "week" && !(on >= 1 && on <= 7)) problems.push("on must be the weekday, 1 (Monday) to 7 (Sunday)");
+  if (every === "month" && !(on >= 1 && on <= 28)) problems.push("on must be the day of the month, 1 to 28");
+  if (every === "day") on = 1;
+  const at = str("at");
+  if (!AT.test(at)) problems.push("at must be a time, HH:MM");
+  const timeZone = str("timeZone");
+  if (!timeZone || !(0, import_recurrence.isTimeZone)(timeZone)) problems.push("timeZone must be an IANA time zone, e.g. Europe/London");
+  const { skills, problems: skillProblems } = (0, import_skill_model.normaliseSkills)(r.skills);
+  problems.push(...skillProblems);
+  const since = str("since");
+  if (!since || Number.isNaN(Date.parse(since))) problems.push("since must be an ISO date");
+  const by = str("by").slice(0, 200);
+  if (problems.length > 0 || !every) return { rule: null, problems };
+  return {
+    rule: { id, playbook, title, every, on, at, timeZone, carryOver: r.carryOver === true, skills, since: new Date(since).toISOString(), by },
+    problems: []
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  parseRecurrenceRule
+});

package/src/backend/services/recurring-agent.js

@@ -0,0 +1,89 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var recurring_agent_exports = {};
+__export(recurring_agent_exports, {
+  RUN_AGENTS: () => RUN_AGENTS,
+  isRunAgent: () => isRunAgent,
+  runAgentsFor: () => runAgentsFor,
+  runCommand: () => runCommand,
+  runPrompt: () => runPrompt,
+  setRunAgent: () => setRunAgent,
+  startRunAgent: () => startRunAgent
+});
+module.exports = __toCommonJS(recurring_agent_exports);
+var import_database = require("./database");
+var import_persistence = require("./persistence");
+var import_terminal_service = require("./terminal-service");
+const RUN_AGENTS = { claude: "Claude Code", codex: "Codex" };
+function isRunAgent(v) {
+  return v === "claude" || v === "codex";
+}
+function runAgentsFor(projectRoot) {
+  const out = {};
+  const res = (0, import_database.getDb)().exec("SELECT rule_id, agent, by_name, at FROM recurring_agents WHERE project_root = ?", [projectRoot]);
+  for (const row of res[0]?.values ?? []) {
+    const [ruleId, agent, by, at] = row;
+    if (isRunAgent(agent)) out[ruleId] = { agent, by, at };
+  }
+  return out;
+}
+function setRunAgent(projectRoot, ruleId, agent, by, now = Date.now()) {
+  if (agent === null) {
+    (0, import_database.getDb)().run("DELETE FROM recurring_agents WHERE project_root = ? AND rule_id = ?", [projectRoot, ruleId]);
+  } else {
+    (0, import_database.getDb)().run("INSERT OR REPLACE INTO recurring_agents (project_root, rule_id, agent, by_name, at) VALUES (?, ?, ?, ?, ?)", [projectRoot, ruleId, agent, by, now]);
+  }
+  (0, import_persistence.markDirty)();
+  return agent === null ? null : { agent, by, at: now };
+}
+function runPrompt(plan) {
+  const title = plan.title.replace(/['"`$\\\n\r]/g, " ").replace(/\s+/g, " ").trim();
+  return `Work the CodeTrellis plan "${title}" (plan_uid ${plan.uid}): call get_next_item with that plan_uid, claim the task, read its brief with get_brief, do it, and repeat until no task is left.`;
+}
+function runCommand(agent, plan, program = process.env.CODETRELLIS_RUN_AGENT_COMMAND || agent) {
+  return `${program} '${runPrompt(plan)}'
+`;
+}
+const SHELL_SETTLE_MS = 500;
+function startRunAgent(projectRoot, ruleId, plan, may, onCreated) {
+  const setting = runAgentsFor(projectRoot)[ruleId];
+  if (!setting) return null;
+  const name = RUN_AGENTS[setting.agent];
+  if (may !== true) return { agent: setting.agent, terminalId: null, words: `${name} was not started: ${may}` };
+  try {
+    const session = (0, import_terminal_service.createTerminal)({ preset: "shell", cwd: projectRoot, title: `${plan.title} \xB7 ${name}` });
+    setTimeout(() => {
+      (0, import_terminal_service.writeTerminal)(session.id, runCommand(setting.agent, plan));
+    }, SHELL_SETTLE_MS);
+    onCreated?.(session);
+    return { agent: setting.agent, terminalId: session.id, words: `${name} started in a terminal on the computer` };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return { agent: setting.agent, terminalId: null, words: `${name} was not started: ${message}` };
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RUN_AGENTS,
+  isRunAgent,
+  runAgentsFor,
+  runCommand,
+  runPrompt,
+  setRunAgent,
+  startRunAgent
+});

package/src/backend/services/recurring-scheduler.js

@@ -0,0 +1,77 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var recurring_scheduler_exports = {};
+__export(recurring_scheduler_exports, {
+  startRecurringScheduler: () => startRecurringScheduler,
+  startRunsDueBetween: () => startRunsDueBetween,
+  stopRecurringScheduler: () => stopRecurringScheduler
+});
+module.exports = __toCommonJS(recurring_scheduler_exports);
+var import_recurrence = require("../../shared/lib/recurrence");
+var import_trusted_roots = require("./trusted-roots");
+var import_recurring_service = require("./recurring-service");
+var import_plan_service = require("./plan-service");
+const SCHEDULE = { author: "schedule", authorType: "system" };
+const tickMs = () => Number(process.env.CODETRELLIS_RECURRING_TICK_MS) || 6e4;
+let lastTick = null;
+let timer = null;
+function startRunsDueBetween(roots, from, now) {
+  const started = [];
+  for (const root of roots) {
+    let rules;
+    try {
+      rules = (0, import_recurring_service.rulesOf)(root);
+    } catch {
+      continue;
+    }
+    for (const rule of rules) {
+      const p = (0, import_recurrence.currentPeriod)(rule, now);
+      const at = (0, import_recurrence.dueAt)(rule, p);
+      if (at <= from || at > now || at < Date.parse(rule.since)) continue;
+      if ((0, import_plan_service.getPlan)((0, import_recurring_service.runUid)(root, rule.id, (0, import_recurrence.periodId)(p)))) continue;
+      try {
+        started.push({ root, run: (0, import_recurring_service.startRun)(root, rule.id, SCHEDULE, now) });
+      } catch (err) {
+        console.warn(`[Recurring] Could not start ${rule.title} in ${root}:`, err instanceof Error ? err.message : err);
+      }
+    }
+  }
+  return started;
+}
+function startRecurringScheduler(onStarted) {
+  if (timer) return;
+  lastTick = Date.now();
+  timer = setInterval(() => {
+    const now = Date.now();
+    const from = lastTick ?? now;
+    lastTick = now;
+    for (const { root, run } of startRunsDueBetween((0, import_trusted_roots.listTrustedRoots)(), from, now)) onStarted(root, run);
+  }, tickMs());
+  timer.unref?.();
+}
+function stopRecurringScheduler() {
+  if (timer) clearInterval(timer);
+  timer = null;
+  lastTick = null;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  startRecurringScheduler,
+  startRunsDueBetween,
+  stopRecurringScheduler
+});

package/src/backend/services/recurring-service.js

@@ -0,0 +1,276 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var recurring_service_exports = {};
+__export(recurring_service_exports, {
+  RecurringError: () => RecurringError,
+  dismissDue: () => dismissDue,
+  recurrenceOf: () => recurrenceOf,
+  removeRule: () => removeRule,
+  rulesOf: () => rulesOf,
+  runInfo: () => runInfo,
+  runUid: () => runUid,
+  seriesFor: () => seriesFor,
+  seriesOf: () => seriesOf,
+  setRule: () => setRule,
+  startRun: () => startRun
+});
+module.exports = __toCommonJS(recurring_service_exports);
+var import_node_crypto = __toESM(require("node:crypto"));
+var import_node_path = __toESM(require("node:path"));
+var import_recurrence = require("../../shared/lib/recurrence");
+var import_project_config_service = require("./project-config-service");
+var import_recurrence_rule = require("./recurrence-rule");
+var import_plan_templates = require("./plan-templates");
+var import_plan_templates_service = require("./plan-templates-service");
+var import_plan_service = require("./plan-service");
+var planItemService = __toESM(require("./plan-item-service"));
+var import_git_identity = require("./git-identity");
+var import_plans_home = require("./plans-home");
+var import_database = require("./database");
+var import_persistence = require("./persistence");
+var import_recurring_agent = require("./recurring-agent");
+var import_plan_file_service = require("./plan-file-service");
+const SHOWN = 8;
+const LOOK_BACK = 52;
+class RecurringError extends Error {
+  constructor(message, status) {
+    super(message);
+    this.status = status;
+  }
+  status;
+}
+function rulesOf(projectRoot) {
+  return (0, import_project_config_service.getProjectConfig)(projectRoot).recurring ?? [];
+}
+function ruleOf(projectRoot, id) {
+  const rule = rulesOf(projectRoot).find((r) => r.id === id);
+  if (!rule) throw new RecurringError(`No recurring playbook "${id}" in this project`, 404);
+  return rule;
+}
+function setRule(projectRoot, raw, by, now = Date.now()) {
+  const existing = rulesOf(projectRoot).find((r) => r.id === raw.id);
+  const { rule, problems } = (0, import_recurrence_rule.parseRecurrenceRule)({ ...raw, since: existing?.since ?? new Date(now).toISOString(), by });
+  if (!rule) throw new RecurringError(problems.join("; "), 400);
+  if (!(0, import_plan_templates.getTemplate)(rule.playbook, projectRoot)) throw new RecurringError(`No playbook "${rule.playbook}" in this project`, 400);
+  (0, import_project_config_service.updateProjectConfig)(projectRoot, { recurring: [...rulesOf(projectRoot).filter((r) => r.id !== rule.id), rule] });
+  return rule;
+}
+function removeRule(projectRoot, id) {
+  ruleOf(projectRoot, id);
+  (0, import_project_config_service.updateProjectConfig)(projectRoot, { recurring: rulesOf(projectRoot).filter((r) => r.id !== id) });
+}
+function seriesKey(projectRoot) {
+  const folder = (0, import_project_config_service.getProjectConfig)(projectRoot).plans?.folder;
+  if (folder?.kind === "git") return `git:${(0, import_plans_home.normaliseRemote)(folder.remote)}`;
+  if (folder?.kind === "synced") return `synced:${folder.provider}:${folder.place}`;
+  const origin = (0, import_git_identity.getNormalisedOriginUrl)(projectRoot);
+  return origin ? `origin:${origin}` : `folder:${import_node_path.default.basename(import_node_path.default.resolve(projectRoot))}`;
+}
+function runUid(projectRoot, ruleId, period) {
+  const h = import_node_crypto.default.createHash("sha256").update(`codetrellis-recurring\0${seriesKey(projectRoot)}\0${ruleId}\0${period}`).digest("hex");
+  return `${h.slice(0, 8)}-${h.slice(8, 12)}-5${h.slice(13, 16)}-${(parseInt(h[16], 16) & 3 | 8).toString(16)}${h.slice(17, 20)}-${h.slice(20, 32)}`;
+}
+const SETTLED = /* @__PURE__ */ new Set(["done", "skipped"]);
+function runState(plan) {
+  return plan.status === "completed" || plan.status === "archived" ? "done" : "in_progress";
+}
+function runWords(label, state, rule, due) {
+  switch (state) {
+    case "done":
+      return `${label} \u2713 done`;
+    case "in_progress":
+      return `${label} \u25D0 in progress`;
+    case "missed":
+      return `${label} \u2717 missed`;
+    case "due":
+      return `${label} due ${(0, import_recurrence.sinceWords)(rule, due)}`;
+    case "next":
+      return `${label} next, ${(0, import_recurrence.momentWords)(rule.timeZone, due)}`;
+  }
+}
+function seriesOf(projectRoot, rule, now = Date.now()) {
+  const since = Date.parse(rule.since);
+  const current = (0, import_recurrence.currentPeriod)(rule, now);
+  const past = [];
+  for (let p = current, i = 0; i < SHOWN && (0, import_recurrence.dueAt)(rule, p) >= since; p = (0, import_recurrence.previousPeriod)(p), i++) past.unshift(p);
+  const runs = past.map((p) => {
+    const period = (0, import_recurrence.periodId)(p);
+    const at = (0, import_recurrence.dueAt)(rule, p);
+    const plan = (0, import_plan_service.getPlan)(runUid(projectRoot, rule.id, period));
+    const state = plan ? runState(plan) : p === current ? "due" : "missed";
+    const label = (0, import_recurrence.periodLabel)(p);
+    return { period, label, dueAt: at, state, planUid: plan?.uid ?? null, words: runWords(label, state, rule, at) };
+  });
+  const next = (0, import_recurrence.nextPeriod)(current);
+  const nextAt = (0, import_recurrence.dueAt)(rule, next);
+  runs.push({ period: (0, import_recurrence.periodId)(next), label: (0, import_recurrence.periodLabel)(next), dueAt: nextAt, state: "next", planUid: null, words: runWords((0, import_recurrence.periodLabel)(next), "next", rule, nextAt) });
+  const open = runs.find((r) => r.state === "due");
+  return {
+    rule,
+    words: (0, import_recurrence.seriesWords)(rule),
+    runs,
+    due: open ? { period: open.period, label: open.label, since: open.dueAt, words: `${rule.title} is due ${(0, import_recurrence.sinceWords)(rule, open.dueAt)}`, dismissed: isDismissed(projectRoot, rule.id, open.period) } : null,
+    agent: (0, import_recurring_agent.runAgentsFor)(projectRoot)[rule.id] ?? null
+  };
+}
+function seriesFor(projectRoot, now = Date.now()) {
+  return rulesOf(projectRoot).map((r) => seriesOf(projectRoot, r, now));
+}
+function runInfo(planUid) {
+  const row = (0, import_database.getDb)().exec("SELECT rule_id, period, label, previous_uid, carried_json, started_by, started_at FROM recurring_runs WHERE plan_uid = ?", [planUid])[0]?.values[0];
+  if (!row) return null;
+  let carried = [];
+  try {
+    carried = JSON.parse(String(row[4]));
+  } catch {
+  }
+  return {
+    rule: String(row[0]),
+    period: String(row[1]),
+    label: String(row[2]),
+    previous: row[3] === null ? null : String(row[3]),
+    carried,
+    startedBy: String(row[5]),
+    startedAt: Number(row[6])
+  };
+}
+function isDismissed(projectRoot, ruleId, period) {
+  return ((0, import_database.getDb)().exec("SELECT 1 FROM recurring_dismissed WHERE project_root = ? AND rule_id = ? AND period = ?", [projectRoot, ruleId, period])[0]?.values.length ?? 0) > 0;
+}
+function dismissDue(projectRoot, ruleId, by, now = Date.now()) {
+  const s = seriesOf(projectRoot, ruleOf(projectRoot, ruleId), now);
+  if (!s.due) throw new RecurringError(`${s.rule.title} has no run due now`, 409);
+  (0, import_database.getDb)().run("INSERT OR REPLACE INTO recurring_dismissed (project_root, rule_id, period, by_name, at) VALUES (?, ?, ?, ?, ?)", [projectRoot, ruleId, s.due.period, by, now]);
+  (0, import_persistence.markDirty)();
+  return { period: s.due.period, label: s.due.label };
+}
+function startRun(projectRoot, ruleId, by, now = Date.now()) {
+  const rule = ruleOf(projectRoot, ruleId);
+  const p = (0, import_recurrence.currentPeriod)(rule, now);
+  if ((0, import_recurrence.dueAt)(rule, p) < Date.parse(rule.since)) {
+    throw new RecurringError(`${rule.title} is not due yet: the first run is ${(0, import_recurrence.momentWords)(rule.timeZone, (0, import_recurrence.dueAt)(rule, (0, import_recurrence.nextPeriod)(p)))}`, 409);
+  }
+  const period = (0, import_recurrence.periodId)(p);
+  const label = (0, import_recurrence.periodLabel)(p);
+  const uid = runUid(projectRoot, rule.id, period);
+  const existing = (0, import_plan_service.getPlan)(uid);
+  if (existing) {
+    return { plan: existing, created: false, info: runInfo(uid) ?? { rule: rule.id, period, label, previous: null, carried: [] } };
+  }
+  let previous = null;
+  for (let q = (0, import_recurrence.previousPeriod)(p), i = 0; i < LOOK_BACK; q = (0, import_recurrence.previousPeriod)(q), i++) {
+    const u = runUid(projectRoot, rule.id, (0, import_recurrence.periodId)(q));
+    if ((0, import_plan_service.getPlan)(u)) {
+      previous = { uid: u, label: (0, import_recurrence.periodLabel)(q) };
+      break;
+    }
+  }
+  const applied = (0, import_plan_templates_service.applyTemplate)({
+    templateId: rule.playbook,
+    projectPath: projectRoot,
+    title: `${rule.title} \u2014 ${label}`,
+    author: by.author,
+    authorType: by.authorType,
+    uid
+  });
+  const actions = () => planItemService.listAllItems(uid).filter((i) => i.kind === "action");
+  if (rule.skills.length > 0) {
+    for (const item of actions()) {
+      const have = new Set((item.skills ?? []).map((s) => s.name));
+      const add = rule.skills.filter((s) => !have.has(s.name));
+      if (add.length > 0) planItemService.updateItem(item.uid, { skills: [...item.skills ?? [], ...add], author: by.author, authorType: by.authorType });
+    }
+  }
+  const carried = [];
+  if (rule.carryOver && previous) {
+    const titles = new Set(actions().map((i) => i.title.trim().toLowerCase()));
+    for (const item of planItemService.listAllItems(previous.uid)) {
+      if (item.kind !== "action" || SETTLED.has(item.status ?? "") || titles.has(item.title.trim().toLowerCase())) continue;
+      const copy = planItemService.createItem({
+        planUid: uid,
+        kind: "action",
+        title: item.title,
+        body: item.body,
+        fileSpecs: item.fileSpecs,
+        skills: item.skills,
+        author: by.author,
+        authorType: by.authorType
+      });
+      carried.push({ itemUid: copy.uid, from: previous.label });
+    }
+  }
+  (0, import_database.getDb)().run(
+    "INSERT OR REPLACE INTO recurring_runs (plan_uid, project_root, rule_id, period, label, previous_uid, carried_json, started_at, started_by) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)",
+    [uid, projectRoot, rule.id, period, label, previous?.uid ?? null, JSON.stringify(carried), now, by.author]
+  );
+  (0, import_persistence.markDirty)();
+  (0, import_plan_file_service.exportIfSharedByDefault)(uid, projectRoot);
+  return { plan: (0, import_plan_service.getPlan)(uid) ?? applied.plan, created: true, info: { rule: rule.id, period, label, previous: previous?.uid ?? null, carried, startedBy: by.author, startedAt: now } };
+}
+function recurrenceOf(projectRoot, planUid, now = Date.now()) {
+  const rules = rulesOf(projectRoot);
+  let info = runInfo(planUid);
+  if (!info) {
+    outer: for (const rule2 of rules) {
+      for (let p = (0, import_recurrence.currentPeriod)(rule2, now), i = 0; i < LOOK_BACK; p = (0, import_recurrence.previousPeriod)(p), i++) {
+        if (runUid(projectRoot, rule2.id, (0, import_recurrence.periodId)(p)) === planUid) {
+          info = { rule: rule2.id, period: (0, import_recurrence.periodId)(p), label: (0, import_recurrence.periodLabel)(p), previous: null, carried: [] };
+          break outer;
+        }
+      }
+    }
+  }
+  if (!info) return null;
+  const rule = rules.find((r) => r.id === info.rule);
+  const title = rule?.title ?? info.rule;
+  const carriedTasks = info.carried.map((c) => ({ ...c, title: planItemService.getItem(c.itemUid)?.title ?? "(removed)" }));
+  const who = info.startedBy === "schedule" ? "started by the schedule" : info.startedBy ? `started by ${info.startedBy}` : null;
+  const from = info.carried[0]?.from;
+  const carriedWords = carriedTasks.length ? `${carriedTasks.length} ${carriedTasks.length === 1 ? "task" : "tasks"} carried from ${from}` : null;
+  return {
+    ...info,
+    title,
+    words: rule ? (0, import_recurrence.seriesWords)(rule) : "",
+    line: [title, `${info.label} run`, who, carriedWords].filter(Boolean).join(" \xB7 "),
+    carriedTasks
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RecurringError,
+  dismissDue,
+  recurrenceOf,
+  removeRule,
+  rulesOf,
+  runInfo,
+  runUid,
+  seriesFor,
+  seriesOf,
+  setRule,
+  startRun
+});