@stringsync/splates 0.0.60 → 1.13.3

package/vendor/@stringsync/splates-server/index-0jttnv86.js

@@ -0,0 +1,1309 @@
+import {
+  LEGACY_PLAN_FILE2
+} from "./index-g18nxyn7.js";
+
+// plans/demo.ts
+var DEMO = /^### 🎬 Demo(?::[ \t]*(.*?))?[ \t]*$/;
+var STEP = /^(\d+)\.[ \t]+(.+)$/;
+function demoAt(lines, start, until) {
+  const title = DEMO.exec(lines[start]);
+  if (title === null) {
+    return null;
+  }
+  const first = lines.findIndex((line, at) => at > start && at < until && STEP.exec(line)?.[1] === "1");
+  const steps = [];
+  let end = first === -1 ? until : first;
+  if (first !== -1) {
+    let body = [];
+    for (let i = first;i < lines.length; i += 1) {
+      const line = lines[i];
+      const item = STEP.exec(line);
+      if (item !== null && item[1] === String(steps.length + 1)) {
+        body = [];
+        steps.push({
+          number: item[1],
+          action: (item[2] ?? "").trim(),
+          expect: ""
+        });
+        end = i + 1;
+        continue;
+      }
+      if (line.trim() === "") {
+        continue;
+      }
+      if (!/^[ \t]/.test(line)) {
+        break;
+      }
+      body.push(...lines.slice(end, i).map(() => ""), line);
+      steps.at(-1).expect = dedented(body);
+      end = i + 1;
+    }
+  }
+  return {
+    demo: {
+      title: title[1] || null,
+      intro: trimmed(lines.slice(start + 1, first === -1 ? until : first)),
+      steps
+    },
+    end
+  };
+}
+function isDemoTitle(line) {
+  return DEMO.test(line);
+}
+function dedented(lines) {
+  const indent = Math.min(...lines.filter((line) => line.trim() !== "").map((line) => /^[ \t]*/.exec(line)?.[0].length ?? 0));
+  return trimmed(lines.map((line) => line.slice(indent)));
+}
+function trimmed(lines) {
+  return lines.join(`
+`).replace(/^\n+|\s+$/g, "");
+}
+
+// plans/permission.ts
+function queueIsSettled2(proposal, todos) {
+  const { lane, tasks } = proposal;
+  const mine = lane === null ? tasks.flatMap((id) => todos.filter((todo) => todo.id === id)) : todos.filter((todo) => todo.lane === lane);
+  const byTask = lane === null || mine.length === 1;
+  return mine.filter((todo) => todo.takenBy === null).every((todo) => todo.stage === "queued" || !byTask && todo.unqueuedFor !== undefined);
+}
+function asksPermission(line) {
+  return [PERMISSION, GRANT_PERMISSION, EVALS_PERMISSION, RUN_PERMISSION].some((each) => each.test(line));
+}
+function permissionOf(line, body) {
+  const permission = PERMISSION.exec(line);
+  const evals = EVALS_PERMISSION.exec(line);
+  const run = RUN_PERMISSION.exec(line);
+  const grant = GRANT_PERMISSION.exec(line);
+  if (run !== null) {
+    const rows = body.split(`
+`);
+    const at = rows.findIndex((each) => RUN_COMMAND.test(each));
+    const command = at < 0 ? "" : RUN_COMMAND.exec(rows[at])?.[1];
+    return {
+      action: "run-command",
+      lane: null,
+      tasks: [],
+      title: run[1] || null,
+      body: rows.filter((_, index) => index !== at).join(`
+`).replace(/^\n+|\s+$/g, ""),
+      command
+    };
+  }
+  if (grant !== null) {
+    return {
+      action: "grant",
+      lane: null,
+      tasks: [],
+      title: grant[4] || null,
+      body: body.replace(COMMAND_LINE, "").replace(/^\n+|\s+$/g, ""),
+      grant: {
+        in: grant[1],
+        reach: grant[2],
+        from: grant[3]
+      }
+    };
+  }
+  if (evals !== null) {
+    const scenarios = [];
+    let baseline = null;
+    let reps;
+    const prose = body.split(`
+`).filter((each) => {
+      const scenario = EVAL_PROBE.exec(each);
+      if (scenario !== null) {
+        scenarios.push(scenario[1]);
+        return false;
+      }
+      const base = EVAL_BASELINE.exec(each);
+      if (base !== null) {
+        baseline = base[1];
+        return false;
+      }
+      const times = EVAL_REPS.exec(each);
+      if (times !== null && Number(times[1]) > 0) {
+        reps = Number(times[1]);
+        return false;
+      }
+      return true;
+    });
+    return {
+      action: "run-evals",
+      lane: null,
+      tasks: [],
+      title: evals[2] || null,
+      body: prose.join(`
+`).replace(/^\n+|\s+$/g, ""),
+      evals: {
+        skill: evals[1],
+        scenarios,
+        baseline,
+        ...reps === undefined ? {} : { reps }
+      }
+    };
+  }
+  if (permission !== null) {
+    const lane = permission[2] ?? permission[3] ?? permission[6];
+    return {
+      action: permission[1] === undefined ? "queue" : "remove-lane",
+      lane: lane === undefined ? null : Number(lane),
+      tasks: Array.from((permission[5] ?? permission[7] ?? "").matchAll(/\d+/g), Number),
+      ...permission[4] === undefined ? {} : { project: permission[4] },
+      title: permission[8] || null,
+      body: body.replace(COMMAND_LINE, "").replace(/^\n+|\s+$/g, "")
+    };
+  }
+  return null;
+}
+var EVALS_PERMISSION = /^## 🔐 Permission: run evals (\S+?)(?::[ \t]*(.*?))?[ \t]*$/;
+var EVAL_PROBE = /^[-*][ \t]+`([^`\s]+)`(?:[ \t].*)?$/;
+var EVAL_BASELINE = /^Baseline:[ \t]*`([^`\s]+)`[ \t]*$/;
+var EVAL_REPS = /^Repetitions:[ \t]*(\d+)[ \t]*$/;
+var RUN_PERMISSION = /^## 🔐 Permission: run command(?::[ \t]*(.*?))?[ \t]*$/;
+var RUN_COMMAND = /^`([^`\n]+)`[ \t]*$/;
+var PERMISSION = /^## (?:🔐 Permission: (?:(remove) lane (\d+)|queue (?:lane (\d+)|(?:([\w.-]+) )?(#\d+(?:,[ \t]*#\d+)*)))|📥 Queue (?:lane (\d+)|(#\d+(?:,[ \t]*#\d+)*)))(?::[ \t]*(.*?))?[ \t]*$/;
+var GRANT_PERMISSION = /^## 🔐 Permission: grant ([\w.-]+) (read|queue|tasks) to ([\w.-]+)(?::[ \t]*(.*?))?[ \t]*$/;
+var COMMAND_LINE = /^`splates [^`\n]+`[ \t]*$/gm;
+
+// plans/plan.ts
+import { Markdown } from "../../core/md/index.js";
+var PLAN_FILE2 = "SPLATES.md";
+
+class Plans2 {
+  fs;
+  constructor(fs) {
+    this.fs = fs;
+  }
+  read(tree) {
+    return this.fs.read(`${tree}/${PLAN_FILE2}`).catch(() => this.fs.read(`${tree}/${LEGACY_PLAN_FILE2}`)).catch(() => null);
+  }
+  async exclude(gitDir) {
+    const info = `${gitDir}/info`;
+    const excluded = await this.fs.read(`${info}/exclude`).catch(() => "");
+    if (!excluded.split(`
+`).includes(PLAN_FILE2)) {
+      await this.fs.mkdir(info);
+      await this.fs.write(`${info}/exclude`, `${excluded.trimEnd()}
+${PLAN_FILE2}
+`.trimStart());
+    }
+  }
+}
+var STUB_STEPS = [
+  "list the steps here as `- [ ]` items",
+  "fill in Goal and list the steps here as `- [ ]` items"
+];
+var SECTIONS = ["Goal", "Next", "Verification", "Demo", "Blocked", "Outcome"];
+var REQUIRED = ["Goal"];
+var QUESTION = /^[ \t]*- \[[ xX]\] [Qq]?\d+\./m;
+function goalLine2(text) {
+  const md = Markdown.parse(text);
+  if (!md.has("Goal")) {
+    return null;
+  }
+  const line = md.section("Goal").body.split(`
+`).find((line) => line.trim() !== "");
+  return line === undefined ? null : line.trim();
+}
+function sectionApart2(text, name) {
+  const md = Markdown.parse(text);
+  const found = md.sections.find((each) => each.level === 2 && each.heading.toLowerCase() === name.toLowerCase());
+  if (found === undefined) {
+    return { section: null, rest: text };
+  }
+  const lines = md.text.split(`
+`);
+  const next = md.sections.find((each) => each.line > found.line && each.level <= 2);
+  const start = found.line - 1;
+  const end = next === undefined ? lines.length : next.line - 1;
+  return {
+    section: lines.slice(start, end).join(`
+`).trim(),
+    rest: [...lines.slice(0, start), ...lines.slice(end)].join(`
+`)
+  };
+}
+function outcomeOf2(text) {
+  const md = Markdown.parse(text);
+  return md.has("Outcome") ? md.section("Outcome").body.trim() : "";
+}
+function goalOf2(text) {
+  const md = Markdown.parse(text);
+  return md.has("Goal") ? md.section("Goal").body.trim() : "";
+}
+var ITEM = /^[ \t]*- \[([ xX])\] [Qq]?(\d+)\.[ \t]*(.*)$/;
+var ARROW = " → ";
+var FOLLOW_UP = /^[ \t]+→[ \t]+(.*)$/;
+var CHOICE = /^([ \t]+)- (?:\(([a-z])\)|\[([a-z])\]|([a-z])\.)[ \t]+(.+?)[ \t]*$/;
+var CHOSEN = /[ \t]*\(chosen\)$/i;
+var SIZE = /^\(([a-z]+)\)[ \t]+/;
+function sized(text) {
+  const size = SIZE.exec(text);
+  return size === null ? { text, size: null } : { text: text.slice(size[0].length), size: size[1] };
+}
+function questions2(text) {
+  return items(sectionLines(text, "Blocked"));
+}
+function openQuestions2(text) {
+  return questions2(text).filter((asked) => !asked.done && asked.reply === null);
+}
+function items(lines) {
+  const found = [];
+  let last;
+  for (const { line } of lines) {
+    const asked = question(line);
+    if (asked !== null) {
+      last = { asked, body: [] };
+      found.push(last);
+      continue;
+    }
+    if (line.trim() !== "" && !/^[ \t]/.test(line)) {
+      last = undefined;
+    }
+    if (last === undefined) {
+      continue;
+    }
+    const followUp = FOLLOW_UP.exec(line);
+    if (followUp !== null) {
+      last.asked.followUps.push((followUp[1] ?? "").trim());
+    } else if (!offers(last.asked, line)) {
+      last.body.push(line);
+    }
+  }
+  return found.map(({ asked, body }) => settled(asked, body));
+}
+var INDENTS = new WeakMap;
+function offers(asked, line) {
+  const choice = CHOICE.exec(line);
+  if (choice === null) {
+    const last = asked.choices.at(-1);
+    const indent = /^[ \t]*/.exec(line)?.[0].length ?? 0;
+    if (last === undefined || line.trim() === "" || indent <= (INDENTS.get(last) ?? indent)) {
+      return false;
+    }
+    last.body = last.body === "" ? line : `${last.body}
+${line}`;
+    return true;
+  }
+  const [, indent = "", one, any, order, text = ""] = choice;
+  const offered = {
+    key: one ?? any ?? order ?? "",
+    text: text.replace(CHOSEN, ""),
+    body: "",
+    why: "",
+    chosen: CHOSEN.test(text)
+  };
+  INDENTS.set(offered, indent.length);
+  asked.choices.push(offered);
+  asked.pick ??= one !== undefined ? "one" : any !== undefined ? "any" : "order";
+  return true;
+}
+function settled(asked, body) {
+  asked.body = dedent(body);
+  for (const choice of asked.choices) {
+    Object.assign(choice, reasoned(dedent(choice.body.split(`
+`))));
+  }
+  return asked;
+}
+var WHY = /^why:[ \t]*(.*)$/i;
+function reasoned(body) {
+  const lines = body.split(`
+`);
+  const at = lines.findIndex((line) => WHY.test(line));
+  if (at === -1) {
+    return { body, why: "" };
+  }
+  return {
+    body: dedent(lines.filter((_, index) => index !== at)),
+    why: (WHY.exec(lines[at] ?? "")?.[1] ?? "").trim()
+  };
+}
+function dedent(lines) {
+  const indents = lines.filter((line) => line.trim() !== "").map((line) => /^[ \t]*/.exec(line)?.[0].length ?? 0);
+  const cut = indents.length === 0 ? 0 : Math.min(...indents);
+  return lines.map((line) => line.slice(cut).trimEnd()).join(`
+`).replace(/^\n+|\s+$/g, "");
+}
+function picks2(text) {
+  const asked = questions2(text);
+  const met = asked.map(metPick).filter((each) => each !== null);
+  return {
+    asked: asked.length,
+    picked: met.length,
+    overturned: met.filter((each) => each === "overturned").length,
+    amended: met.filter((each) => each === "amended").length
+  };
+}
+function metPick(asked) {
+  const chosen = asked.choices.find((choice) => choice.chosen);
+  const reply = asked.reply ?? "";
+  const [lead, wrapped, bare] = /^(?:- )?(?:\(([a-z])\)|([a-z])(?=[.,]|$))/i.exec(reply) ?? [];
+  const key = wrapped ?? bare;
+  if (chosen === undefined || key === undefined || asked.pick !== "one") {
+    return null;
+  }
+  if (key.toLowerCase() !== chosen.key) {
+    return "overturned";
+  }
+  return /[a-z0-9]/i.test(reply.slice(lead?.length ?? 0)) || asked.followUps.length > 0 ? "amended" : "kept";
+}
+function decisions2(text) {
+  return questions2(text).map((item) => ({
+    number: item.number,
+    text: item.text,
+    size: item.size,
+    ended: metPick(item)
+  }));
+}
+var STEP2 = /^[ \t]*- \[ \][ \t]*(.*)$/;
+function unfinished2(text) {
+  const md = Markdown.parse(text);
+  const next = md.has("Next") ? md.section("Next").body.split(`
+`) : [];
+  return {
+    questions: questions2(text).filter((asked) => !asked.done).map((asked) => asked.number),
+    steps: next.flatMap((line) => {
+      const step = STEP2.exec(line)?.[1];
+      return step === undefined ? [] : [step.trim()];
+    })
+  };
+}
+function ready2({ questions, steps }) {
+  return questions.length === 0 && steps.length === 0;
+}
+function whatIsLeft2({ questions, steps }) {
+  return [
+    questions.length > 0 ? `questions ${questions.join(", ")} unchecked under ## Blocked` : "",
+    steps.length > 0 ? `${steps.length} step${steps.length === 1 ? "" : "s"} unchecked under ## Next` : ""
+  ].filter(Boolean).join(" and ");
+}
+function question(line) {
+  const item = ITEM.exec(line);
+  if (item === null) {
+    return null;
+  }
+  const [, check = " ", number = "", rest = ""] = item;
+  const arrow = rest.indexOf(ARROW);
+  const { text, size } = sized((arrow === -1 ? rest : rest.slice(0, arrow)).trim());
+  return {
+    number,
+    done: check !== " ",
+    text,
+    size,
+    body: "",
+    reply: arrow === -1 ? null : rest.slice(arrow + ARROW.length).trim(),
+    followUps: [],
+    choices: [],
+    pick: null
+  };
+}
+function sectionLines(text, name) {
+  const { sections } = Markdown.parse(text);
+  const at = sections.findIndex((section) => section.heading.toLowerCase() === name.toLowerCase());
+  const blocked = sections[at];
+  if (blocked === undefined) {
+    return [];
+  }
+  const lines = text.split(`
+`);
+  const end = sections.slice(at + 1).find((later) => later.level <= blocked.level)?.line ?? lines.length + 1;
+  return lines.slice(blocked.line, end - 1).map((line, offset) => ({ index: blocked.line + offset, line }));
+}
+function checkPlan2(text, { task }) {
+  const md = Markdown.parse(text);
+  const problems = [];
+  const section = (name) => md.has(name) ? md.section(name).body : null;
+  if (md.title !== task) {
+    problems.push(md.title === null ? `no title: the first line should be "# ${task}"` : `title is "# ${md.title}", should be "# ${task}"`);
+  }
+  for (const name of REQUIRED) {
+    if (!md.has(name)) {
+      problems.push(`no ## ${name} section`);
+    }
+  }
+  if (section("Goal") === "") {
+    problems.push("## Goal is empty: say in a line or two what done means");
+  }
+  const blocked = section("Blocked");
+  if (blocked !== null && !QUESTION.test(blocked)) {
+    problems.push("## Blocked lists nothing: add `- [ ] 1.` items for what the user must answer");
+  }
+  const numbers = questions2(text).map((item) => item.number);
+  const twice = [
+    ...new Set(numbers.filter((each, at) => numbers.indexOf(each) !== at))
+  ];
+  if (twice.length > 0) {
+    problems.push(`${twice.join(", ")} numbered twice under ## Blocked: new questions continue from the highest`);
+  }
+  const known = [...SECTIONS, "Notes"].map((section) => section.toLowerCase());
+  for (const section of md.sections) {
+    if (section.level === 2 && !known.includes(section.heading.toLowerCase())) {
+      problems.push(`unexpected section "## ${section.heading}" (line ${section.line}): keep to ${SECTIONS.join(", ")}`);
+    }
+  }
+  return problems;
+}
+
+// plans/asked.ts
+function stretches2(text) {
+  const held = CUT.get(text);
+  if (held !== undefined) {
+    return held;
+  }
+  const found = cut(text);
+  if (CUT.size >= CUT_HELD) {
+    CUT.delete(CUT.keys().next().value);
+  }
+  CUT.set(text, found);
+  return found;
+}
+var CUT = new Map;
+var CUT_HELD = 256;
+function cut(text) {
+  const lines = text.split(`
+`);
+  const found = [];
+  let from = 0;
+  let fenced = false;
+  for (let i = 0;i < lines.length; i += 1) {
+    const line = lines[i];
+    if (FENCE.test(line)) {
+      fenced = !fenced;
+      continue;
+    }
+    if (fenced) {
+      continue;
+    }
+    const title = REVIEW.exec(line);
+    const end = title === null ? -1 : lines.findIndex((each, at) => at > i && each.trim() === REVIEW_END);
+    if (title !== null && end !== -1) {
+      found.push(...prose(lines.slice(from, i)));
+      found.push({
+        type: "review",
+        review: {
+          task: title[1],
+          base: title[2],
+          ...reviewOf(lines.slice(i + 1, end))
+        }
+      });
+      from = end + 1;
+      i = end;
+      continue;
+    }
+    const proposed = PROPOSED.exec(line);
+    if (proposed !== null) {
+      const end = endAt(lines, i + 1);
+      found.push(...prose(lines.slice(from, i)));
+      found.push({
+        type: "proposal",
+        proposal: {
+          subject: proposed[1],
+          body: trimmed2(lines.slice(i + 1, end))
+        }
+      });
+      from = end;
+      i = end - 1;
+      continue;
+    }
+    const demo = demoHere(lines, i);
+    if (demo !== null) {
+      found.push(...prose(lines.slice(from, i)));
+      found.push({ type: "demo", demo: demo.demo });
+      from = demo.end;
+      i = demo.end - 1;
+      continue;
+    }
+    const kept = keptAt(lines, i);
+    if (kept !== null) {
+      found.push(...prose(lines.slice(from, i)));
+      found.push(kept.stretch);
+      from = kept.end;
+      i = kept.end - 1;
+      continue;
+    }
+    if (ITEM2.exec(line)?.[1] !== "1") {
+      continue;
+    }
+    const list = listAt(lines, i);
+    if (list === null) {
+      continue;
+    }
+    found.push(...prose(lines.slice(from, i)));
+    found.push({ type: "questions", questions: list.questions });
+    from = list.end;
+    i = list.end - 1;
+  }
+  found.push(...prose(lines.slice(from)));
+  return found;
+}
+var ASKS = /\?(?:[ \t]+\([^()]*\))?$/;
+var ASKS_THEN = /^(.*?\?(?:[ \t]+\([^()]*\))?)[ \t]+(\S.*)$/;
+var MERGED = /^## ✅ Merged (\S+) onto (\S+)[ \t]*$/;
+var DONE = /^## ✅ Done(?::[ \t]*(.*?))?[ \t]*$/;
+var ENDED = /^## (?:(🛑) Removed|(⏸)\uFE0F? Deferred|⚠\uFE0F? Escalated) (\S+?)(?::[ \t]*(.*?))?[ \t]*$/;
+var WORKING_TASK = /^## ⏳ Working (\S+?)(?::[ \t]*(.*?))?[ \t]*$/;
+var PROPOSAL = /^### 📝 (.+?) \[#(\d+)\][ \t]*$/;
+var HEADING = /^#{1,3}[ \t]/;
+var REVIEW = /^## 🔍 Ready to merge (\S+) onto (\S+)[ \t]*$/;
+var REVIEW_END = 'Reply "merge", or say what to change.';
+var PROPOSED = /^## 💡 Proposed (.+?)[ \t]*$/;
+var CHECKS = /^Checks:[ \t]*(.*)$/;
+var FAILED = /^Failed:[ \t]*(.*)$/;
+var ITEM2 = /^(\d+)\.[ \t]+(.+)$/;
+var FENCE = /^[ \t]*(```|~~~)/;
+function keptAt(lines, start) {
+  const line = lines[start];
+  const merged = MERGED.exec(line);
+  const done = DONE.exec(line);
+  const ended = ENDED.exec(line);
+  const workingTask = WORKING_TASK.exec(line);
+  const proposed = PROPOSAL.exec(line);
+  const asking = asksPermission(line);
+  if (!asking && merged === null && done === null && ended === null && workingTask === null && proposed === null) {
+    return null;
+  }
+  const end = proposed !== null ? paragraphEnd(lines, start + 1, endAt(lines, start + 1)) : endAt(lines, start + 1);
+  const body = lines.slice(start + 1, end).join(`
+`).replace(/^\n+|\s+$/g, "");
+  if (asking) {
+    return {
+      stretch: {
+        type: "permission",
+        permission: permissionOf(line, body)
+      },
+      end
+    };
+  }
+  if (proposed !== null) {
+    return {
+      stretch: {
+        type: "todo",
+        todo: {
+          id: Number(proposed[2]),
+          subject: proposed[1],
+          body
+        }
+      },
+      end
+    };
+  }
+  const source = lines.slice(start, end).join(`
+`).replace(/\s+$/, "");
+  const report = merged !== null ? {
+    ending: "merged",
+    task: merged[1],
+    base: merged[2],
+    reason: null,
+    body,
+    source
+  } : done !== null ? {
+    ending: "done",
+    task: "",
+    base: null,
+    reason: done[1] || null,
+    body,
+    source
+  } : workingTask !== null ? {
+    ending: "working",
+    task: workingTask[1],
+    base: null,
+    reason: workingTask[2] || null,
+    body,
+    source
+  } : {
+    ending: ended?.[1] !== undefined ? "removed" : ended?.[2] !== undefined ? "deferred" : "escalated",
+    task: ended?.[3],
+    base: null,
+    reason: ended?.[4] || null,
+    body,
+    source
+  };
+  return { stretch: { type: "report", report }, end };
+}
+function reviewOf(lines) {
+  const { body, demo } = withDemo(lines);
+  let rest = body.split(`
+`);
+  const named = (line) => {
+    const at = rest.findIndex((said) => line.test(said));
+    if (at === -1) {
+      return [];
+    }
+    const found = Array.from(rest[at].matchAll(/`([^`]+)`/g), (code) => code[1]);
+    rest = rest.toSpliced(at, rest[at + 1]?.trim() === "" ? 2 : 1);
+    return found;
+  };
+  const checks = named(CHECKS);
+  const failed = named(FAILED);
+  const gap = rest.findIndex((line) => line.trim() === "");
+  return {
+    summary: trimmed2(gap === -1 ? rest : rest.slice(0, gap)),
+    demo,
+    checks,
+    failed,
+    details: gap === -1 ? "" : trimmed2(rest.slice(gap))
+  };
+}
+function withDemo(lines) {
+  const at = lines.findIndex((_, index) => demoHere(lines, index) !== null);
+  const found = at === -1 ? null : demoHere(lines, at);
+  if (found === null) {
+    return { body: trimmed2(lines), demo: null };
+  }
+  return {
+    body: trimmed2([...lines.slice(0, at), ...lines.slice(found.end)]),
+    demo: found.demo
+  };
+}
+function demoHere(lines, start) {
+  return isDemoTitle(lines[start]) ? demoAt(lines, start, endAt(lines, start + 1)) : null;
+}
+function trimmed2(lines) {
+  return lines.join(`
+`).replace(/^\n+|\s+$/g, "");
+}
+function paragraphEnd(lines, start, end) {
+  let begun = false;
+  let fenced = false;
+  for (let i = start;i < end; i += 1) {
+    const line = lines[i];
+    if (FENCE.test(line)) {
+      fenced = !fenced;
+    }
+    if (line.trim() !== "") {
+      begun = true;
+    } else if (begun && !fenced) {
+      return i;
+    }
+  }
+  return end;
+}
+function endAt(lines, start) {
+  let fenced = false;
+  for (let i = start;i < lines.length; i += 1) {
+    const line = lines[i];
+    if (FENCE.test(line)) {
+      fenced = !fenced;
+      continue;
+    }
+    if (!fenced && (HEADING.test(line) || ITEM2.exec(line)?.[1] === "1" && listAt(lines, i) !== null)) {
+      return i;
+    }
+  }
+  return lines.length;
+}
+function listAt(lines, start) {
+  const items = [];
+  let end = start;
+  for (let i = start;i < lines.length; i += 1) {
+    const line = lines[i];
+    const item = ITEM2.exec(line);
+    if (item !== null && item[1] === String(items.length + 1)) {
+      items.push({ asked: question2(item[1], item[2] ?? ""), body: [] });
+      end = i + 1;
+      continue;
+    }
+    if (line.trim() === "") {
+      continue;
+    }
+    if (!/^[ \t]/.test(line)) {
+      break;
+    }
+    const last = items.at(-1);
+    last.body.push(...lines.slice(end, i).map(() => ""));
+    if (!offers(last.asked, line)) {
+      last.body.push(line);
+    }
+    end = i + 1;
+  }
+  if (!items.every(asks)) {
+    return null;
+  }
+  return {
+    questions: items.map(({ asked, body }) => settled(asked, body)),
+    end
+  };
+}
+function asks({ asked, body }) {
+  if (ASKS.test(asked.text)) {
+    return true;
+  }
+  const then = ASKS_THEN.exec(asked.text);
+  if (then !== null) {
+    asked.text = then[1];
+    const indent = /^[ \t]*/.exec(body.find((line) => line.trim()) ?? "");
+    body.unshift(`${indent?.[0] ?? ""}${then[2]}`);
+    return true;
+  }
+  return asked.choices.length > 0;
+}
+function question2(number, line) {
+  return {
+    number,
+    done: false,
+    ...sized(line.trim()),
+    body: "",
+    reply: null,
+    followUps: [],
+    choices: [],
+    pick: null
+  };
+}
+function prose(lines) {
+  const text = lines.join(`
+`).replace(/^\n+|\s+$/g, "");
+  return text === "" ? [] : [{ type: "text", text }];
+}
+// plans/decided.ts
+function madeByYou2(outcome) {
+  return decided2(outcome).reduce((total, [, count]) => total + count, 0);
+}
+function decided2(outcome) {
+  if (outcome.decisions !== undefined) {
+    return outcome.decisions.filter((each) => each.how !== "assumed").map((each) => [each, 1]);
+  }
+  const picked = outcome.picksAsked ?? 0;
+  const overturned = outcome.picksOverturned ?? 0;
+  const amended = outcome.picksAmended ?? 0;
+  const unsized = (ended, count) => [
+    { size: null, ended },
+    Math.max(0, count)
+  ];
+  return [
+    unsized("kept", picked - overturned - amended),
+    unsized("amended", amended),
+    unsized("overturned", overturned),
+    unsized(null, (outcome.questionsAsked ?? 0) - picked)
+  ].filter(([, count]) => count > 0);
+}
+function keptDecisions2(outcome) {
+  return outcome.decisions !== undefined || outcome.questionsAsked !== undefined;
+}
+// plans/needs.ts
+import { Markdown as Markdown2 } from "../../core/md/index.js";
+import { Duration } from "../../core/time/index.js";
+function needs2({
+  tasks,
+  conversations,
+  todos,
+  now = Date.now()
+}) {
+  const live = tasks.filter(isLive);
+  const found = [
+    ...conversations.filter((each) => !each.archived).map((conversation) => {
+      const task = live.find((each) => each.task === conversation.task) ?? null;
+      return {
+        conversation,
+        task,
+        need: need2(task, conversation, now, todos)
+      };
+    }),
+    ...externals2(tasks, conversations, now)
+  ];
+  return answeredThrough2(found, conversations).sort((one, other) => KINDS.indexOf(one.need.kind) - KINDS.indexOf(other.need.kind) || pressing(one.need, other.need));
+}
+var KINDS = ["waiting", "assuming", "working", "idle"];
+function isLive(task) {
+  return ["working", "merging"].includes(task.status);
+}
+function externals2(tasks, conversations, now = Date.now()) {
+  const listed = conversations.filter((each) => !each.archived);
+  return tasks.filter((task) => isLive(task) && !task.dispatched && !listed.some((each) => each.task === task.task)).map((task) => ({
+    conversation: null,
+    task,
+    need: needOfExternal2(task, conversations, now)
+  }));
+}
+function needOfExternal2(task, conversations, now = Date.now()) {
+  const asked = need2(task, null, now);
+  const left = orphaned2(task, conversations);
+  if (left === null) {
+    return asked;
+  }
+  return {
+    kind: "waiting",
+    why: "orphaned",
+    subject: left.subject,
+    since: left.since,
+    questions: "questions" in asked ? asked.questions : []
+  };
+}
+function orphaned2(task, conversations) {
+  if (!isLive(task) || task.dispatched || task.lease === "held") {
+    return null;
+  }
+  const listed = conversations.filter((each) => !each.archived);
+  const on = listed.filter((each) => each.task === task.task);
+  if (on.length > 0) {
+    return on.every((each) => each.status === "failed") ? { subject: "Its agent failed", since: task.activeAt } : null;
+  }
+  if (answersTo2({ conversation: null, task }, conversations) !== null) {
+    return null;
+  }
+  if (task.takenBy === null) {
+    return {
+      subject: "No conversation here is on it",
+      since: task.activeAt
+    };
+  }
+  const by = conversations.find((each) => each.id === task.takenBy);
+  if (by === undefined) {
+    return { subject: "Its conversation is gone", since: task.activeAt };
+  }
+  return by.archived ? { subject: "Its conversation was archived", since: task.activeAt } : null;
+}
+var ASKED_QUIET2 = Duration.mins(3);
+function working(task) {
+  const subject = task?.plan ? doing(task.plan) : null;
+  const since = task?.mergeSince ? { mergeSince: task.mergeSince } : {};
+  if (task?.status === "merging" || task?.gate === "running") {
+    return { kind: "working", subject, merge: "running", ...since };
+  }
+  if (task?.gate !== "queued") {
+    return { kind: "working", subject };
+  }
+  const place = task.mergePlace === null ? {} : { mergePlace: task.mergePlace };
+  return { kind: "working", subject, merge: "queued", ...since, ...place };
+}
+function need2(task, conversation, now = Date.now(), todos) {
+  const open = task?.plan ? openQuestions2(task.plan) : [];
+  const waiting = (why, subject, since = null, questions = open) => ({ kind: "waiting", why, subject, since, questions });
+  const ask = conversation?.ask ?? null;
+  if (ask !== null) {
+    return waiting("ask", ask.type === "permission" ? ask.title : ask.message, ask.at);
+  }
+  if (conversation?.status === "failed") {
+    return waiting("failed", conversation.error ?? "Failed");
+  }
+  const [first] = open;
+  if (conversation === null) {
+    const at = task?.activeAt ?? null;
+    if (first !== undefined && at !== null && now - Date.parse(at) >= ASKED_QUIET2.ms) {
+      return waiting("questions", first.text, at);
+    }
+    return first !== undefined ? { kind: "assuming", subject: first.text, questions: open } : working(task);
+  }
+  const running = conversation.status === "running" || conversation.status === "starting";
+  if (running) {
+    return first !== undefined ? { kind: "assuming", subject: first.text, questions: open } : working(task);
+  }
+  if (task?.mergeSince != null) {
+    return working(task);
+  }
+  if (conversation.evaluating === true) {
+    return first !== undefined ? { kind: "assuming", subject: first.text, questions: open } : { ...working(task), evals: true };
+  }
+  const last = conversation.messages.at(-1);
+  const ended = last?.until ?? last?.at ?? null;
+  if (first !== undefined) {
+    return waiting("questions", first.text, ended);
+  }
+  const asked = askedIn(conversation);
+  const [lead] = asked;
+  if (lead !== undefined) {
+    return waiting("questions", lead.text, ended, asked);
+  }
+  const permission = permissionIn(conversation, todos);
+  if (permission !== null) {
+    return waiting("ask", permission, ended);
+  }
+  const review = reviewIn(conversation);
+  return review !== null ? waiting("review", review, ended) : { kind: "idle" };
+}
+function askedIn(conversation) {
+  return stretches2(lastWords(conversation) ?? "").flatMap((stretch) => stretch.type === "questions" ? stretch.questions : []);
+}
+function permissionIn(conversation, todos) {
+  for (const stretch of stretches2(lastWords(conversation) ?? "")) {
+    if (stretch.type !== "permission") {
+      continue;
+    }
+    const { permission } = stretch;
+    if (permission.action === "queue" && permission.project === undefined && todos !== undefined && queueIsSettled2(permission, todos)) {
+      continue;
+    }
+    return permission.title ?? "Permission";
+  }
+  return null;
+}
+function reviewIn(conversation) {
+  for (const stretch of stretches2(lastWords(conversation) ?? "")) {
+    if (stretch.type === "review") {
+      return stretch.review.summary || "Ready to merge";
+    }
+  }
+  return null;
+}
+function lastWords(conversation) {
+  const last = conversation.messages.at(-1);
+  if (last?.role !== "agent") {
+    return null;
+  }
+  return last.parts.flatMap((part) => part.type === "text" ? [part.text] : []).join(`
+
+`);
+}
+function answeredThrough2(found, conversations) {
+  const handedOut = (entry) => answersTo2(entry, conversations)?.id ?? null;
+  const relayed = (entry) => handedOut(entry) !== null && entry.need.kind === "waiting" && entry.need.why !== "failed";
+  const lifted = new Map;
+  for (const entry of found.filter(relayed).toSorted((one, other) => Number(other.need.kind === "waiting" && other.need.why === "ask") - Number(one.need.kind === "waiting" && one.need.why === "ask"))) {
+    const by = handedOut(entry);
+    const via = entry.task?.task ?? entry.conversation?.task ?? entry.conversation?.title;
+    if (!lifted.has(by) && entry.need.kind === "waiting") {
+      lifted.set(by, via == null ? entry.need : { ...entry.need, via });
+    }
+  }
+  return found.map((entry) => {
+    if (relayed(entry)) {
+      const running = entry.conversation?.status === "running" || entry.conversation?.status === "starting";
+      const plan = entry.task?.plan;
+      return {
+        ...entry,
+        need: running ? { kind: "working", subject: plan ? doing(plan) : null } : { kind: "idle" }
+      };
+    }
+    const wait = lifted.get(entry.conversation?.id ?? "");
+    const takes = wait?.kind === "waiting" && (wait.why === "ask" ? entry.need.kind !== "waiting" : entry.need.kind === "idle");
+    if (wait !== undefined && takes) {
+      return { ...entry, need: wait };
+    }
+    if (wait?.kind === "waiting" && wait.why !== "ask" && entry.need.kind === "working") {
+      const { subject, questions, via } = wait;
+      return {
+        ...entry,
+        need: {
+          kind: "assuming",
+          subject,
+          questions,
+          ...via === undefined ? {} : { via }
+        }
+      };
+    }
+    return entry;
+  });
+}
+function answersTo2({ conversation, task }, conversations) {
+  if (conversation !== null) {
+    return null;
+  }
+  const caller = task?.caller ?? null;
+  return caller === null ? null : conversations.find((each) => each.id === caller && !each.archived) ?? null;
+}
+function pressing(one, other) {
+  if (one.kind === "waiting" && other.kind === "waiting") {
+    const at = (need) => need.since === null ? Number.POSITIVE_INFINITY : Date.parse(need.since);
+    return at(one) - at(other) || 0;
+  }
+  if (one.kind === "assuming" && other.kind === "assuming") {
+    return other.questions.length - one.questions.length;
+  }
+  return 0;
+}
+var STEPS = /^[ \t]*- \[ \][ \t]+(.+)$/gm;
+function doing(plan) {
+  return nextStep(plan) ?? goalLine2(plan);
+}
+function nextStep(plan) {
+  const md = Markdown2.parse(plan);
+  if (!md.has("Next")) {
+    return null;
+  }
+  for (const [, step] of md.section("Next").body.matchAll(STEPS)) {
+    const trimmed = step?.trim();
+    if (trimmed !== undefined && !STUB_STEPS.includes(trimmed)) {
+      return trimmed;
+    }
+  }
+  return null;
+}
+var TASK2 = "task/";
+function openedBy2(row) {
+  return row.conversation?.id ?? `${TASK2}${row.task?.task ?? ""}`;
+}
+// plans/prompts.ts
+function taskNumberReference2(id) {
+  return `[SPLATES TASK #${id}]`;
+}
+var UNTRIAGED2 = "untriaged";
+function eventReference2(name, numbers, task) {
+  const about = [
+    ...numbers.map((id) => `#${id}`),
+    ...task === null ? [] : [task]
+  ];
+  return `[SPLATES EVENT ${[name, ...about].join(" ")}]`;
+}
+function scheduleReference2(automation) {
+  return `[SPLATES SCHEDULE ${automation}]`;
+}
+function groomReference2(id) {
+  return `[SPLATES GROOM #${id}]`;
+}
+function sortReference2(ids) {
+  return `[SPLATES SORT ${ids.map((id) => `#${id}`).join(" ")}]`;
+}
+function taskReference2(task) {
+  return `[SPLATES TASK ${task}]`;
+}
+function handOffReference2(task, transcript) {
+  return `${taskReference2(task)}
+
+The agent before you on this task stopped without handing it over, so its SPLATES.md may be behind. What it said and did last is in ${transcript}: read its end before going on.`;
+}
+function continuedReference2(transcript) {
+  return `This conversation continues one the person started in General, outside any project. What was said there is in ${transcript}: read it, then carry on with that work here, starting a task before changing code.`;
+}
+function setupReference2(step) {
+  return `[SPLATES SETUP ${step}]`;
+}
+function isUpdate2(text) {
+  return /^\[SPLATES (?:(?:REPORT|IDLE) [^\]]+|TASK (?:DONE|OPEN|ADDED) #\d+|GROOM #\d+|SORT(?: #\d+)+|LANES DONE)\]$/.test(directive2(text));
+}
+function evalsDoneReference2(batch) {
+  return `[SPLATES EVALS DONE ${batch}]`;
+}
+var CHECKPOINT2 = "[SPLATES CHECKPOINT]";
+var RESUME2 = "[SPLATES RESUME]";
+var RECONNECT2 = "[SPLATES RECONNECT]";
+var MERGE2 = "[SPLATES MERGE]";
+var RUN_ALLOWED2 = "[SPLATES RUN ALLOWED]";
+var RUN_DENIED2 = "[SPLATES RUN DENIED]";
+var RETRIED2 = "[SPLATES RETRIED]";
+var GRANTED2 = "[SPLATES GRANTED]";
+var GRANT_DENIED2 = "[SPLATES GRANT DENIED]";
+var APPROVE2 = "[SPLATES APPROVE]";
+var DEFER2 = "[SPLATES DEFER]";
+var DICTATED2 = "(Dictated by voice: words that sound alike may be swapped, and names in this project misspelled. Read a near miss as the closest name in the project, and ask before acting on a reading that changes what you do.)";
+var DIRECTIVES2 = /\[(?:SPLATES|ARBOR) [A-Z]+(?: [^\]\s]+)*\]/g;
+var LEADING = /^\s*(\[(?:SPLATES|ARBOR) [A-Z]+(?: [^\]\s]+)*\])(?:\s+|$)/;
+function leadingDirectives2(text) {
+  const directives = [];
+  let rest = text;
+  for (let found = LEADING.exec(rest);found !== null; found = LEADING.exec(rest)) {
+    directives.push(directive2(found[1]));
+    rest = rest.slice(found[0].length);
+  }
+  return { directives, rest };
+}
+var LEGACY_DIRECTIVE = "[ARBOR ";
+var LEGACY_TODO = /^\[SPLATES TODO (?=(?:(?:DONE|OPEN|ADDED) )?#\d+\]$)/;
+function directive2(text) {
+  const trimmed = text.trim();
+  const splates = trimmed.startsWith(LEGACY_DIRECTIVE) ? `[SPLATES ${trimmed.slice(LEGACY_DIRECTIVE.length)}` : trimmed;
+  return splates.replace(LEGACY_TODO, "[SPLATES TASK ");
+}
+// plans/reply.ts
+var QUOTED = /^> \*\*(.+)\*\*[ \t]*$/;
+var ANYTHING_ELSE = "Anything else?";
+var PICKED = /^(?:-|\d+\.)[ \t]+\(([a-z])\)(?=[ \t]|$)/;
+function replyOf2(questions, answers, more) {
+  const parts = [];
+  questions.forEach((asked, at) => {
+    const answer = answers[at] ?? null;
+    if (answer === null || isEmpty2(answer)) {
+      return;
+    }
+    const picks = answer.picks.map((key, index) => {
+      const choice = asked.choices.find((each) => each.key === key);
+      const mark = asked.pick === "order" ? `${index + 1}.` : "-";
+      return `${mark} (${key}) ${choice?.text ?? ""}`.trimEnd();
+    });
+    parts.push([
+      `> **${asked.text}**`,
+      picks.join(`
+`),
+      escaped(answer.words.trim(), asked.choices)
+    ].filter((part) => part !== "").join(`
+
+`));
+  });
+  if (more.trim() !== "") {
+    const words = escaped(more.trim(), []);
+    parts.push(parts.length === 0 ? words : `> **${ANYTHING_ELSE}**
+
+${words}`);
+  }
+  return parts.join(`
+
+`);
+}
+function isEmpty2(answer) {
+  return answer.picks.length === 0 && answer.words.trim() === "";
+}
+function takenOf2(asked) {
+  return {
+    picks: asked.choices.filter((choice) => choice.chosen).map((choice) => choice.key),
+    words: ""
+  };
+}
+function changes2(asked, answer) {
+  const taken = takenOf2(asked).picks;
+  return !isEmpty2(answer) && (answer.words.trim() !== "" || answer.picks.length !== taken.length || answer.picks.some((key) => !taken.includes(key)));
+}
+function quotedIn2(text, asked) {
+  const lines = text.split(`
+`);
+  const at = lines.findIndex((line) => {
+    const quoted = QUOTED.exec(line);
+    return quoted !== null && sameLine(quoted[1], asked.text);
+  });
+  if (at === -1) {
+    return null;
+  }
+  const next = lines.findIndex((line, index) => index > at && QUOTED.test(line));
+  const rest = lines.slice(at + 1, next === -1 ? lines.length : next);
+  let from = rest.findIndex((line) => line.trim() !== "");
+  from = from === -1 ? rest.length : from;
+  const picks = [];
+  for (;from < rest.length; from += 1) {
+    const key = picked(rest[from], asked.choices);
+    if (key === null) {
+      break;
+    }
+    picks.push(key);
+  }
+  return {
+    picks,
+    words: rest.slice(from).map(unescaped).join(`
+`).trim()
+  };
+}
+function answerIn2(text, asked) {
+  const quoted = quotedIn2(text, asked);
+  if (quoted !== null) {
+    return quoted;
+  }
+  for (const line of text.split(`
+`)) {
+    const found = replyLine(asked).exec(line);
+    if (found !== null) {
+      const [picks, rest] = asked.choices.length === 0 ? [undefined, found[1]] : [found[1], found[2]];
+      return {
+        picks: (picks ?? "").split(/[ \t]*,[ \t]*/).filter(Boolean),
+        words: (rest ?? "").replace(picks ? /^:?[ \t]?/ : /^[ \t]/, "").trim()
+      };
+    }
+  }
+  return null;
+}
+function besides2(text, asked) {
+  const lines = text.split(`
+`);
+  const last = lines.findLastIndex((line) => {
+    const quoted = QUOTED.exec(line);
+    return quoted !== null && sameLine(quoted[1], ANYTHING_ELSE);
+  });
+  const quoted = lines.findIndex((line) => QUOTED.test(line));
+  return (last !== -1 ? lines.slice(last + 1) : quoted === -1 ? lines : lines.slice(0, quoted)).filter((line) => !asked.some((each) => replyLine(each).test(line))).map(unescaped).join(`
+`).trim();
+}
+function escaped(words, choices) {
+  return words.split(`
+`).map((line, at) => QUOTED.test(line) || at === 0 && picked(line, choices) !== null ? `\\${line}` : line).join(`
+`);
+}
+function unescaped(line) {
+  const rest = line.slice(1);
+  return line.startsWith("\\") && (QUOTED.test(rest) || PICKED.test(rest)) ? rest : line;
+}
+function picked(line, choices) {
+  const key = PICKED.exec(line)?.[1];
+  return choices.some((choice) => choice.key === key) ? key ?? null : null;
+}
+function sameLine(one, other) {
+  const plain = (text) => text.replace(/\s+/g, " ").trim().toLowerCase();
+  return plain(one) === plain(other);
+}
+function replyLine({ number, choices }) {
+  const keys = choices.map((choice) => choice.key).join("");
+  const picks = keys === "" ? "" : `(?:[ \\t]+([${keys}](?:[ \\t]*,[ \\t]*[${keys}])*)(?![a-z]))?`;
+  return new RegExp(`^${number}\\.${picks}(.*)$`);
+}
+// plans/store.ts
+class PlanStore2 {
+  fs;
+  plans;
+  kept;
+  constructor(fs, storage) {
+    this.fs = fs;
+    this.plans = new Plans2(fs);
+    this.kept = storage.collection("plans");
+  }
+  async save(task, tree) {
+    const plan = await this.plans.read(tree);
+    if (plan === null) {
+      return;
+    }
+    await this.kept.write(this.at(task), plan);
+  }
+  async drop(task) {
+    await this.kept.remove(this.at(task));
+  }
+  async restore(task, tree) {
+    if (await this.plans.read(tree) !== null) {
+      return false;
+    }
+    const kept = await this.kept.read(this.at(task)).catch(() => null);
+    if (kept === null) {
+      return false;
+    }
+    await this.fs.write(`${tree}/${PLAN_FILE2}`, kept);
+    return true;
+  }
+  at(task) {
+    return `${task}.md`;
+  }
+}
+// plans/unanswered.ts
+function unanswered2(open, messages) {
+  const done = new Set;
+  messages.forEach((message, at) => {
+    if (message.role !== "user") {
+      return;
+    }
+    const text = textOf(message);
+    const before = messages[at - 1];
+    for (const asked of open) {
+      if (quotedIn2(text, asked) !== null) {
+        done.add(asked);
+      }
+    }
+    if (before?.role === "agent") {
+      for (const card of asks2(before)) {
+        const same = open.find((asked) => alike(asked, card));
+        if (same !== undefined && answerIn2(text, card) !== null) {
+          done.add(same);
+        }
+      }
+    }
+  });
+  return open.filter((asked) => !done.has(asked));
+}
+function asks2(message) {
+  const said = message.parts.findLast((part) => part.type === "text" && part.text.trim() !== "");
+  if (said?.type !== "text") {
+    return [];
+  }
+  return stretches2(said.text).flatMap((stretch) => stretch.type === "questions" ? stretch.questions : []);
+}
+function textOf(message) {
+  return message.parts.map((part) => part.type === "text" ? part.text : "").join("").trim();
+}
+function alike(one, other) {
+  const plain = (text) => text.replace(/\s+/g, " ").trim().toLowerCase();
+  return plain(one.text) === plain(other.text);
+}
+function waitsOnYou2({ conversation, need }) {
+  if (conversation === null) {
+    return false;
+  }
+  if (need.kind === "waiting" && need.why !== "questions") {
+    return true;
+  }
+  if (need.kind === "idle" || need.kind === "working" || need.kind === "assuming") {
+    return false;
+  }
+  return unanswered2(need.questions, conversation.messages).length > 0;
+}
+export { queueIsSettled2, PLAN_FILE2, Plans2, goalLine2, sectionApart2, outcomeOf2, goalOf2, questions2, openQuestions2, picks2, decisions2, unfinished2, ready2, whatIsLeft2, checkPlan2, stretches2, madeByYou2, decided2, keptDecisions2, needs2, externals2, needOfExternal2, orphaned2, ASKED_QUIET2, need2, answeredThrough2, answersTo2, TASK2, openedBy2, taskNumberReference2, UNTRIAGED2, eventReference2, scheduleReference2, groomReference2, sortReference2, taskReference2, handOffReference2, continuedReference2, setupReference2, isUpdate2, evalsDoneReference2, CHECKPOINT2, RESUME2, RECONNECT2, MERGE2, RUN_ALLOWED2, RUN_DENIED2, RETRIED2, GRANTED2, GRANT_DENIED2, APPROVE2, DEFER2, DICTATED2, DIRECTIVES2, leadingDirectives2, directive2, replyOf2, isEmpty2, takenOf2, changes2, quotedIn2, answerIn2, besides2, PlanStore2, unanswered2, waitsOnYou2 };