@stringsync/splates 0.0.0-stage → 0.0.45

package/index-vcv9m93e.js

@@ -0,0 +1,1265 @@
+import {
+  Attachments,
+  CONFIG_FILE,
+  ConfigFiles,
+  SYSTEMS_FILE2,
+  checkSystems2
+} from "./index-4776671w.js";
+import {
+  LEGACY,
+  renameLegacyFiles,
+  removeLegacySkill
+} from "./index-k73tsw5g.js";
+import {
+  fail
+} from "./index-kaa44k7q.js";
+
+// update.ts
+import { color as color2 } from "webappwiz/log";
+
+// lanes-from-tags.ts
+import { isAbsolute, resolve } from "node:path";
+import { ConsoleLogger } from "webappwiz/log";
+import { FileLock, NodeFs as NodeFs2, NodePs } from "webappwiz/system";
+
+// todos.ts
+import { UuidProvider } from "webappwiz/id";
+import { NodeFs } from "webappwiz/system";
+
+// lanes.ts
+function lanes(todos, records) {
+  return named(todos, records).map((record) => lane(todos, record));
+}
+function named(todos, records) {
+  const unnamed = [
+    ...new Set(todos.flatMap((todo) => todo.lane === null || records.some((record) => record.id === todo.lane) ? [] : [todo.lane]))
+  ].sort((left, right) => left - right);
+  return [...records, ...unnamed.map((id) => ({ id, name: `Lane ${id}` }))];
+}
+function lane(todos, { id, name }) {
+  const steps = todos.filter((todo) => todo.lane === id).sort((left, right) => left.position - right.position);
+  const next = steps.find((todo) => todo.takenBy === null) ?? null;
+  const agents = [
+    ...new Set(steps.flatMap((todo) => todo.takenBy === null ? [] : [todo.takenBy]))
+  ];
+  const blockers = next === null ? [] : blockersOf(todos, next).filter((blocker) => blocker.lane !== id);
+  return {
+    id,
+    name,
+    todos: steps,
+    agents,
+    next,
+    blockers,
+    ready: next !== null && blockersOf(todos, next).length === 0
+  };
+}
+function blockersOf(todos, todo) {
+  return todos.filter((other) => todo.blockedBy.includes(other.id)).map(({ id, subject, lane, takenBy }) => ({ id, subject, lane, takenBy }));
+}
+function followers(todos, id) {
+  return todos.filter((todo) => todo.blockedBy.includes(id));
+}
+function isReady(todo) {
+  return todo.takenBy === null && todo.blockedBy.length === 0;
+}
+function cycle(todos, id, blocker) {
+  if (id === blocker) {
+    return [id, id];
+  }
+  const byId = new Map(todos.map((todo) => [todo.id, todo]));
+  const trail = (from, seen) => {
+    if (from === id) {
+      return [id];
+    }
+    if (seen.has(from)) {
+      return null;
+    }
+    seen.add(from);
+    for (const before of byId.get(from)?.blockedBy ?? []) {
+      const found = trail(before, seen);
+      if (found) {
+        return [...found, from];
+      }
+    }
+    return null;
+  };
+  const found = trail(blocker, new Set);
+  return found && [...found, id];
+}
+function settle(todos) {
+  const pending = [...todos];
+  const placed = new Set;
+  const byId = new Map(todos.map((todo) => [todo.id, todo]));
+  const free = (todo) => todo.lane === null || todo.blockedBy.every((id) => placed.has(id) || byId.get(id)?.lane !== todo.lane);
+  const order = [];
+  while (pending.length > 0) {
+    const at = Math.max(0, pending.findIndex(free));
+    const [todo] = pending.splice(at, 1);
+    placed.add(todo.id);
+    order.push(todo);
+  }
+  return order;
+}
+function misordered(todos) {
+  const at = new Map(todos.map((todo, i) => [todo.id, i]));
+  for (const [i, todo] of todos.entries()) {
+    if (todo.lane === null) {
+      continue;
+    }
+    for (const id of todo.blockedBy) {
+      const before = todos[at.get(id) ?? -1];
+      if (before && before.lane === todo.lane && (at.get(id) ?? -1) > i) {
+        return { todo, blockedBy: before };
+      }
+    }
+  }
+  return null;
+}
+function blockerLabel({ id, lane }, records) {
+  const name = records.find((record) => record.id === lane)?.name;
+  return `#${id}${lane === null ? "" : ` in ${name ?? `lane ${lane}`}`}`;
+}
+function aptName(todos, taken) {
+  const used = new Set(taken.map((name) => name.toLowerCase()));
+  const base = todos[0]?.subject ?? "New lane";
+  let name = base;
+  for (let count = 2;used.has(name.toLowerCase()); count++) {
+    name = `${base} ${count}`;
+  }
+  return name;
+}
+function mentioned(text) {
+  const prose = text.replace(/```[\s\S]*?(```|$)|`[^`\n]*`/g, " ");
+  return [
+    ...new Set([...prose.matchAll(MENTION)].map((match) => Number(match[1])))
+  ];
+}
+var MENTION = /(?<![\w/#&])#(\d+)\b/g;
+
+// todo.ts
+import { basename } from "node:path";
+class Todo {
+  todos;
+  state;
+  constructor(todos, state) {
+    this.todos = todos;
+    this.state = state;
+  }
+  get id() {
+    return this.state.id;
+  }
+  get subject() {
+    return this.state.subject;
+  }
+  get text() {
+    return this.state.text;
+  }
+  get position() {
+    return this.state.position;
+  }
+  get from() {
+    return this.state.from;
+  }
+  get takenBy() {
+    return this.state.takenBy;
+  }
+  get createdAt() {
+    return new Date(this.state.createdAt);
+  }
+  get waited() {
+    return Date.now() - this.createdAt.getTime();
+  }
+  async blockers(task, together = []) {
+    if (this.takenBy === task) {
+      return [];
+    }
+    return (await this.todos.all()).filter((other) => this.blockedBy.includes(other.id) && other.takenBy !== task && !together.includes(other.id));
+  }
+  async take(task) {
+    return this.todos.revise(this.id, (state) => {
+      if (state.takenBy !== null && state.takenBy !== task) {
+        fail("exists", `todo ${this.id} is already taken by '${state.takenBy}': pick another from \`splates todo list\``, { todo: this.id, takenBy: state.takenBy });
+      }
+      return { ...state, takenBy: task };
+    });
+  }
+  release() {
+    return this.todos.revise(this.id, (state) => ({
+      ...state,
+      takenBy: null
+    }));
+  }
+  get files() {
+    return this.state.files;
+  }
+  get blockedBy() {
+    return this.state.blockedBy;
+  }
+  get lane() {
+    return this.state.lane;
+  }
+  get attachments() {
+    return this.todos.attachments(this.id);
+  }
+  async update({
+    subject,
+    text,
+    position,
+    files = [],
+    keep,
+    blockedBy,
+    lane,
+    assignee
+  }) {
+    const words = wording(subject ?? this.subject, text ?? this.text);
+    if (words.subject === "") {
+      fail("usage", "a todo needs a subject: say what is left to do", {
+        todo: this.id
+      });
+    }
+    const kept = keep === undefined ? this.files : this.files.filter((path) => keep.includes(path));
+    await this.attachments.remove(this.files.filter((path) => !kept.includes(path)));
+    const added = await this.attachments.store(files);
+    const updated = await this.todos.revise(this.id, (state) => assigned({ ...state, ...words, files: [...kept, ...added] }, assignee === undefined ? state.assignee : assignee));
+    let linked = updated;
+    if (blockedBy !== undefined) {
+      linked = await this.todos.link(this.id, {
+        add: blockedBy.filter((id) => !updated.blockedBy.includes(id)),
+        drop: updated.blockedBy.filter((id) => !blockedBy.includes(id))
+      });
+    }
+    if (lane !== undefined && lane !== linked.lane) {
+      linked = await this.todos.arrange(this.id, lane);
+    }
+    return position === undefined ? linked : this.todos.move(this.id, position);
+  }
+  async remove() {
+    await this.todos.delete(this.id);
+    await this.attachments.clear();
+  }
+  discard() {
+    return this.todos.discard(this.state);
+  }
+}
+function cameFrom({ from, origin }) {
+  if (origin === undefined) {
+    return from;
+  }
+  const project = basename(origin.project);
+  return origin.task === null ? project : `${project}/${origin.task}`;
+}
+function assigned(state, assignee) {
+  const { assignee: _, ...rest } = state;
+  return assignee == null ? rest : { ...rest, assignee };
+}
+function wording(subject, text) {
+  const [first = "", ...rest] = subject.trim().split(`
+`);
+  return {
+    subject: first.trim(),
+    text: [rest.join(`
+`).trim(), text.trim()].filter(Boolean).join(`
+
+`)
+  };
+}
+async function recordUpdate(journal, todos, id, update) {
+  let before;
+  return journal.record("todo update", null, async () => {
+    before = (await todos.find(id)).state;
+    return update();
+  }, (after) => updated(before ?? after.state, after.state));
+}
+function updated(before, after) {
+  const named = (paths) => paths.map((path) => basename(path));
+  const attached = after.files.filter((path) => !before.files.includes(path));
+  const detached = before.files.filter((path) => !after.files.includes(path));
+  const blocked = after.blockedBy.filter((id) => !before.blockedBy.includes(id));
+  const unblocked = before.blockedBy.filter((id) => !after.blockedBy.includes(id));
+  const same = (old, now) => old?.agent === now?.agent && old?.model === now?.model;
+  const changed = {
+    ...after.subject === before.subject ? {} : { subject: after.subject },
+    ...after.text === before.text ? {} : { text: true },
+    ...after.position === before.position ? {} : { position: after.position },
+    ...after.lane === before.lane ? {} : { lane: after.lane },
+    ...blocked.length === 0 ? {} : { blocked },
+    ...unblocked.length === 0 ? {} : { unblocked },
+    ...attached.length === 0 ? {} : { attached: named(attached) },
+    ...detached.length === 0 ? {} : { detached: named(detached) },
+    ...same(before.assignee, after.assignee) ? {} : { assignee: after.assignee ?? null }
+  };
+  return { todo: after.id, subject: after.subject, changed };
+}
+function todosNamed(todos) {
+  return todos.map(({ id, subject }) => ({ id, subject }));
+}
+
+// todo-file.ts
+function parseTodoFile(raw) {
+  try {
+    const { tags = [], ...state } = JSON.parse(raw);
+    return {
+      state: {
+        ...state,
+        ...state.subject === undefined ? wording(state.text, "") : { subject: state.subject, text: state.text },
+        position: state.position ?? 0,
+        files: state.files ?? [],
+        blockedBy: state.blockedBy ?? [],
+        lane: state.lane ?? null
+      },
+      tags
+    };
+  } catch {
+    return null;
+  }
+}
+
+// todo-lanes.ts
+class TodoLanes {
+  todos;
+  fs;
+  constructor(todos, fs) {
+    this.todos = todos;
+    this.fs = fs;
+  }
+  async joinLanes(from, into) {
+    await this.todos.locked(async () => {
+      const states = await this.todos.stored();
+      const records = await this.records(states);
+      for (const lane of [from, into]) {
+        lacking(records, lane);
+      }
+      const moving = states.filter((state) => state.lane === from).map((state) => ({ ...state, lane: into }));
+      const rest = states.filter((state) => state.lane !== from);
+      const tail = rest.findLastIndex((state) => state.lane === into);
+      const order = settle([
+        ...rest.slice(0, tail + 1),
+        ...moving,
+        ...rest.slice(tail + 1)
+      ]);
+      for (const state of moving) {
+        await this.todos.save(state);
+      }
+      await this.todos.renumber(order);
+      await this.writeLanes(records.filter((record) => record.id !== from));
+    });
+  }
+  async addLane(name) {
+    return this.todos.locked(async () => {
+      const states = await this.todos.stored();
+      const records = await this.records(states);
+      const called = laneName(name, records);
+      const record = { id: await this.nextLaneId(states), name: called };
+      await this.writeLanes([...records, record]);
+      return record;
+    });
+  }
+  async renameLane(id, name) {
+    return this.todos.locked(async () => {
+      const records = await this.records(await this.todos.stored());
+      lacking(records, id);
+      const others = records.filter((record) => record.id !== id);
+      const renamed = {
+        ...records.find((record) => record.id === id),
+        name: laneName(name, others)
+      };
+      await this.writeLanes(records.map((record) => record.id === id ? renamed : record));
+      return renamed;
+    });
+  }
+  async moveLane(id, position) {
+    if (!Number.isInteger(position) || position <= 0) {
+      fail("usage", `'${position}' is not a position: 1 is the first lane`, {
+        position
+      });
+    }
+    return this.todos.locked(async () => {
+      const records = await this.records(await this.todos.stored());
+      lacking(records, id);
+      const moved = records.find((record) => record.id === id);
+      const rest = records.filter((record) => record.id !== id);
+      const at = Math.min(position - 1, rest.length);
+      const order = [...rest.slice(0, at), moved, ...rest.slice(at)];
+      await this.writeLanes(order);
+      return order;
+    });
+  }
+  async dropLane(id) {
+    await this.todos.locked(async () => {
+      const states = await this.todos.stored();
+      const records = await this.records(states);
+      lacking(records, id);
+      for (const state of states.filter((state) => state.lane === id)) {
+        await this.todos.save({ ...state, lane: null });
+      }
+      await this.writeLanes(records.filter((record) => record.id !== id));
+    });
+  }
+  async endLanes(ids) {
+    await this.todos.locked(async () => {
+      const states = await this.todos.stored();
+      const records = await this.records(states);
+      const done = new Set(ids.filter((id) => !states.some((state) => state.lane === id)));
+      if (done.size > 0) {
+        await this.writeLanes(records.filter((record) => !done.has(record.id)));
+      }
+    });
+  }
+  async moveTagsToLanes() {
+    return this.todos.locked(async () => {
+      const entries = await this.fs.readdir(this.todos.dir).catch(() => []);
+      const parsed = [];
+      for (const entry of entries.filter((entry) => entry.endsWith(".json"))) {
+        const raw = await this.fs.read(`${this.todos.dir}/${entry}`).catch(() => "");
+        const found = parseTodoFile(raw);
+        if (found !== null && found.tags.length > 0) {
+          parsed.push(found);
+        }
+      }
+      if (parsed.length === 0) {
+        return [];
+      }
+      const counts = new Map;
+      for (const { tags } of parsed) {
+        for (const tag of tags) {
+          counts.set(tag, (counts.get(tag) ?? 0) + 1);
+        }
+      }
+      const states = await this.todos.stored(parsed.map(({ state }) => state.id));
+      const records = await this.records(states);
+      const filled = new Map;
+      for (const state of states) {
+        const tags = parsed.find((each) => each.state.id === state.id)?.tags;
+        if (tags === undefined) {
+          continue;
+        }
+        let lane = state.lane;
+        if (lane === null) {
+          const [tag] = [...tags].sort((left, right) => (counts.get(right) ?? 0) - (counts.get(left) ?? 0) || left.localeCompare(right));
+          const name = tagName(tag);
+          let record = records.find((each) => each.name.toLowerCase() === name.toLowerCase());
+          if (record === undefined) {
+            record = { id: await this.nextLaneId(states), name };
+            records.push(record);
+            await this.writeLanes(records);
+          }
+          lane = record.id;
+          filled.set(lane, [...filled.get(lane) ?? [], state.id]);
+        }
+        await this.todos.save({ ...state, lane });
+      }
+      await this.todos.renumber(settle(await this.todos.stored()));
+      return records.filter((record) => filled.has(record.id)).map((lane) => ({ lane, todos: filled.get(lane.id) ?? [] }));
+    });
+  }
+  async laneId(lane, states, todos, name) {
+    if (lane === null) {
+      return null;
+    }
+    if (lane !== "new") {
+      lacking(await this.records(states), lane);
+      return lane;
+    }
+    return (await this.newLane(states, todos, name)).id;
+  }
+  async newLane(states, todos, name) {
+    const records = await this.records(states);
+    const called = name === undefined ? aptName(todos, records.map((each) => each.name)) : laneName(name, records);
+    const record = { id: await this.nextLaneId(states), name: called };
+    await this.writeLanes([...records, record]);
+    return record;
+  }
+  async nextLaneId(states) {
+    const last = Number(await this.fs.read(`${this.todos.dir}/last-lane`).catch(() => 0));
+    const records = await this.records(states);
+    const id = Math.max(Number.isInteger(last) ? last : 0, ...records.map((record) => record.id)) + 1;
+    await this.fs.mkdir(this.todos.dir);
+    await this.fs.write(`${this.todos.dir}/last-lane`, String(id));
+    return id;
+  }
+  async records(states) {
+    return named(states, await this.read("lanes"));
+  }
+  async names(states) {
+    const records = await this.records(states);
+    const ended = await this.read("ended-lanes");
+    return [
+      ...records,
+      ...ended.filter(({ id }) => !records.some((record) => record.id === id))
+    ];
+  }
+  async read(file) {
+    const raw = await this.fs.read(`${this.todos.dir}/${file}`).catch(() => "[]");
+    try {
+      const parsed = JSON.parse(raw);
+      if (Array.isArray(parsed)) {
+        return parsed.filter((each) => Number.isInteger(each?.id) && typeof each?.name === "string").map(({ id, name }) => ({ id, name }));
+      }
+    } catch {}
+    return [];
+  }
+  async writeLanes(records) {
+    const dropped = (await this.read("lanes")).filter(({ id }) => !records.some((record) => record.id === id));
+    if (dropped.length > 0) {
+      const ended = await this.read("ended-lanes");
+      await this.write("ended-lanes", [
+        ...ended.filter(({ id }) => !dropped.some((each) => each.id === id)),
+        ...dropped
+      ]);
+    }
+    await this.write("lanes", records);
+  }
+  async write(file, records) {
+    await this.fs.mkdir(this.todos.dir);
+    const path = `${this.todos.dir}/${file}`;
+    const tmp = `${path}.${crypto.randomUUID()}.tmp`;
+    await this.fs.write(tmp, `${JSON.stringify(records, null, "\t")}
+`);
+    await this.fs.rename(tmp, path);
+  }
+}
+function tagName(tag) {
+  const words = tag.replaceAll("-", " ");
+  return words.charAt(0).toUpperCase() + words.slice(1);
+}
+function lacking(records, id) {
+  if (!records.some((record) => record.id === id)) {
+    fail("not_found", `no lane ${id}: run \`splates lane list\`, or pass \`new\` to start one`, { lane: id });
+  }
+}
+function laneName(name, others) {
+  const trimmed = name.trim();
+  if (trimmed === "") {
+    fail("usage", "a lane needs a name: say what its todos are for", {});
+  }
+  const same = others.find((other) => other.name.toLowerCase() === trimmed.toLowerCase());
+  if (same) {
+    fail("exists", `lane ${same.id} is already called '${same.name}': pick another name`, { lane: same.id, name: same.name });
+  }
+  return trimmed;
+}
+
+// todos.ts
+class Todos {
+  dir;
+  lock;
+  fs;
+  ids;
+  laneFiles;
+  constructor(dir, lock, opts = {}) {
+    this.dir = dir;
+    this.lock = lock;
+    this.fs = opts.fs ?? new NodeFs;
+    this.ids = opts.ids ?? new UuidProvider;
+    this.laneFiles = new TodoLanes(this, this.fs);
+  }
+  attachments(id) {
+    return new Attachments(`${this.dir}/${id}`, this.fs, this.ids);
+  }
+  owns(path) {
+    return new Attachments(this.dir, this.fs).owns(path);
+  }
+  async add(subject, from, {
+    text = "",
+    files = [],
+    position,
+    blockedBy = [],
+    lane = null,
+    assignee = null,
+    origin
+  } = {}) {
+    const words = wording(subject, text);
+    if (words.subject === "") {
+      fail("usage", "a todo needs a subject: say what is left to do", {});
+    }
+    await this.fs.mkdir(this.dir);
+    return this.locked(async () => {
+      const stored = await this.stored();
+      for (const id of blockedBy) {
+        if (!stored.some((other) => other.id === id)) {
+          missing(id);
+        }
+      }
+      const id = await this.lastId() + 1;
+      await this.fs.write(`${this.dir}/last`, String(id));
+      const state = {
+        id,
+        ...words,
+        position: 0,
+        from,
+        createdAt: new Date().toISOString(),
+        takenBy: null,
+        files: await this.attachments(id).store(files),
+        blockedBy: [...new Set(blockedBy)].sort((left, right) => left - right),
+        lane: null,
+        ...origin === undefined ? {} : { origin }
+      };
+      const todo = await this.save(assigned({
+        ...state,
+        lane: await this.laneFiles.laneId(lane, stored, [state])
+      }, assignee));
+      await this.place(todo.state, position);
+      return this.settled(todo.id);
+    });
+  }
+  async all() {
+    return (await this.stored()).map((state, i) => new Todo(this, { ...state, position: i + 1 }));
+  }
+  async find(id) {
+    return (await this.all()).find((todo) => todo.id === id) ?? missing(id);
+  }
+  async takenBy(task) {
+    return (await this.all()).filter((todo) => todo.takenBy === task);
+  }
+  async move(id, position) {
+    return this.locked(async () => {
+      const state = await this.state(id);
+      this.ordered(slot(await this.stored(), state, position));
+      return this.place(state, position);
+    });
+  }
+  async link(id, { add = [], drop = [] }) {
+    return this.locked(async () => {
+      const states = await this.stored();
+      const state = states.find((other) => other.id === id) ?? missing(id);
+      for (const before of add) {
+        if (!states.some((other) => other.id === before)) {
+          missing(before);
+        }
+        const loop = cycle(states, id, before);
+        if (loop) {
+          fail("cycle", loop.length === 2 ? `todo ${id} cannot come after itself` : `todo ${id} cannot come after todo ${before}: that makes a loop, ${loop.map((each) => `#${each}`).join(" → ")}, where each has to merge before the next`, { todo: id, blockedBy: before, cycle: loop });
+        }
+      }
+      const unknown = drop.find((before) => !state.blockedBy.includes(before));
+      if (unknown !== undefined) {
+        fail("not_found", `todo ${id} does not come after todo ${unknown}: nothing was changed`, { todo: id, blockedBy: unknown });
+      }
+      await this.save({
+        ...state,
+        blockedBy: [...new Set([...state.blockedBy, ...add])].filter((before) => !drop.includes(before)).sort((left, right) => left - right)
+      });
+      return this.settled(id);
+    });
+  }
+  async arrange(id, lane, { before, name } = {}) {
+    return this.locked(async () => {
+      const states = await this.stored();
+      const state = states.find((other) => other.id === id) ?? missing(id);
+      const moved = {
+        ...state,
+        lane: await this.laneFiles.laneId(lane, states, [state], name)
+      };
+      const rest = states.filter((other) => other.id !== id);
+      let at;
+      if (before !== undefined) {
+        at = rest.findIndex((other) => other.id === before);
+        if (at === -1) {
+          missing(before);
+        }
+      } else {
+        const tail = rest.findLastIndex((other) => moved.lane !== null && other.lane === moved.lane);
+        at = tail === -1 ? states.findIndex((other) => other.id === id) : tail + 1;
+      }
+      const order = [...rest.slice(0, at), moved, ...rest.slice(at)];
+      this.ordered(order);
+      await this.save(moved);
+      await this.renumber(order);
+      return this.find(id);
+    });
+  }
+  async lanes() {
+    return this.laneFiles.records(await this.stored());
+  }
+  async laneNames() {
+    return this.laneFiles.names(await this.stored());
+  }
+  joinLanes(from, into) {
+    return this.laneFiles.joinLanes(from, into);
+  }
+  addLane(name) {
+    return this.laneFiles.addLane(name);
+  }
+  renameLane(id, name) {
+    return this.laneFiles.renameLane(id, name);
+  }
+  moveLane(id, position) {
+    return this.laneFiles.moveLane(id, position);
+  }
+  dropLane(id) {
+    return this.laneFiles.dropLane(id);
+  }
+  endLanes(ids) {
+    return this.laneFiles.endLanes(ids);
+  }
+  moveTagsToLanes() {
+    return this.laneFiles.moveTagsToLanes();
+  }
+  async revise(id, change) {
+    return this.locked(async () => this.save(change(await this.state(id))));
+  }
+  async save(state) {
+    const path = this.path(state.id);
+    const tmp = `${path}.${crypto.randomUUID()}.tmp`;
+    await this.fs.write(tmp, `${JSON.stringify(state, null, "\t")}
+`);
+    await this.fs.rename(tmp, path);
+    return new Todo(this, state);
+  }
+  async delete(id) {
+    await this.locked(async () => {
+      await this.fs.rm(this.path(id), { force: true });
+      const order = [];
+      for (const state of await this.stored()) {
+        if (state.blockedBy.includes(id)) {
+          const freed = {
+            ...state,
+            blockedBy: state.blockedBy.filter((before) => before !== id)
+          };
+          await this.save(freed);
+          order.push(freed);
+        } else {
+          order.push(state);
+        }
+      }
+      await this.renumber(order);
+    });
+  }
+  async discard(state) {
+    await this.fs.mkdir(this.removedDir);
+    const kept = { state, removedAt: new Date().toISOString() };
+    await this.fs.write(this.removedPath(state.id), `${JSON.stringify(kept, null, "\t")}
+`);
+    await this.delete(state.id);
+    const removed = await this.removed();
+    for (const { state: old } of removed.slice(0, -REMOVED_KEPT)) {
+      await this.fs.rm(this.removedPath(old.id), { force: true });
+      await this.attachments(old.id).clear();
+    }
+  }
+  async restore(id) {
+    return this.locked(async () => {
+      const raw = await this.fs.read(this.removedPath(id)).catch(() => null);
+      if (raw === null) {
+        fail("not_found", `no removed todo ${id} to put back: only the last ${REMOVED_KEPT} removed are kept`, { todo: id });
+      }
+      const { state } = JSON.parse(raw);
+      const stored = await this.stored();
+      if (stored.some((other) => other.id === id)) {
+        fail("exists", `todo ${id} is on the list already`, { todo: id });
+      }
+      const lanes = await this.laneFiles.records(stored);
+      const restored = await this.save({
+        ...state,
+        takenBy: null,
+        lane: lanes.some((lane) => lane.id === state.lane) ? state.lane : null,
+        blockedBy: state.blockedBy.filter((before) => stored.some((other) => other.id === before))
+      });
+      await this.fs.rm(this.removedPath(id), { force: true });
+      await this.place(restored.state, state.position);
+      return this.settled(id);
+    });
+  }
+  async locked(run) {
+    await this.lock.acquire();
+    try {
+      return await run();
+    } finally {
+      await this.lock.release();
+    }
+  }
+  async settled(id) {
+    await this.renumber(settle(await this.stored()));
+    return this.find(id);
+  }
+  ordered(order) {
+    const wrong = misordered(order);
+    if (wrong) {
+      fail("usage", `todo ${wrong.todo.id} comes after todo ${wrong.blockedBy.id} in lane ${wrong.todo.lane}, so it cannot go above it: \`splates todo update ${wrong.todo.id} --remove-blocked-by ${wrong.blockedBy.id}\` first, or move it to another lane`, {
+        todo: wrong.todo.id,
+        blockedBy: wrong.blockedBy.id,
+        lane: wrong.todo.lane
+      });
+    }
+  }
+  async state(id) {
+    const state = await this.read(this.path(id));
+    return state ?? missing(id);
+  }
+  async place(state, position) {
+    if (position !== undefined && (!Number.isInteger(position) || position <= 0)) {
+      fail("usage", `'${position}' is not a position: 1 is the top`, {
+        todo: state.id,
+        position
+      });
+    }
+    await this.renumber(slot(await this.stored(), state, position));
+    return this.find(state.id);
+  }
+  async stored(tagged = []) {
+    const entries = await this.fs.readdir(this.dir).catch(() => []);
+    const states = [];
+    for (const entry of entries.filter((entry) => entry.endsWith(".json"))) {
+      const state = await this.read(`${this.dir}/${entry}`, tagged);
+      if (state) {
+        states.push(state);
+      }
+    }
+    return states.sort((left, right) => (left.position || Infinity) - (right.position || Infinity) || left.id - right.id);
+  }
+  async renumber(order) {
+    for (const [i, state] of order.entries()) {
+      if (state.position !== i + 1) {
+        await this.save({ ...state, position: i + 1 });
+      }
+    }
+  }
+  get removedDir() {
+    return `${this.dir}/removed`;
+  }
+  removedPath(id) {
+    return `${this.removedDir}/${id}.json`;
+  }
+  async removed() {
+    const entries = await this.fs.readdir(this.removedDir).catch(() => []);
+    const kept = [];
+    for (const entry of entries.filter((each) => each.endsWith(".json"))) {
+      const raw = await this.fs.read(`${this.removedDir}/${entry}`).catch(() => null);
+      if (raw !== null) {
+        kept.push(JSON.parse(raw));
+      }
+    }
+    return kept.sort((left, right) => left.removedAt.localeCompare(right.removedAt));
+  }
+  path(id) {
+    return `${this.dir}/${id}.json`;
+  }
+  async lastId() {
+    const last = Number(await this.fs.read(`${this.dir}/last`).catch(() => 0));
+    const ids = (await this.all()).map((todo) => todo.id);
+    return Math.max(Number.isInteger(last) ? last : 0, ...ids);
+  }
+  async read(path, tagged = []) {
+    const raw = await this.fs.read(path).catch(() => null);
+    const found = raw === null ? null : parseTodoFile(raw);
+    if (found !== null && found.tags.length > 0 && !tagged.includes(found.state.id)) {
+      fail("outdated", [
+        `todo ${found.state.id} was saved with tags, and splates now groups todos in lanes instead, so it reads no todos until their tags are moved.`,
+        "Run `splates update` in this repository: it puts each tag's todos in a lane named after the tag, then splates works as before."
+      ].join(`
+`), { todo: found.state.id });
+    }
+    return found?.state ?? null;
+  }
+}
+var REMOVED_KEPT = 50;
+function slot(states, state, position) {
+  const rest = states.filter((other) => other.id !== state.id);
+  const at = Math.min((position ?? Infinity) - 1, rest.length);
+  return [...rest.slice(0, at), state, ...rest.slice(at)];
+}
+function missing(id) {
+  fail("not_found", `no todo ${id}: run \`splates todo list\``, { todo: id });
+}
+
+// lanes-from-tags.ts
+async function lanesFromTags(opts) {
+  const log = opts.log ?? new ConsoleLogger;
+  const fs = opts.fs ?? new NodeFs2;
+  const git = await commonDir(opts.dir, fs);
+  if (git === null || !await fs.exists(`${git}/splates/todos`)) {
+    return;
+  }
+  const todos = new Todos(`${git}/splates/todos`, new FileLock(`${git}/splates/todos.lock`, {
+    fs,
+    ps: opts.ps ?? new NodePs,
+    log
+  }), { fs });
+  for (const { lane, todos: moved } of await todos.moveTagsToLanes()) {
+    log.info(`moved ${moved.map((id) => `#${id}`).join(", ")} into lane ${lane.id} ${lane.name}, from their tag`);
+  }
+}
+async function commonDir(dir, fs) {
+  const dotGit = `${dir}/.git`;
+  if (!await fs.exists(dotGit)) {
+    return null;
+  }
+  if ((await fs.stat(dotGit)).isDirectory()) {
+    return dotGit;
+  }
+  const own = /^gitdir:\s*(.+)$/m.exec(await fs.read(dotGit))?.[1]?.trim();
+  if (own === undefined) {
+    return null;
+  }
+  const worktree = isAbsolute(own) ? own : resolve(dir, own);
+  const common = await fs.read(`${worktree}/commondir`).then((text) => text.trim()).catch(() => ".");
+  return isAbsolute(common) ? common : resolve(worktree, common);
+}
+
+// migrate-config.ts
+import { color } from "webappwiz/log";
+
+// config-source.ts
+function typedConfig(source) {
+  const imported = source.match(DEFINE_CONFIG_IMPORT);
+  const code = [...codeOf(source)];
+  const calls = code.filter(({ index }, at) => source.startsWith("defineConfig(", index) && !/[\w$.]/.test(source[code[at - 1]?.index ?? -1] ?? ""));
+  if (imported?.index === undefined || calls.length !== 1) {
+    return null;
+  }
+  const from = imported.index;
+  const [call] = calls;
+  const open = call.index + "defineConfig".length;
+  const close = code.find(({ index, depth }) => index > open && source[index] === ")" && depth === call.depth);
+  if (close === undefined) {
+    return null;
+  }
+  return source.slice(0, from) + 'import type { ConfigFile } from "@stringsync/splates/config";' + source.slice(from + imported[0].length, call.index) + source.slice(open + 1, close.index).trim() + " satisfies ConfigFile" + source.slice(close.index + 1);
+}
+var DEFINE_CONFIG_IMPORT = /import\s*\{\s*defineConfig\s*\}\s*from\s*["'](?:@stringsync\/)?splates\/config["'];?/;
+function withoutSystems(source) {
+  const code = [...codeOf(source)];
+  const keys = code.filter(({ index, objects }, at) => objects === 1 && KEY.test(source.slice(index)) && !/[\w$.]/.test(source[code[at - 1]?.index ?? -1] ?? ""));
+  if (keys.length !== 1) {
+    return null;
+  }
+  const [key] = keys;
+  const colon = source.indexOf(":", key.index);
+  const end = code.find(({ index, depth }) => index > colon && (source[index] === "," && depth === key.depth || source[index] === "}" && depth === key.depth - 1));
+  if (end === undefined) {
+    return null;
+  }
+  let from = key.index;
+  let to = source[end.index] === "," ? end.index + 1 : end.index;
+  const lineStart = source.lastIndexOf(`
+`, from - 1) + 1;
+  const rest = source.slice(to).match(/^[ \t]*(\/\/[^\n]*)?\n/);
+  if (/^\s*$/.test(source.slice(lineStart, from)) && rest !== null) {
+    from = lineStart;
+    to += rest[0].length;
+  } else if (source[end.index] === ",") {
+    to += (source.slice(to).match(/^[ \t]*/)?.[0] ?? "").length;
+  }
+  return source.slice(0, from) + source.slice(to);
+}
+var KEY = /^(systems|"systems"|'systems')\s*:/;
+function* codeOf(source) {
+  const open = [];
+  const objects = () => open.filter((each) => each === "{").length;
+  let i = 0;
+  let template = false;
+  while (i < source.length) {
+    const char = source[i];
+    if (template) {
+      if (char === "\\") {
+        i += 2;
+      } else if (char === "`") {
+        template = false;
+        i++;
+      } else if (source.startsWith("${", i)) {
+        open.push("${");
+        template = false;
+        i += 2;
+      } else {
+        i++;
+      }
+      continue;
+    }
+    if (source.startsWith("//", i)) {
+      const end = source.indexOf(`
+`, i);
+      i = end === -1 ? source.length : end;
+    } else if (source.startsWith("/*", i)) {
+      const end = source.indexOf("*/", i + 2);
+      i = end === -1 ? source.length : end + 2;
+    } else if (char === '"' || char === "'") {
+      yield { index: i, depth: open.length, objects: objects() };
+      i++;
+      while (i < source.length && source[i] !== char) {
+        i += source[i] === "\\" ? 2 : 1;
+      }
+      i++;
+    } else if (char === "`") {
+      template = true;
+      i++;
+    } else if (char === "}" && open.at(-1) === "${") {
+      open.pop();
+      template = true;
+      i++;
+    } else {
+      if ("{([".includes(char)) {
+        open.push(char);
+      } else if ("})]".includes(char)) {
+        open.pop();
+      }
+      yield { index: i, depth: open.length, objects: objects() };
+      i++;
+    }
+  }
+}
+
+// migrate-config.ts
+async function moveSystems({
+  root,
+  fs,
+  log
+}) {
+  const config = await new ConfigFiles(fs).importConfig(root);
+  if (config.systems === undefined) {
+    return 0;
+  }
+  const configPath = `${root}/${CONFIG_FILE}`;
+  const systemsPath = `${root}/${SYSTEMS_FILE2}`;
+  const byHand = `move \`systems\` from ${CONFIG_FILE} into ${SYSTEMS_FILE2} by hand`;
+  if (await fs.exists(systemsPath)) {
+    log.error(`both ${CONFIG_FILE} and ${SYSTEMS_FILE2} name systems: ${byHand}`);
+    return 1;
+  }
+  const systems = checkSystems2(`${configPath}: systems`, config.systems);
+  const before = await fs.read(configPath);
+  const after = withoutSystems(before);
+  if (after === null) {
+    log.error(`could not find \`systems\` to take out of ${CONFIG_FILE}: ${byHand}`);
+    return 1;
+  }
+  await fs.write(configPath, after);
+  const { systems: _, ...rest } = config;
+  const rewritten = await new ConfigFiles(fs).importConfig(root).catch(() => null);
+  if (rewritten === null || JSON.stringify(rewritten) !== JSON.stringify(rest)) {
+    await fs.write(configPath, before);
+    log.error(`taking \`systems\` out of ${CONFIG_FILE} changed the rest of it: ${byHand}`);
+    return 1;
+  }
+  await fs.write(systemsPath, systemsSource(systems));
+  const count = Object.keys(systems).length;
+  log.info(`${color.green("moved")} ${count} ${count === 1 ? "system" : "systems"} from ${CONFIG_FILE} to ${SYSTEMS_FILE2}`);
+  return 0;
+}
+async function typeConfig({
+  root,
+  fs,
+  log
+}) {
+  const path = `${root}/${CONFIG_FILE}`;
+  if (!await fs.exists(path)) {
+    return;
+  }
+  const before = await fs.read(path);
+  if (!before.includes("defineConfig")) {
+    return;
+  }
+  const after = typedConfig(before);
+  if (after === null) {
+    log.info(`left ${CONFIG_FILE} calling \`defineConfig\`: type it with \`satisfies ConfigFile\` by hand`);
+    return;
+  }
+  const config = await new ConfigFiles(fs).importConfig(root);
+  await fs.write(path, after);
+  const rewritten = await new ConfigFiles(fs).importConfig(root).catch(() => null);
+  if (JSON.stringify(rewritten) !== JSON.stringify(config)) {
+    await fs.write(path, before);
+    log.info(`left ${CONFIG_FILE} calling \`defineConfig\`: type it with \`satisfies ConfigFile\` by hand`);
+    return;
+  }
+  log.info(`${color.green("typed")} ${CONFIG_FILE} with \`satisfies ConfigFile\``);
+}
+function systemsSource(systems) {
+  const literal = JSON.stringify(systems, null, "\t").replace(/^(\s*)"([A-Za-z_$][\w$]*)":/gm, "$1$2:");
+  return `import type { SystemsFile } from "@stringsync/splates/systems";
+
+export default ${literal} satisfies SystemsFile;
+`;
+}
+
+// release.ts
+import { dirname } from "node:path";
+import { Duration } from "webappwiz/time";
+// package.json
+var package_default = {
+  name: "@stringsync/splates",
+  version: "0.0.45",
+  description: "Runs several AI coding agents on one repository at once, each in its own git worktree",
+  license: "MIT",
+  author: "stringsync LLC",
+  repository: {
+    type: "git",
+    url: "git+https://github.com/stringsync/splates.git",
+    directory: "packages/splates"
+  },
+  type: "module",
+  module: "index.ts",
+  bin: {
+    splates: "./index.ts",
+    arbor: "./index.ts"
+  },
+  exports: {
+    ".": "./index.ts",
+    "./asked": "./asked.ts",
+    "./probe-runtime": "./probe-runtime.ts",
+    "./testing/agent": "./fake-agent.ts",
+    "./config": "./config.ts",
+    "./heavy": "./heavy.ts",
+    "./skill-checks": "./skill-checks.ts",
+    "./systems": "./systems.ts",
+    "./tunnel-provider": "./tunnel-provider.ts",
+    "./update": "./update.ts"
+  },
+  imports: {
+    "#dev/*": "./dev/*"
+  },
+  engines: {
+    bun: ">=1.3"
+  },
+  publishConfig: {
+    access: "public"
+  },
+  dependencies: {
+    "@agentclientprotocol/sdk": "^1.7.0",
+    webappwiz: "^0.0.45",
+    zod: "^4.4.3"
+  },
+  devDependencies: {
+    "@assistant-ui/core": "^0.3.28",
+    "@assistant-ui/react": "^0.15.28",
+    "@assistant-ui/react-lexical": "^0.2.17",
+    "@assistant-ui/react-markdown": "^0.14.22",
+    "@assistant-ui/store": "^0.3.20",
+    "@base-ui/react": "^1.8.0",
+    "@dnd-kit/core": "^6.3.1",
+    "@dnd-kit/modifiers": "^9.0.0",
+    "@dnd-kit/sortable": "^10.0.0",
+    "@dnd-kit/utilities": "^3.2.2",
+    "@happy-dom/global-registrator": "^20.3.1",
+    "@lexical/history": "^0.52.0",
+    "@lexical/plain-text": "^0.52.0",
+    "@lexical/react": "^0.52.0",
+    "@lexical/utils": "^0.52.0",
+    "@tailwindcss/oxide": "^4.3.3",
+    "@testing-library/react": "^16.3.1",
+    "@types/bun": "1.3.14",
+    "@types/react": "^19.2.18",
+    "@types/react-dom": "^19.2.4",
+    "@webappwiz/react": "^0.0.45",
+    "@xterm/addon-fit": "^0.11.0",
+    "@xterm/addon-webgl": "^0.19.0",
+    "@xterm/xterm": "^6.0.0",
+    "class-variance-authority": "^0.7.1",
+    clsx: "^2.1.1",
+    lexical: "^0.52.0",
+    "lucide-react": "^1.49.0",
+    "markdown-to-jsx": "^9.10.3",
+    "radix-ui": "^1.7.0",
+    react: "^19.2.8",
+    "react-dom": "^19.2.8",
+    "remark-gfm": "^4.0.1",
+    "tailwind-merge": "^3.7.0",
+    tailwindcss: "^4.3.3",
+    "tw-animate-css": "^1.4.0",
+    "tw-shimmer": "^0.4.13",
+    zustand: "^5.0.15"
+  },
+  scripts: {
+    build: "bun run build.ts"
+  }
+};
+
+// release.ts
+var RUNNING = package_default.version;
+var REGISTRY = "https://registry.npmjs.org/@stringsync%2fsplates/latest";
+var PATIENCE = Duration.secs(10);
+var SOURCE = [
+  import.meta.dirname,
+  dirname(dirname(Bun.fileURLToPath(import.meta.resolve("webappwiz/time"))))
+];
+async function sourceCommit(ps, source = SOURCE) {
+  const [here = "", ...rest] = source;
+  try {
+    const { exitCode, stdout } = await ps.spawnCapture([
+      "git",
+      "-C",
+      here,
+      "log",
+      "-1",
+      "--format=%H",
+      "--",
+      here,
+      ...rest
+    ]);
+    const commit = stdout.trim();
+    return exitCode === 0 && /^[0-9a-f]{40,64}$/.test(commit) ? commit : null;
+  } catch {
+    return null;
+  }
+}
+async function newest(registry = REGISTRY) {
+  try {
+    const response = await fetch(registry, {
+      signal: AbortSignal.timeout(PATIENCE.ms)
+    });
+    if (!response.ok) {
+      return null;
+    }
+    const { version } = await response.json();
+    return typeof version === "string" && parse(version) !== null ? version : null;
+  } catch {
+    return null;
+  }
+}
+function isNewer(version, than) {
+  const [mine, theirs] = [parse(version), parse(than)];
+  if (mine === null || theirs === null) {
+    return false;
+  }
+  for (let i = 0;i < 3; i += 1) {
+    if (mine[i] !== theirs[i]) {
+      return mine[i] > theirs[i];
+    }
+  }
+  return false;
+}
+function parse(version) {
+  const match = /^(\d+)\.(\d+)\.(\d+)$/.exec(version);
+  return match === null ? null : match.slice(1).map(Number);
+}
+
+// skills.ts
+import { ProjectSkills, SKILLS_DIR, versionOf } from "webappwiz/skills";
+var SOURCE2 = "stringsync/splates";
+function projectSkills(root, deps) {
+  return new ProjectSkills(root, { ...deps, source: SOURCE2 });
+}
+function installedVersion(fs, root) {
+  return fs.read(`${root}/${SKILLS_DIR}/splates/SKILL.md`).then(versionOf).catch(() => null);
+}
+
+// update.ts
+var UPDATING2 = "SPLATES_UPDATING";
+async function update2({
+  root,
+  fs,
+  ps,
+  log,
+  newest,
+  release
+}) {
+  if (release === undefined && newest && ps.env(UPDATING2) === undefined) {
+    const latest = await newest();
+    if (latest === null) {
+      log.info(`could not reach npm: refreshing from splates ${RUNNING}`);
+    } else if (isNewer(latest, RUNNING)) {
+      log.info(`${color2.green("updating")} splates ${RUNNING} to ${latest}`);
+      const { exitCode } = await ps.spawn(["bunx", `@stringsync/splates@${latest}`, "update"], { env: { [UPDATING2]: "1" } });
+      return exitCode;
+    }
+  }
+  await lanesFromTags({ dir: root, fs, ps, log });
+  await renameLegacyFiles({ root, fs, ps, log });
+  const skills = projectSkills(root, { fs, ps, log });
+  await skills.add(["splates"], release ?? RUNNING);
+  await removeLegacySkill(`${root}/${skills.path(LEGACY)}`, { fs, log });
+  const code = await moveSystems({ root, fs, log });
+  await typeConfig({ root, fs, log });
+  return code;
+}
+
+export { RUNNING, sourceCommit, newest, isNewer, projectSkills, installedVersion, lanes, lane, blockersOf, followers, isReady, blockerLabel, mentioned, cameFrom, wording, recordUpdate, todosNamed, Todos, UPDATING2, update2 };