codetrellis 0.0.0-stage → 0.2.0

package/src/backend/services/task-records/run-record.js

@@ -0,0 +1,136 @@
+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 run_record_exports = {};
+__export(run_record_exports, {
+  MAX_RUN_RECORD_BYTES: () => MAX_RUN_RECORD_BYTES,
+  isRunPath: () => isRunPath,
+  parseRunRecord: () => parseRunRecord,
+  runFilesOf: () => runFilesOf,
+  runRecordBytes: () => runRecordBytes,
+  serializeRunRecord: () => serializeRunRecord
+});
+module.exports = __toCommonJS(run_record_exports);
+var import_yaml = require("yaml");
+var import_signing = require("./signing");
+const KIND = "test-run";
+const MAX_RUN_RECORD_BYTES = 512 * 1024;
+const MAX_FILES = 5e3;
+const MAX_FAILING_PER_FILE = 50;
+const MAX_DIRTY = 500;
+const WRITER = /^[a-f0-9]{8,32}$/;
+const SHA = /^[a-f0-9]{40}$/;
+const text = (v, max) => typeof v === "string" && v.length > 0 ? v.slice(0, max) : null;
+const count = (v) => Number.isSafeInteger(v) && v >= 0 ? v : 0;
+function isRunPath(p) {
+  return typeof p === "string" && p.length > 0 && p.length <= 1024 && !p.includes("\\") && !p.includes("\0") && !p.startsWith("/") && !/^[A-Za-z]:/.test(p) && !p.split("/").some((x) => x === ".." || x === "");
+}
+function bodyOf(r) {
+  return {
+    kind: KIND,
+    writer: r.writer,
+    name: r.name,
+    counter: r.counter,
+    at: new Date(r.at).toISOString(),
+    by: r.by,
+    commit: r.commit,
+    dirty: r.dirty,
+    report: r.report,
+    totals: r.totals,
+    files: r.files.map((f) => ({ file: f.file, passed: f.passed, failed: f.failed, skipped: f.skipped, failing: f.failing.map((x) => ({ name: x.name, result: x.result, why: x.why })) }))
+  };
+}
+function runRecordBytes(r) {
+  return (0, import_signing.canonicalJson)(bodyOf(r));
+}
+function serializeRunRecord(r, signature) {
+  const body = signature ? { ...bodyOf(r), signature } : bodyOf(r);
+  return `# CodeTrellis: one device's latest test run, by test file, and the commit it ran against.
+${(0, import_yaml.stringify)(body, { lineWidth: 0 })}`;
+}
+function parseRunRecord(source) {
+  if (Buffer.byteLength(source, "utf8") > MAX_RUN_RECORD_BYTES) return { error: "larger than a run record can be" };
+  let raw;
+  try {
+    raw = (0, import_yaml.parse)(source, { maxAliasCount: 0 });
+  } catch {
+    return { error: "not YAML" };
+  }
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return { error: "not a record" };
+  const { signature: rawSignature, ...r } = raw;
+  if (r.kind !== KIND) return { error: "not a test-run record" };
+  const writer = typeof r.writer === "string" && WRITER.test(r.writer) ? r.writer : null;
+  if (!writer) return { error: "no writer" };
+  const counter = Number.isSafeInteger(r.counter) && r.counter > 0 ? r.counter : null;
+  if (!counter) return { error: "no counter" };
+  const at = typeof r.at === "string" ? Date.parse(r.at) : NaN;
+  if (!Number.isFinite(at)) return { error: "no time" };
+  const by = r.by && typeof r.by === "object" ? r.by : {};
+  const t = r.totals && typeof r.totals === "object" ? r.totals : {};
+  const files = [];
+  for (const f of Array.isArray(r.files) ? r.files.slice(0, MAX_FILES) : []) {
+    if (!f || typeof f !== "object" || !isRunPath(f.file)) continue;
+    const ff = f;
+    const failing = [];
+    for (const x of Array.isArray(ff.failing) ? ff.failing.slice(0, MAX_FAILING_PER_FILE) : []) {
+      const xx = x && typeof x === "object" ? x : {};
+      const name = text(xx.name, 300);
+      if (!name) continue;
+      failing.push({ name, result: xx.result === "error" ? "error" : "failed", why: text(xx.why, 500) });
+    }
+    files.push({ file: ff.file, passed: count(ff.passed), failed: Math.max(count(ff.failed), failing.length), skipped: count(ff.skipped), failing });
+  }
+  return {
+    signed: { bytes: (0, import_signing.canonicalJson)(r), signature: (0, import_signing.parseSignature)(rawSignature) },
+    record: {
+      writer,
+      name: text(r.name, 120) ?? "someone",
+      counter,
+      at,
+      by: { author: text(by.author, 120) ?? "someone", authorType: text(by.authorType, 40) ?? "unknown" },
+      commit: typeof r.commit === "string" && SHA.test(r.commit) ? r.commit : null,
+      dirty: (Array.isArray(r.dirty) ? r.dirty : []).filter(isRunPath).slice(0, MAX_DIRTY),
+      report: text(r.report, 300) ?? "a test report",
+      totals: { tests: count(t.tests), passed: count(t.passed), failed: count(t.failed), errors: count(t.errors), skipped: count(t.skipped) },
+      files
+    }
+  };
+}
+function runFilesOf(cases) {
+  const by = /* @__PURE__ */ new Map();
+  for (const c of cases) {
+    if (!c.testFile || !isRunPath(c.testFile)) continue;
+    let f = by.get(c.testFile);
+    if (!f) {
+      f = { file: c.testFile, passed: 0, failed: 0, skipped: 0, failing: [] };
+      by.set(c.testFile, f);
+    }
+    if (c.result === "passed") f.passed++;
+    else if (c.result === "skipped") f.skipped++;
+    else if (++f.failed <= MAX_FAILING_PER_FILE) f.failing.push({ name: c.name.slice(0, 300), result: c.result === "error" ? "error" : "failed", why: c.message ? c.message.slice(0, 500) : null });
+  }
+  return [...by.values()].sort((a, b) => a.file.localeCompare(b.file)).slice(0, MAX_FILES);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MAX_RUN_RECORD_BYTES,
+  isRunPath,
+  parseRunRecord,
+  runFilesOf,
+  runRecordBytes,
+  serializeRunRecord
+});

package/src/backend/services/task-records/shared-state.js

@@ -0,0 +1,548 @@
+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 shared_state_exports = {};
+__export(shared_state_exports, {
+  RECORDS_DIR: () => RECORDS_DIR,
+  getSharedTaskState: () => getSharedTaskState,
+  isSharingMaterialReads: () => isSharingMaterialReads,
+  isSharingTaskState: () => isSharingTaskState,
+  keepMyState: () => keepMyState,
+  readAndTell: () => readAndTell,
+  readProjectRecords: () => readProjectRecords,
+  setCheckRunsChangedListener: () => setCheckRunsChangedListener,
+  setRecordAppliedListener: () => setRecordAppliedListener,
+  setRunsChangedListener: () => setRunsChangedListener,
+  setSharedMaterialReads: () => setSharedMaterialReads,
+  setSharedTaskState: () => setSharedTaskState,
+  setSplitChangedListener: () => setSplitChangedListener,
+  shareMaterialRead: () => shareMaterialRead,
+  startRecordWatcher: () => startRecordWatcher,
+  stopRecordWatcher: () => stopRecordWatcher,
+  trustTeammateKey: () => trustTeammateKey,
+  writeRecordFor: () => writeRecordFor,
+  writerId: () => writerId,
+  writerName: () => writerName
+});
+module.exports = __toCommonJS(shared_state_exports);
+var import_node_fs = __toESM(require("node:fs"));
+var import_node_path = __toESM(require("node:path"));
+var import_node_crypto = __toESM(require("node:crypto"));
+var import_chokidar = __toESM(require("chokidar"));
+var import_database = require("../database");
+var import_persistence = require("../persistence");
+var import_confined_fs = require("../confined-fs");
+var import_settings_service = require("../settings-service");
+var import_plan_service = require("../plan-service");
+var import_plan_item_service = require("../plan-item-service");
+var import_plan_file_service = require("../plan-file-service");
+var import_plans_home = require("../plans-home");
+var import_heads = require("./heads");
+var import_cloud_files = require("../cloud-files");
+var import_record = require("./record");
+var import_material_reads = require("./material-reads");
+var import_test_runs = require("./test-runs");
+var import_teammate_runs = require("../tests/teammate-runs");
+var import_test_results = require("../tests/test-results");
+var import_check_runs = require("./check-runs");
+var import_check_runs2 = require("../check-runs");
+var import_trust = require("./trust");
+const MAX_RECORDS_PER_ITEM = 5e3;
+const RECORDS_DIR = import_node_path.default.join(".codetrellis", "records");
+function rowOf(projectRoot) {
+  const v = (0, import_database.getDb)().exec("SELECT enabled, changed_at, changed_by FROM shared_task_state WHERE project_root = ?", [projectRoot])[0]?.values[0];
+  return v ? { enabled: Number(v[0]) === 1, changedAt: Number(v[1]), changedBy: String(v[2]) } : null;
+}
+function isSharingTaskState(projectRoot) {
+  return rowOf(projectRoot)?.enabled === true;
+}
+function writerId() {
+  const v = (0, import_database.getDb)().exec("SELECT writer FROM task_record_writer WHERE id = 1")[0]?.values[0];
+  if (v) return String(v[0]);
+  const id = import_node_crypto.default.randomBytes(8).toString("hex");
+  (0, import_database.getDb)().run("INSERT OR IGNORE INTO task_record_writer (id, writer) VALUES (1, ?)", [id]);
+  (0, import_persistence.markDirty)();
+  return writerId();
+}
+function writerName(projectRoot) {
+  return (0, import_settings_service.getSettings)().identity.displayName || (0, import_settings_service.readGitIdentity)(projectRoot).name || "someone";
+}
+function counts(projectRoot) {
+  const writers = /* @__PURE__ */ new Set();
+  let records = 0;
+  for (const { files } of itemFolders(projectRoot)) {
+    for (const f of files) {
+      records++;
+      const m = /^([a-f0-9]{8,32})-\d+/.exec(f);
+      if (m) writers.add(m[1]);
+    }
+  }
+  return { records, writers: writers.size };
+}
+function checkedCounts(projectRoot) {
+  const me = writerId();
+  const ctx = (0, import_trust.checkContext)(projectRoot);
+  let verified = 0;
+  const reasons = /* @__PURE__ */ new Map();
+  const home = (0, import_plans_home.plansHome)(projectRoot);
+  for (const f of home ? itemFolders(projectRoot) : []) {
+    for (const r of readFolder(home, f)) {
+      if (r.writer === me) continue;
+      const v = (0, import_trust.verifyTaskRecord)(r, signedOf(r), ctx);
+      if (v.verified) verified++;
+      else reasons.set(v.why, (reasons.get(v.why) ?? 0) + 1);
+    }
+  }
+  const list = [...reasons].map(([why, n]) => ({ why, records: n })).sort((a, b) => b.records - a.records);
+  return { verified, unverified: list.reduce((t, r) => t + r.records, 0), reasons: list };
+}
+function getSharedTaskState(projectRoot) {
+  const row = rowOf(projectRoot);
+  const enabled = row?.enabled === true;
+  const { records, writers } = counts(projectRoot);
+  const name = writerName(projectRoot);
+  const home = (0, import_plans_home.plansHome)(projectRoot);
+  if (home) (0, import_trust.readKeyIntroductions)(home, writerId());
+  const found = records ? ` ${records} record${records === 1 ? "" : "s"} from ${writers} ${writers === 1 ? "device" : "devices"} are in the project's files.` : "";
+  return {
+    project: projectRoot,
+    enabled,
+    changedAt: row?.changedAt ?? null,
+    changedBy: row?.changedBy ?? null,
+    writer: writerId(),
+    name,
+    records,
+    writers,
+    says: enabled ? `On: each change to a task's state here is written to ${RECORDS_DIR} as ${name}, and teammates' records are read.${found}` : `Off. Task state stays on this device; teammates who pull see the plan, not who is doing what.${found}`,
+    signing: (0, import_trust.signingWay)(projectRoot),
+    // Introduced where the records go: the project, or its linked plans folder.
+    keys: (0, import_trust.listTeammateKeys)(home && home !== projectRoot ? [projectRoot, home] : [projectRoot]),
+    checked: checkedCounts(projectRoot),
+    materialReads: materialReadsStatus(projectRoot, enabled, home),
+    runs: runsStatus(projectRoot, enabled, home)
+  };
+}
+function runsStatus(projectRoot, sharing, home) {
+  const teammates = (0, import_teammate_runs.listTeammateRuns)(projectRoot).map((r) => ({
+    who: r.who,
+    verified: r.verified,
+    at: r.at,
+    commit: r.commit,
+    tests: r.totals.tests,
+    failing: r.totals.failed + r.totals.errors
+  }));
+  const from = teammates.length ? ` Runs from ${[...new Set(teammates.map((t) => t.who))].join(", ")} are here.` : "";
+  return {
+    mine: (0, import_test_runs.myRunCount)(home, writerId()),
+    teammates,
+    says: sharing ? `On with task state: each test run reported here is written to ${import_test_runs.RUNS_DIR}, and teammates' runs ground your files by the commit they ran on.${from}` : "Shared with task state: turn that on first."
+  };
+}
+(0, import_test_results.setReportListener)((run) => {
+  if (!isSharingTaskState(run.projectRoot)) return;
+  const home = (0, import_plans_home.plansHome)(run.projectRoot);
+  if (!home) return;
+  (0, import_test_runs.writeRunRecord)({ projectRoot: run.projectRoot, home, me: writerId(), name: writerName(run.projectRoot) }, run);
+});
+(0, import_check_runs2.setCheckRunListener)((run) => {
+  if (!isSharingTaskState(run.projectRoot)) return;
+  const home = (0, import_plans_home.plansHome)(run.projectRoot);
+  if (!home) return;
+  (0, import_check_runs.writeCheckRunRecord)({ projectRoot: run.projectRoot, home, me: writerId(), name: writerName(run.projectRoot) }, run);
+});
+function materialReadsStatus(projectRoot, sharing, home) {
+  const choice = (0, import_material_reads.materialReadsChoice)(projectRoot, sharing);
+  const n = (0, import_material_reads.readCounts)(projectRoot, home, writerId());
+  const people = n.people.length ? n.people.join(", ") : null;
+  const says = !sharing ? "Shared with task state: turn that on first." : !choice.enabled ? "Off: which version of each material your tasks read stays on this device, and teammates' reads are not used." : `On: which version of each material your tasks read is written to ${import_material_reads.READS_DIR}, and teammates' reads are compared with yours.${people ? ` Reads from ${people} are here.` : ""}`;
+  return { ...choice, ...n, says };
+}
+function isSharingMaterialReads(projectRoot) {
+  return (0, import_material_reads.materialReadsChoice)(projectRoot, isSharingTaskState(projectRoot)).enabled;
+}
+function setSharedMaterialReads(projectRoot, enabled, by) {
+  (0, import_material_reads.setMaterialReadsChoice)(projectRoot, enabled, by);
+  if (!enabled) (0, import_material_reads.forgetTeammateReads)(projectRoot);
+  else {
+    const home = (0, import_plans_home.plansHome)(projectRoot);
+    if (home && isSharingTaskState(projectRoot)) (0, import_material_reads.readTeammateReads)(projectRoot, home, writerId());
+  }
+  splitsChanged(projectRoot);
+  return getSharedTaskState(projectRoot);
+}
+function shareMaterialRead(itemUid, attachmentUid, by) {
+  const item = (0, import_plan_item_service.getItem)(itemUid);
+  if (!item) return null;
+  const root = sharingRootOf(item.planUid);
+  if (!root || !isSharingMaterialReads(root)) return null;
+  const home = (0, import_plans_home.plansHome)(root);
+  if (!home) return null;
+  const att = (0, import_database.getDb)().exec("SELECT value, sha256, kind FROM attachments WHERE uid = ?", [attachmentUid])[0]?.values[0];
+  if (!att || String(att[2]) !== "file_ref") return null;
+  try {
+    return (0, import_material_reads.writeReadRecord)(
+      { projectRoot: root, home, me: writerId(), name: writerName(root) },
+      { plan: item.planUid, item: item.uid, by, material: String(att[0]), attachment: attachmentUid, sha256: att[1] == null ? null : String(att[1]) }
+    );
+  } catch (err) {
+    console.warn("[TaskRecords] could not write a material-read record:", err.message);
+    return null;
+  }
+}
+function setSharedTaskState(projectRoot, enabled, by) {
+  (0, import_database.getDb)().run(
+    `INSERT INTO shared_task_state (project_root, enabled, changed_at, changed_by) VALUES (?, ?, ?, ?)
+     ON CONFLICT(project_root) DO UPDATE SET enabled = excluded.enabled, changed_at = excluded.changed_at, changed_by = excluded.changed_by`,
+    [projectRoot, enabled ? 1 : 0, Date.now(), by]
+  );
+  (0, import_persistence.markDirty)();
+  if (enabled) {
+    void startRecordWatcher(projectRoot);
+    readProjectRecords(projectRoot);
+  } else {
+    stopRecordWatcher(projectRoot);
+    if ((0, import_material_reads.forgetTeammateReads)(projectRoot)) splitsChanged(projectRoot);
+    if ((0, import_teammate_runs.forgetTeammateRuns)({ projectRoot })) runsChanged(projectRoot);
+    if ((0, import_check_runs2.forgetTeammateCheckRuns)({ projectRoot })) checkRunsChanged(projectRoot);
+  }
+  return getSharedTaskState(projectRoot);
+}
+function itemFolders(projectRoot, onlyPlan) {
+  const home = (0, import_plans_home.plansHome)(projectRoot);
+  if (!home) return [];
+  const root = import_node_path.default.join(home, RECORDS_DIR);
+  const out = [];
+  const dirs = (d) => {
+    try {
+      return import_node_fs.default.readdirSync(d, { withFileTypes: true }).filter((e) => e.isDirectory() && (0, import_record.isRecordId)(e.name)).map((e) => e.name);
+    } catch {
+      return [];
+    }
+  };
+  for (const plan of dirs(root)) {
+    if (onlyPlan && plan !== onlyPlan) continue;
+    for (const item of dirs(import_node_path.default.join(root, plan))) {
+      const dir = import_node_path.default.join(root, plan, item);
+      let files = [];
+      try {
+        files = import_node_fs.default.readdirSync(dir, { withFileTypes: true }).filter((e) => e.isFile() && e.name.endsWith(".yaml") && !e.name.startsWith(".")).map((e) => e.name).slice(0, MAX_RECORDS_PER_ITEM);
+      } catch {
+      }
+      out.push({ plan, item, dir, files });
+    }
+  }
+  return out;
+}
+const signedParts = /* @__PURE__ */ new WeakMap();
+const UNSIGNED = { bytes: "", signature: null };
+const signedOf = (r) => signedParts.get(r) ?? UNSIGNED;
+function readOne(home, f, name) {
+  if ((0, import_cloud_files.isPlaceholder)(import_node_path.default.join(f.dir, name))) return null;
+  let text;
+  try {
+    text = (0, import_confined_fs.readTextWithin)(home, import_node_path.default.join(f.dir, name), "task record");
+  } catch {
+    return null;
+  }
+  const parsed = (0, import_record.parseRecord)(text, { plan: f.plan, item: f.item });
+  if (!("record" in parsed)) return null;
+  signedParts.set(parsed.record, parsed.signed);
+  return parsed.record;
+}
+function readFolder(home, f) {
+  const out = [];
+  for (const name of f.files) {
+    const r = readOne(home, f, name);
+    if (r) out.push(r);
+  }
+  return out;
+}
+function itemFolder(projectRoot, home, planUid, itemUid) {
+  const dir = import_node_path.default.join(home, RECORDS_DIR, planUid, itemUid);
+  return itemFolders(projectRoot, planUid).find((f) => f.item === itemUid) ?? { plan: planUid, item: itemUid, dir, files: [] };
+}
+let splitListener;
+let runsListener;
+function setRunsChangedListener(fn) {
+  runsListener = fn;
+}
+function runsChanged(projectRoot) {
+  try {
+    runsListener?.(projectRoot);
+  } catch {
+  }
+}
+let checkRunsListener;
+function setCheckRunsChangedListener(fn) {
+  checkRunsListener = fn;
+}
+function checkRunsChanged(projectRoot) {
+  try {
+    checkRunsListener?.(projectRoot);
+  } catch {
+  }
+}
+function setSplitChangedListener(fn) {
+  splitListener = fn;
+}
+function splitsChanged(projectRoot) {
+  try {
+    splitListener?.(projectRoot);
+  } catch (err) {
+    console.warn("[TaskRecords] signal refresh failed:", err);
+  }
+}
+function stateOf(item) {
+  return {
+    status: item.status ?? null,
+    assignee: item.assignee ?? null,
+    assigneeType: item.assigneeType ?? null,
+    progressPercent: item.progressPercent ?? null,
+    blockedReason: item.blockedReason ?? null
+  };
+}
+function sharingRootOf(planUid) {
+  const plan = (0, import_plan_service.getPlan)(planUid);
+  if (!plan?.projectPath || !import_node_path.default.isAbsolute(plan.projectPath)) return null;
+  if (!isSharingTaskState(plan.projectPath)) return null;
+  if (!(0, import_plan_file_service.getLinkedPlanDir)(planUid, plan.projectPath)) return null;
+  return plan.projectPath;
+}
+function writeRecordFor(item, by, now = Date.now()) {
+  if (!(0, import_record.isRecordId)(item.planUid) || !(0, import_record.isRecordId)(item.uid)) return null;
+  const root = sharingRootOf(item.planUid);
+  if (!root) return null;
+  const home = (0, import_plans_home.plansHome)(root);
+  if (!home) return null;
+  const me = writerId();
+  const folder = itemFolder(root, home, item.planUid, item.uid);
+  const existing = readFolder(home, folder);
+  const mine = existing.filter((r) => r.writer === me);
+  let counter = Math.max(0, ...mine.map((r) => r.counter), ...folder.files.map((f) => f.startsWith(`${me}-`) ? parseInt(f.slice(me.length + 1), 10) || 0 : 0)) + 1;
+  while (import_node_fs.default.existsSync(import_node_path.default.join(folder.dir, (0, import_record.recordFileName)(me, counter)))) counter++;
+  const others = (0, import_record.seenOf)(existing.filter((r) => r.writer !== me));
+  const record = {
+    writer: me,
+    name: writerName(root),
+    counter,
+    seen: others,
+    at: now,
+    plan: item.planUid,
+    item: item.uid,
+    by,
+    state: stateOf(item)
+  };
+  const signature = (0, import_trust.signRecord)(root, home, record, (0, import_record.recordBytes)(record));
+  const file = (0, import_confined_fs.writeFileWithin)(home, import_node_path.default.join(folder.dir, (0, import_record.recordFileName)(me, counter)), (0, import_record.serializeRecord)(record, signature), "task record");
+  const ended = !!(0, import_heads.headOf)(item.uid)?.split;
+  (0, import_heads.setHead)(item.uid, me, counter, null);
+  if (ended) splitsChanged(root);
+  return file;
+}
+function keepMyState(itemUid, by) {
+  const item = (0, import_plan_item_service.getItem)(itemUid);
+  if (!item || item.kind !== "action") return { ok: false, status: 404, error: "no such task" };
+  if (!(0, import_heads.splitOf)(itemUid)) return { ok: false, status: 409, error: "Nobody set this task two ways at once, so there is nothing to settle." };
+  const file = writeRecordFor(item, by);
+  if (!file) return { ok: false, status: 409, error: "This project does not share task state, so no record can be written." };
+  return { ok: true, file: import_node_path.default.basename(file) };
+}
+function recordCheck(r, v) {
+  const person = r.by.authorType === "human" || r.by.authorType === "unverified" || r.by.author === r.name;
+  const as = (who) => person ? who : `${r.by.author} for ${who}`;
+  return v.verified ? { verified: true, claimed: as(r.name), how: v.how, who: v.who, author: as(v.who) } : { verified: false, claimed: as(r.name), why: v.why };
+}
+function recordAuthor(check) {
+  return { author: check.verified && check.author ? check.author : check.claimed, authorType: "record" };
+}
+const claimOf = (r, forged = false) => ({ name: r.name, status: r.state.status, at: r.at, ...forged ? { forged: true } : {} });
+function readProjectRecords(projectRoot, onlyPlan, onApplied) {
+  const result = { read: 0, applied: [], split: [] };
+  if (!isSharingTaskState(projectRoot)) return result;
+  const me = writerId();
+  const home = (0, import_plans_home.plansHome)(projectRoot);
+  if (!home) return result;
+  (0, import_trust.readKeyIntroductions)(home, me);
+  let ctx = null;
+  let changed = false;
+  for (const f of itemFolders(projectRoot, onlyPlan)) {
+    const item = (0, import_plan_item_service.getItem)(f.item);
+    if (!item || item.planUid !== f.plan || item.kind !== "action") continue;
+    if ((0, import_plan_service.getPlan)(f.plan)?.projectPath !== projectRoot) continue;
+    const { records, clashing } = (0, import_record.distinctRecords)(readFolder(home, f));
+    result.read += records.length;
+    const read = (0, import_record.readItem)(records);
+    const known = (0, import_heads.headOf)(item.uid);
+    const claims = clashing.length ? clashing.flatMap((c) => [claimOf(records.find((r) => r.writer === c.writer && r.counter === c.counter), true), claimOf(c, true)]) : read.kind === "split" ? read.heads.map((h) => claimOf(h)) : null;
+    if (claims) {
+      const split = JSON.stringify(claims);
+      if (known?.split !== split) {
+        (0, import_heads.setHead)(item.uid, known?.writer ?? "", known?.counter ?? 0, split);
+        changed = true;
+      }
+      result.split.push(item.uid);
+      continue;
+    }
+    if (read.kind !== "settled") continue;
+    const { head } = read;
+    if (known && known.writer === head.writer && known.counter === head.counter && !known.split) continue;
+    if (known?.split) changed = true;
+    if (head.writer === me) {
+      (0, import_heads.setHead)(item.uid, head.writer, head.counter, null);
+      continue;
+    }
+    ctx ??= (0, import_trust.checkContext)(projectRoot);
+    const check = recordCheck(head, (0, import_trust.verifyTaskRecord)(head, signedOf(head), ctx));
+    (0, import_heads.setHead)(item.uid, head.writer, head.counter, null, check);
+    const s = head.state;
+    const applied = (0, import_plan_item_service.applyRecordedState)(item.uid, {
+      status: s.status ?? "pending",
+      assignee: s.assignee,
+      assigneeType: s.assigneeType,
+      progressPercent: s.progressPercent,
+      blockedReason: s.blockedReason
+    }, recordAuthor(check));
+    if (applied) {
+      result.applied.push(item.uid);
+      onApplied?.(applied);
+    }
+  }
+  if (isSharingMaterialReads(projectRoot) && (0, import_material_reads.readTeammateReads)(projectRoot, home, me, onlyPlan) > 0) changed = true;
+  if ((0, import_test_runs.readTeammateRuns)(projectRoot, home, me) > 0) runsChanged(projectRoot);
+  if ((0, import_check_runs.readTeammateCheckRuns)(projectRoot, home, me) > 0) checkRunsChanged(projectRoot);
+  if (changed) splitsChanged(projectRoot);
+  return result;
+}
+function trustTeammateKey(writer, fingerprint, trust, by) {
+  const key = (0, import_trust.decideKey)(writer, fingerprint, trust, by);
+  if (!key) return null;
+  (0, import_material_reads.forgetReadsBy)(writer);
+  (0, import_teammate_runs.forgetTeammateRuns)({ writer });
+  (0, import_check_runs2.forgetTeammateCheckRuns)({ writer });
+  const me = writerId();
+  for (const v of (0, import_database.getDb)().exec("SELECT project_root FROM shared_task_state WHERE enabled = 1")[0]?.values ?? []) {
+    const root = String(v[0]);
+    const home = (0, import_plans_home.plansHome)(root);
+    if (home && isSharingMaterialReads(root) && (0, import_material_reads.readTeammateReads)(root, home, me) > 0) splitsChanged(root);
+    if (home && (0, import_test_runs.readTeammateRuns)(root, home, me) > 0) runsChanged(root);
+    if (home && (0, import_check_runs.readTeammateCheckRuns)(root, home, me) > 0) checkRunsChanged(root);
+  }
+  const rechecked = [];
+  for (const h of (0, import_heads.headsBy)(writer)) {
+    const item = (0, import_plan_item_service.getItem)(h.itemUid);
+    const root = item ? (0, import_plan_service.getPlan)(item.planUid)?.projectPath : null;
+    const home = root ? (0, import_plans_home.plansHome)(root) : null;
+    if (!item || !root || !home || !(0, import_record.isRecordId)(item.planUid) || !(0, import_record.isRecordId)(item.uid)) continue;
+    const folder = { plan: item.planUid, item: item.uid, dir: import_node_path.default.join(home, RECORDS_DIR, item.planUid, item.uid) };
+    const r = readOne(home, folder, (0, import_record.recordFileName)(writer, h.counter));
+    if (!r) continue;
+    (0, import_heads.setHeadCheck)(item.uid, recordCheck(r, (0, import_trust.verifyTaskRecord)(r, signedOf(r), (0, import_trust.checkContext)(root))));
+    rechecked.push(item.uid);
+  }
+  return { key, rechecked };
+}
+const watchers = /* @__PURE__ */ new Map();
+const watcherReady = /* @__PURE__ */ new Map();
+let appliedListener;
+function setRecordAppliedListener(fn) {
+  appliedListener = fn;
+}
+function readAndTell(projectRoot, onlyPlan) {
+  return readProjectRecords(projectRoot, onlyPlan, appliedListener);
+}
+function startRecordWatcher(projectRoot) {
+  if (watchers.has(projectRoot)) return watcherReady.get(projectRoot) ?? Promise.resolve();
+  if (!isSharingTaskState(projectRoot)) return Promise.resolve();
+  const home = (0, import_plans_home.plansHome)(projectRoot);
+  if (!home) return Promise.resolve();
+  const dir = import_node_path.default.join(home, RECORDS_DIR);
+  const reads = import_node_path.default.join(home, import_material_reads.READS_DIR);
+  const runs = import_node_path.default.join(home, import_test_runs.RUNS_DIR);
+  try {
+    for (const d of [dir, reads, runs]) import_node_fs.default.mkdirSync(d, { recursive: true });
+  } catch {
+    return Promise.resolve();
+  }
+  let timer = null;
+  const watcher = import_chokidar.default.watch([dir, reads, runs], {
+    ignoreInitial: true,
+    persistent: true,
+    depth: 3,
+    followSymlinks: false,
+    awaitWriteFinish: { stabilityThreshold: 100, pollInterval: 50 }
+  });
+  watcher.on("all", (event, file) => {
+    if (event !== "add" && event !== "change" || !file?.endsWith(".yaml")) return;
+    if (timer) clearTimeout(timer);
+    timer = setTimeout(() => {
+      timer = null;
+      try {
+        readAndTell(projectRoot);
+      } catch (err) {
+        console.warn("[TaskRecords] read failed:", err);
+      }
+    }, 150);
+  });
+  watcher.on("error", (err) => console.warn("[TaskRecords] watcher error:", err));
+  watchers.set(projectRoot, watcher);
+  const ready = new Promise((resolve) => {
+    watcher.once("ready", () => resolve());
+    setTimeout(resolve, 5e3).unref?.();
+  });
+  watcherReady.set(projectRoot, ready);
+  return ready;
+}
+function stopRecordWatcher(projectRoot) {
+  const w = watchers.get(projectRoot);
+  if (!w) return;
+  watchers.delete(projectRoot);
+  watcherReady.delete(projectRoot);
+  void w.close();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RECORDS_DIR,
+  getSharedTaskState,
+  isSharingMaterialReads,
+  isSharingTaskState,
+  keepMyState,
+  readAndTell,
+  readProjectRecords,
+  setCheckRunsChangedListener,
+  setRecordAppliedListener,
+  setRunsChangedListener,
+  setSharedMaterialReads,
+  setSharedTaskState,
+  setSplitChangedListener,
+  shareMaterialRead,
+  startRecordWatcher,
+  stopRecordWatcher,
+  trustTeammateKey,
+  writeRecordFor,
+  writerId,
+  writerName
+});