strom-research 1.7.0 → 1.9.0

package/dist/core/edge.js

@@ -0,0 +1,296 @@
+// The edge of the tree: the people above whom it does not go on — no parents, one of them, or parents no record
+// proves — and what the research knows there. Why it ends (what the records say so far: the known books of the
+// birth, the years searched in vain, the records that begin later or are lost), what comes next (the work on it and
+// where it stands in the queue, or that the user decides), and the hypotheses that would join a family nothing
+// links to the tree yet. Read only, computed from the research: what the Strom app shows on the card where the
+// tree ends (_STROM_EDGE, _STROM_ISLAND) and what `strom edge` says.
+import { now } from "./tree.js";
+import { Settings } from "./config.js";
+import { aboutPeople, directionOf, scopes } from "./directions.js";
+import { birthEstimate, birthRecordProven, birthWindow, frontier, FRONTIER_LEVELS, RECORD_KINDS, recordsetsCovering } from "./frontier.js";
+import { kinship, offTree } from "./kin.js";
+import { familiesAsChild, familiesAsPartner, parentsOf, primaryName } from "./people.js";
+import { livingBorn } from "./review.js";
+import { effectiveState, rankTasks } from "./queue.js";
+import { subjectPeople } from "./records.js";
+import { foldText } from "./text.js";
+/** What is missing above the person: both parents, one of them, or a record that proves the parents recorded. */
+export const EDGE_MISSING = ["parents", "father", "mother", "proof"];
+/**
+ * Whether the research reaches them: a direction of it does (in), would but stops at its limit (limit), is paused
+ * or ended (paused, done); none does — they are most likely alive (living), family of the tree no direction goes
+ * through (outside), or a family nothing links to the tree yet (off-tree).
+ */
+export const EDGE_SCOPES = ["in", "limit", "paused", "done", "living", "outside", "off-tree"];
+/**
+ * What the records say so far, from the most final: the baptism names no father (born out of wedlock); every year of the
+ * birth is searched in vain or has no records — lost, before the known records begin, a gap in them; searched in
+ * vain everywhere strom knew to look; the books left are only in the archive; searched in part; not searched yet;
+ * no book of the birthplace known; the birthplace unknown; nothing to go on (no year, no place).
+ */
+export const EDGE_ENDS = ["unnamed", "lost", "before-records", "gap", "not-found", "offline", "partly", "unsearched", "no-books", "no-place", "no-clue"];
+/**
+ * What comes next: an agent works on it now, it waits for the user, it is in the queue, it waits out of the queue
+ * (a direction paused, people off the tree, put aside), strom proposes it with the next session, everything strom
+ * could propose was tried (the user decides), nothing.
+ */
+export const EDGE_NEXT = ["working", "waiting", "queued", "held", "proposed", "decide", "none"];
+const BIRTH_KINDS = RECORD_KINDS.BIRT;
+const LIVE = new Set(["open", "doing", "waiting", "parked"]);
+const FINISHED = new Set(["done", "dropped"]);
+const EDGE_FACTS = new Set(["BIRT", "CHR", "BAPM", "FAMC"]);
+function yearsOf(text) {
+    const m = /^\s*(\d{3,4})(?:\s*[-–]\s*(\d{3,4}))?\s*$/.exec(text ?? "");
+    if (!m)
+        return undefined;
+    const a = Number(m[1]);
+    const b = m[2] ? Number(m[2]) : a;
+    return { from: Math.min(a, b), to: Math.max(a, b) };
+}
+/** Single years as ranges ([1780, 1781, 1782, 1790] → 1780–1782, 1790). */
+function ranges(years) {
+    const out = [];
+    for (const y of [...years].sort((a, b) => a - b)) {
+        const last = out[out.length - 1];
+        if (last && y === last.to + 1)
+            last.to = y;
+        else
+            out.push({ from: y, to: y });
+    }
+    return out;
+}
+const within = (y, r) => !r || (y >= r.from && y <= r.to);
+/** The families nothing links to the tree, person by person (none when the tree has nobody it is for). */
+function islands(tree, kin, tasks, hypotheses) {
+    const out = new Map();
+    if (!kin.size)
+        return out;
+    const off = offTree(tree);
+    for (const p of tree.list("person")) {
+        if (p.retracted || kin.has(p.id) || out.has(p.id))
+            continue;
+        const people = new Set();
+        const queue = [p.id];
+        while (queue.length) {
+            const id = queue.shift();
+            if (people.has(id) || kin.has(id))
+                continue;
+            people.add(id);
+            queue.push(...familiesAsPartner(tree, id).flatMap((f) => [...f.partners, ...f.children.map((c) => c.person)]), ...familiesAsChild(tree, id).flatMap((f) => f.partners));
+        }
+        const island = {
+            people: [...people],
+            hypotheses: hypotheses
+                .map((h) => ({ h, about: aboutPeople(tree, h.subject) }))
+                .filter(({ about }) => about.some((x) => people.has(x)) && about.some((x) => kin.has(x)))
+                .map(({ h, about }) => ({ id: h.id, joins: about.filter((x) => kin.has(x)) })),
+            held: tasks.filter((t) => LIVE.has(t.state) && off(t) && aboutPeople(tree, t.subject).some((x) => people.has(x))).length,
+        };
+        for (const id of people)
+            out.set(id, island);
+    }
+    return out;
+}
+/** Every edge of the tree with something the research knows of it, and the families nothing links to the tree. */
+export function treeEdges(tree) {
+    const lang = tree.lang;
+    const today = now().slice(0, 10);
+    const kin = kinship(tree);
+    const all = scopes(tree).filter((s) => !s.research.retracted);
+    const tasks = tree.list("task").filter((t) => !t.retracted);
+    const hypotheses = tree.list("hypothesis").filter((h) => !h.retracted && h.state === "open");
+    const conflicts = tree.list("conflict").filter((c) => !c.retracted && c.state === "open");
+    const searches = tree.list("search").filter((q) => !q.retracted);
+    const sessions = tree.list("session");
+    const researches = new Map(tree.list("research").map((r) => [r.id, r]));
+    const ranked = rankTasks(tree, tasks, new Settings(tree.env, {}).strategy(tree.config)).map((r) => r.task.id);
+    const position = new Map(ranked.map((id, i) => [id, i + 1]));
+    const off = offTree(tree);
+    const isles = islands(tree, kin, tasks, hypotheses);
+    const frontiers = new Map();
+    const frontierOf = (r) => {
+        if (!frontiers.has(r.id))
+            frontiers.set(r.id, new Map(frontier(tree, r).map((i) => [i.person.id, i])));
+        return frontiers.get(r.id);
+    };
+    const hypAbout = hypotheses.map((h) => ({ h, about: aboutPeople(tree, h.subject) }));
+    const edges = new Map();
+    for (const p of tree.list("person")) {
+        if (p.retracted)
+            continue;
+        const parents = parentsOf(tree, p.id);
+        const proven = birthRecordProven(p);
+        let missing;
+        if (parents.length === 0)
+            missing = "parents";
+        else if (parents.length === 1)
+            missing = parents[0].sex === "F" ? "father" : parents[0].sex === "M" ? "mother" : "parents";
+        else if (!proven)
+            missing = "proof";
+        else
+            continue;
+        // ── whether the research reaches them ──
+        const est = birthEstimate(tree, p, lang);
+        const window = birthWindow(est);
+        const reach = all.filter((s) => (s.people.get(p.id) ?? 0) >= 1).sort((a, b) => a.people.size - b.people.size || a.research.id.localeCompare(b.research.id));
+        const limited = (s) => {
+            const l = s.research.limits;
+            return !!((l?.generations && s.people.get(p.id) >= l.generations) || (l?.before && est.year && est.year < l.before));
+        };
+        const active = reach.filter((s) => s.research.state === "active");
+        const through = active.find((s) => !limited(s)) ?? active[0] ?? reach.find((s) => s.research.state === "paused") ?? reach[0];
+        const scope = active.some((s) => !limited(s))
+            ? "in"
+            : active.length
+                ? "limit"
+                : through
+                    ? through.research.state
+                    : livingBorn(tree, p) !== undefined
+                        ? "living"
+                        : kin.size && !kin.has(p.id)
+                            ? "off-tree"
+                            : "outside";
+        // ── the books of the birth, and the work on the parents ──
+        const placeBooks = est.place ? recordsetsCovering(tree, est.place, undefined, BIRTH_KINDS).filter((b) => !b.retracted) : [];
+        const books = placeBooks.filter((b) => !window || !b.years || (() => {
+            const y = yearsOf(b.years);
+            return !y || (y.from <= window.to && y.to >= window.from);
+        })());
+        const bookIds = new Set(books.map((b) => b.id));
+        const hyps = hypAbout.filter(({ about }) => about.includes(p.id)).map(({ h, about }) => ({ h, about }));
+        const hypIds = new Set(hyps.map(({ h }) => h.id));
+        const onParents = (t) => (t.subject.includes(p.id) && (FRONTIER_LEVELS.has(t.level) || ((t.level === "verify" || t.level === "enrich") && t.where.some((w) => bookIds.has(w))))) ||
+            t.subject.some((s) => hypIds.has(s));
+        const mine = tasks.filter(onParents);
+        const mineIds = new Set(mine.map((t) => t.id));
+        const surname = foldText(primaryName(p).surname);
+        const sought = searches.filter((q) => (q.task ? mineIds.has(q.task) : !!surname && (q.scope.surnames ?? []).some((s) => foldText(s) === surname) && q.recordsets.some((b) => bookIds.has(b))));
+        const edgeTasks = mine
+            .filter((t) => LIVE.has(effectiveState(t, today)))
+            .map((t) => {
+            const state = effectiveState(t, today);
+            const at = position.get(t.id);
+            const dir = directionOf(tree, t, all);
+            const dirState = dir ? researches.get(dir)?.state : undefined;
+            const held = state === "parked" ? "parked" : state !== "open" || at ? undefined : dirState === "paused" || dirState === "done" ? dirState : off(t) ? "off-tree" : undefined;
+            const on = state === "waiting" ? t.waitingOn : state === "parked" ? t.parkedReason : undefined;
+            return {
+                id: t.id,
+                level: t.level,
+                state,
+                what: t.what,
+                ...(at && state === "open" ? { position: at } : {}),
+                ...(held ? { held } : {}),
+                ...(state === "parked" && t.parkedUntil ? { until: t.parkedUntil } : {}),
+                ...(on ? { on } : {}),
+            };
+        })
+            .sort((a, b) => (a.position ?? 1e9) - (b.position ?? 1e9) || a.id.localeCompare(b.id));
+        const tried = mine.filter((t) => FINISHED.has(t.state)).map((t) => t.id);
+        const item = through && through.research.state === "active" ? frontierOf(through.research).get(p.id) : undefined;
+        const next = edgeTasks.some((t) => t.state === "doing")
+            ? "working"
+            : edgeTasks.some((t) => t.state === "waiting")
+                ? "waiting"
+                : edgeTasks.some((t) => t.position)
+                    ? "queued"
+                    : edgeTasks.length
+                        ? "held"
+                        : scope === "in" && item?.proposal
+                            ? "proposed"
+                            : tried.length || item?.exhausted
+                                ? "decide"
+                                : "none";
+        // ── what the records say so far: each year of the window searched in vain, without records, or open ──
+        const covered = [];
+        const noRecords = [];
+        const lostYears = [];
+        const open = [];
+        if (window && placeBooks.length)
+            for (let y = window.from; y <= window.to; y++) {
+                const of = books.filter((b) => within(y, yearsOf(b.years)));
+                const kept = of.filter((b) => b.access !== "lost");
+                if (!of.length)
+                    noRecords.push(y);
+                else if (!kept.length)
+                    lostYears.push(y);
+                else if (kept.every((b) => sought.some((q) => q.result === "negative" && q.recordsets.includes(b.id) && within(y, yearsOf(q.scope.years) ?? (q.scope.pages ? { from: 0, to: -1 } : yearsOf(b.years))))))
+                    covered.push(y);
+                else
+                    open.push({ year: y, online: kept.some((b) => b.access === "online-free" || b.access === "online-login") });
+            }
+        const earliest = Math.min(...placeBooks.map((b) => yearsOf(b.years)?.from ?? Infinity));
+        let end;
+        // the baptism is read and names the mother alone (a child born out of wedlock); a mother missing is one not recorded yet
+        if (missing === "father" && proven)
+            end = "unnamed";
+        else if (!est.place)
+            end = est.year ? "no-place" : "no-clue";
+        else if (!placeBooks.length)
+            end = "no-books";
+        else if (window && !open.length)
+            end = lostYears.length
+                ? "lost"
+                : noRecords.length === window.to - window.from + 1 && earliest > window.to
+                    ? "before-records"
+                    : noRecords.length
+                        ? noRecords.every((y) => y < earliest)
+                            ? "before-records"
+                            : "gap"
+                        : "not-found";
+        else if (item?.exhausted)
+            end = "not-found";
+        else if (window && open.every((o) => !o.online))
+            end = "offline";
+        else
+            end = sought.length || tried.length ? "partly" : "unsearched";
+        // ── the hypotheses, conflicts, and what the work cost ──
+        // a hypothesis that names people on and off the tree would join them: the people on the other side of it
+        const onTree = kin.has(p.id);
+        const edgeHyps = hyps.map(({ h, about }) => {
+            const joining = kin.size > 0 && about.some((x) => kin.has(x)) && about.some((x) => !kin.has(x));
+            const joins = joining ? about.filter((x) => kin.has(x) !== onTree) : [];
+            const isle = joins.length && onTree ? isles.get(joins[0]) : undefined;
+            return {
+                id: h.id,
+                question: h.question,
+                joins,
+                ...(isle ? { island: { people: isle.people.length, held: isle.held } } : {}),
+                tests: tasks.filter((t) => LIVE.has(t.state) && t.subject.includes(h.id)).map((t) => t.id),
+            };
+        });
+        const edgeConflicts = conflicts
+            .filter((c) => subjectPeople(tree, c.subject).includes(p.id) && (!c.fact || EDGE_FACTS.has(c.fact)))
+            .map((c) => c.id);
+        const spent = sessions.filter((s) => s.task && mineIds.has(s.task));
+        const cost = spent.reduce((n, s) => n + (s.metrics?.costUsd ?? 0), 0);
+        const partial = spent.some((s) => s.state !== "open" && (s.metrics?.costPartial || s.metrics?.costUsd === undefined));
+        const last = [...spent.map((s) => s.ended ?? s.started), ...sought.map((q) => q.created)].sort().pop()?.slice(0, 10);
+        const known = scope === "in" || scope === "limit" || scope === "paused" || scope === "done" || edgeTasks.length || tried.length || edgeHyps.length || sought.length || edgeConflicts.length;
+        if (!known)
+            continue;
+        edges.set(p.id, {
+            person: p.id,
+            missing,
+            scope,
+            ...(through ? { research: through.research.id, generation: through.people.get(p.id) } : {}),
+            end,
+            next,
+            ...(est.year || est.place ? { estimate: { ...(est.year ? { year: est.year } : {}), ...(est.place ? { place: est.place } : {}), ...(est.basis ? { basis: est.basis } : {}) } } : {}),
+            ...(window ? { window } : {}),
+            ...(Number.isFinite(earliest) && (end === "before-records" || noRecords.some((y) => y < earliest)) ? { recordsFrom: earliest } : {}),
+            books: books.map((b) => ({ id: b.id, title: b.title, ...(b.years ? { years: b.years } : {}), access: b.access })),
+            covered: ranges(covered),
+            noRecords: ranges(noRecords),
+            tasks: edgeTasks,
+            tried,
+            hypotheses: edgeHyps,
+            conflicts: edgeConflicts,
+            searches: sought.length,
+            sessions: spent.length,
+            ...(spent.length ? { cost: Math.round(cost * 100) / 100, ...(partial ? { costPartial: true } : {}) } : {}),
+            ...(last ? { last } : {}),
+        });
+    }
+    return { edges, islands: isles };
+}

package/dist/core/frontier.js

@@ -7,8 +7,8 @@ import { foldText } from "./text.js";
 import { phrase } from "./phrases.js";
 const OPEN_STATES = new Set(["open", "doing", "parked", "waiting"]);
 const FINISHED_STATES = new Set(["done", "dropped"]);
-const FRONTIER_LEVELS = new Set(["locate", "link", "request"]);
-function birthRecordProven(p) {
+export const FRONTIER_LEVELS = new Set(["locate", "link", "request"]);
+export function birthRecordProven(p) {
     return p.events.some((e) => ["BIRT", "CHR", "BAPM"].includes(e.kind) && (e.status === "proven" || e.status === "probable") && !e.retracted);
 }
 /** The kinds of record set in which an event of this kind is written down. */
@@ -120,7 +120,15 @@ export function birthEstimate(tree, p, lang) {
     const year = ownYear ?? (marrYear ? marrYear - 25 : eldest ? eldest.year - 28 : undefined);
     const place = own?.place ?? marr?.place ?? eldest?.b?.place;
     const from = ownYear ? undefined : marrYear ? phrase(lang, "estimate.marriage", { year: marrYear }) : eldest ? phrase(lang, "estimate.child", { year: eldest.year }) : undefined;
-    return { ...(year ? { year } : {}), ...(place ? { place } : {}), ...(from ? { from } : {}) };
+    const basis = ownYear || !year ? undefined : marrYear ? { kind: "MARR", year: marrYear } : { kind: "child", year: eldest.year };
+    return { ...(year ? { year } : {}), ...(place ? { place } : {}), ...(from ? { from } : {}), ...(basis ? { basis } : {}) };
+}
+/** The years a search for a birth has to cover: a few around a known year, wider around an estimate. */
+export function birthWindow(est) {
+    if (!est.year)
+        return undefined;
+    const span = est.from ? 10 : 3;
+    return { from: est.year - span, to: est.year + span };
 }
 /**
  * The people a research is about, each with their generation from its focus:
@@ -202,7 +210,7 @@ export function frontier(tree, research) {
             const tried = new Set(finished.filter((t) => t.level === "link").flatMap((t) => t.where));
             const place = est.place;
             // an estimate needs a wider search than a known year
-            const span = est.from ? 10 : 3;
+            const span = est.from ? 10 : 3; // as birthWindow
             const about = est.from && year ? phrase(lang, "born.about", { year, from: est.from }) : "";
             const reason = phrase(lang, hasBirthFamily ? "reason.unproven" : "reason.unknown");
             const sets = candidateRecordsets(tree, place, year).filter((b) => !tried.has(b.id));

package/dist/core/kin.js

@@ -2,6 +2,7 @@
 // app opens on them), and how near anyone is to the people the research is
 // for (which entries get their image in the Strom app first).
 import { Settings } from "./config.js";
+import { aboutPeople } from "./directions.js";
 import { ancestorGenerations, familiesAsChild, familiesAsPartner } from "./people.js";
 function researches(tree) {
     return tree
@@ -57,7 +58,7 @@ export function mainPerson(tree) {
  * their ancestors 0, the partners, children and children's partners of those 1, anyone linked by family further 2.
  */
 export function kinship(tree) {
-    const roots = [...new Set([...researches(tree).map((r) => r.focus), mainPerson(tree)].filter((x) => !!x))];
+    const roots = [...new Set([...researches(tree).flatMap((r) => [r.focus, ...(r.review?.people ?? [])]), mainPerson(tree)].filter((x) => !!x))];
     const out = new Map();
     for (const r of roots)
         for (const id of ancestorGenerations(tree, r).keys())
@@ -88,3 +89,41 @@ export function kinship(tree) {
     }
     return out;
 }
+/**
+ * Work about people nothing links to the tree yet: none of the people a task is about (with those of the conflicts
+ * and hypotheses it names) is kin of the people the research is for. It waits out of the queue until the user asks
+ * for it (a direction or a review of one of them makes them the research's) or a hypothesis that joins them to the
+ * tree is decided and recorded. A task that tests that hypothesis names it (--about H…) or the person of the tree
+ * it would join, and so is in the queue. The user's material (intake) and work at hand never wait; a tree with
+ * nobody to be for holds nothing.
+ */
+export function offTree(tree) {
+    const kin = kinship(tree);
+    if (!kin.size)
+        return () => false;
+    return (t) => {
+        if (t.level === "intake" || t.state === "doing")
+            return false;
+        const about = aboutPeople(tree, t.subject);
+        return about.length > 0 && !about.some((p) => kin.has(p));
+    };
+}
+/**
+ * The open hypotheses that would join people off the tree to it: each names someone of the tree and someone of
+ * their family (the people family links join to them) — the work to do before any work on them.
+ */
+export function joiningHypotheses(tree, people) {
+    const kin = kinship(tree);
+    const family = new Set();
+    const queue = people.filter((p) => !kin.has(p));
+    while (queue.length) {
+        const p = queue.shift();
+        if (family.has(p))
+            continue;
+        family.add(p);
+        queue.push(...familiesAsPartner(tree, p).flatMap((f) => [...f.partners, ...f.children.map((c) => c.person)]), ...familiesAsChild(tree, p).flatMap((f) => f.partners));
+    }
+    return tree
+        .list("hypothesis")
+        .filter((h) => h.state === "open" && h.subject.some((s) => family.has(s)) && h.subject.some((s) => kin.has(s)));
+}

package/dist/core/links.js

@@ -29,15 +29,19 @@ export const LINK_SCHEME = "strom-research";
  * as it is now into the app's window, open the research's menu, a conversation with the agent (of one person),
  * a task (answered, put aside, given up, back in the queue), a person's review, a new direction from a person —
  * and (the app's second wave) a new research with a tree of the app, strom's update, the agent's sessions and
- * what they cost, a conflict decided (by the user or the agent), a story approved, a sync taken back, the setup.
+ * what they cost, a conflict decided (by the user or the agent), a story approved, a sync taken back, the setup —
+ * and (the app's 3.5.0) the research followed live in the app's window; a direction of the research paused, ended or
+ * taken up again, a conversation about one direction, a session at work asked to finish.
  */
-export const LINK_ACTIONS = ["send", "excerpt", "app", "open", "chat", "task", "review", "research", "new", "update", "sessions", "conflict", "story", "sync-undo", "setup"];
+export const LINK_ACTIONS = ["send", "excerpt", "app", "open", "chat", "task", "review", "research", "new", "update", "sessions", "conflict", "story", "sync-undo", "setup", "live", "direction", "finish"];
 /** A person's review: the person, with the family, with the ancestors (strom review --scope). */
 export const LINK_SCOPES = ["person", "family", "line"];
 /** A new direction from a person (strom research new --direction). */
 export const LINK_DIRECTIONS = ["ancestors", "descendants"];
 /** What a link does with a task: put it aside, give it up, back into the queue (none: answer it). */
 export const LINK_TASK_DOS = ["park", "drop", "wake"];
+/** What a link does with a direction of the research (strom research pause|done|resume). */
+export const LINK_DIRECTION_DOS = ["pause", "done", "resume"];
 /** What a link does with a conflict: the user decides it, or leaves it to the agent. */
 export const LINK_CONFLICT_DOS = ["decide", "agent"];
 const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
@@ -46,6 +50,8 @@ const PERSON = /^P\d{1,9}$/;
 const TASK = /^T\d{1,9}$/;
 const CONFLICT = /^X\d{1,9}$/;
 const INPUT = /^I\d{1,9}$/;
+const RESEARCH = /^G\d{1,9}$/;
+const SESSION = /^N\d{1,9}$/;
 /** The app's own mark of a tree it hands over (32 random bytes, base64url). */
 export const APP_TOKEN = /^[A-Za-z0-9_-]{22,43}$/;
 /** An excerpt's mark (_STROM_CLIP): letters, digits and "-", at most 32. */
@@ -103,6 +109,7 @@ export function parseLink(text) {
     switch (action) {
         case "send":
         case "app":
+        case "live":
         case "open":
         case "update":
         case "sessions":
@@ -115,8 +122,10 @@ export function parseLink(text) {
                 throw new LinkError("no excerpt named");
             return { action, tree: id, source, clip };
         }
-        case "chat":
-            return { action, tree: id, ...(person ? { person } : {}) };
+        case "chat": {
+            const research = idOf(q, "research", RESEARCH, false);
+            return { action, tree: id, ...(person ? { person } : {}), ...(research ? { research } : {}) };
+        }
         case "task": {
             const task = idOf(q, "task", TASK, true);
             return { action, tree: id, task, ...(q.has("do") ? { do: oneOf(q, "do", LINK_TASK_DOS) } : {}) };
@@ -136,6 +145,10 @@ export function parseLink(text) {
             return { action, tree: id, id: idOf(q, "id", CONFLICT, true), do: oneOf(q, "do", LINK_CONFLICT_DOS, "decide") };
         case "sync-undo":
             return { action, tree: id, intake: idOf(q, "intake", INPUT, true) };
+        case "direction":
+            return { action, tree: id, id: idOf(q, "id", RESEARCH, true), do: oneOf(q, "do", LINK_DIRECTION_DOS) };
+        case "finish":
+            return { action, tree: id, session: idOf(q, "session", SESSION, true) };
     }
     throw new LinkError(`unknown action "${action.slice(0, 32)}"`);
 }