strom-research 1.7.0 → 1.8.0

package/dist/core/pack.js

@@ -309,3 +309,34 @@ export function unpack(pack, treesDir, shared, env) {
         throw e;
     }
 }
+/** The files of the shared store a tree names (its images, the family's material kept there), by its folder alone. */
+export function sharedFilesOf(root) {
+    const out = new Map();
+    const read = (dir, f) => {
+        let names = [];
+        try {
+            names = fs.readdirSync(path.join(root, "data", dir)).filter((n) => n.endsWith(".json"));
+        }
+        catch {
+            return;
+        }
+        for (const n of names)
+            try {
+                f(JSON.parse(fs.readFileSync(path.join(root, "data", dir, n), "utf8")));
+            }
+            catch {
+                // an unreadable record names nothing
+            }
+    };
+    read("images", (m) => m.file && out.set(m.file, m.size ?? 0));
+    read("inputs", (i) => i.file?.startsWith("media:") && out.set(i.file.slice(6), i.size ?? 0));
+    return out;
+}
+/** The files of the shared store only this tree names — none of the other trees (their folders) does. */
+export function onlyItsFiles(root, others, shared) {
+    const theirs = new Set();
+    for (const o of others)
+        for (const f of sharedFilesOf(o).keys())
+            theirs.add(f);
+    return [...sharedFilesOf(root)].filter(([f]) => !theirs.has(f) && fs.existsSync(path.join(shared, f))).map(([file, size]) => ({ file, size }));
+}

package/dist/core/phrases.js

@@ -78,6 +78,67 @@ export const PHRASES = {
     "intake.done.read": "what it adds to the tree is entered as leads citing it (strom source add … --kind family-tree --form authored --input {id}) — or the input is skipped with a reason (strom input skip {id} --reason …)",
     "intake.done": "every person and fact in it is recorded (a source if it is an original document, leads otherwise) and cited — or the input is skipped with a reason (strom input skip I… --reason …)",
     "task.answer": "The user answered (to: {asked}): {answer}",
+    // who is at work, for the Strom app (the bridge's working)
+    "who.run": "{agent} on its own",
+    "who.chat": "{agent} conversation",
+    // what a commit saved, for the Strom app (core/changelog.ts)
+    "log.person.add": "New person: {who}",
+    "log.person.name": "Name recorded: {who}",
+    "log.person.edit": "Changed: {who}",
+    "log.person.cite": "A record for {who}",
+    "log.person.retract": "Withdrawn: {who}",
+    "log.merge": "Two records of one merged: {who}",
+    "log.family.add": "New family: {who}",
+    "log.family.child": "A child of {who}: {child}",
+    "log.family.edit": "Family changed: {who}",
+    "log.family.cite": "A record for the family {who}",
+    "log.event.add": "{who} – {fact}",
+    "log.event.edit": "Refined: {who} – {fact}",
+    "log.event.cite": "A record for: {who} – {fact}",
+    "log.event.retract": "Withdrawn: {who} – {fact}",
+    "log.source.add": "Record from a source: {name}",
+    "log.source.edit": "Record changed: {name}",
+    "log.search.found": "Searched, found: {name}",
+    "log.search.negative": "Searched, nothing there: {name}",
+    "log.search.partial": "Searched, found in part: {name}",
+    "log.search.inconclusive": "Searched, not clear: {name}",
+    "log.recordset.add": "New book: {name}",
+    "log.recordset.edit": "Book changed: {name}",
+    "log.recordset.calibrate": "Which years are where in the book: {name}",
+    "log.media": "New images: {name} (images {images})",
+    "log.media.one": "New image: {name} (image {image})",
+    "log.media.loose": "New images: {n}",
+    "log.reading": "Read through: {name} (images {images})",
+    "log.task.add": "New task: {name}",
+    "log.task.done": "Done: {name}",
+    "log.task.park": "Put aside: {name}",
+    "log.task.drop": "Dropped: {name}",
+    "log.task.wait": "Waits for you: {name}",
+    "log.task.wake": "Back to the agent: {name}",
+    "log.task.edit": "Task changed: {name}",
+    "log.session.start": "The agent began: {name}",
+    "log.session.close": "The agent finished: {name}",
+    "log.lesson.add": "Learned: {name}",
+    "log.hypothesis.add": "A question weighed: {name}",
+    "log.hypothesis.argue": "Weighed further: {name}",
+    "log.hypothesis.decide": "Decided: {name}",
+    "log.conflict.add": "The records disagree: {name}",
+    "log.conflict.resolve": "Disagreement settled: {name}",
+    "log.place.add": "New place: {name}",
+    "log.place.edit": "Place refined: {name}",
+    "log.repository.add": "New archive: {name}",
+    "log.repository.edit": "Archive changed: {name}",
+    "log.story.set": "Story: {who}",
+    "log.story.approve": "Story approved: {who}",
+    "log.note.add": "Note: {name}",
+    "log.input.add": "Material from the family: {name}",
+    "log.input.sync": "Family tree taken in: {name}",
+    "log.input.done": "Material gone through: {name}",
+    "log.research.add": "New direction of the research: {name}",
+    "log.research.edit": "Direction changed: {name}",
+    "log.research.pause": "Direction paused: {name}",
+    "log.research.resume": "Direction taken up again: {name}",
+    "log.research.done": "Direction ended: {name}",
 };
 const catalogs = new Map();
 /**

package/dist/core/queue.js

@@ -12,6 +12,7 @@ import { parentsOf } from "./people.js";
 import { taskRecordsets } from "./frontier.js";
 import { now } from "./tree.js";
 import { subjectPeople } from "./records.js";
+import { directionOf, scopes } from "./directions.js";
 export const LEVEL_ORDER = { intake: 0, locate: 1, link: 2, verify: 3, enrich: 4, request: 5, narrate: 6 };
 /** Levels that read records: without images of their record sets they can only ask the user for them. */
 const NEEDS_IMAGES = new Set(["link", "verify"]);
@@ -53,9 +54,13 @@ export function ancestorLines(tree, focus, max = 50) {
 /** The open tasks in the order to work on them, each with the reason. */
 export function rankTasks(tree, tasks, strategy = "balanced", opts = {}) {
     const today = now().slice(0, 10);
-    const open = tasks.filter((t) => ["open", "doing"].includes(effectiveState(t, today)));
-    const withImages = new Set(tree.list("media").map((m) => m.recordset));
     const researches = tree.list("research");
+    // a direction the user paused or ended: its tasks wait (one at work goes on)
+    const stopped = new Set(researches.filter((r) => r.state !== "active").map((r) => r.id));
+    const all = stopped.size ? scopes(tree) : [];
+    const waits = (t) => t.state !== "doing" && stopped.size > 0 && stopped.has(directionOf(tree, t, all) ?? "");
+    const open = tasks.filter((t) => ["open", "doing"].includes(effectiveState(t, today)) && !waits(t));
+    const withImages = new Set(tree.list("media").map((m) => m.recordset));
     const lines = new Map();
     const linesOf = (researchId) => {
         const r = researches.find((x) => x.id === researchId) ?? (researches.length === 1 ? researches[0] : undefined);

package/dist/core/relocate.js

@@ -33,15 +33,15 @@ export function within(inner, outer, platform = process.platform) {
 export function sameFolder(a, b, platform = process.platform) {
     return within(path.resolve(a), path.resolve(b), platform) && within(path.resolve(b), path.resolve(a), platform);
 }
-/** Somebody at work in a tree: an agent present, a run, a command holding its lock, the live bridge. */
-function atWork(root) {
-    return liveWorkers(root).length > 0 || runsAtWork(root).length > 0 || Boolean(liveHolder(path.join(root, ".strom", "tree.lock"))) || Boolean(liveRunning(root));
+/** Somebody at work in a tree: an agent present, a run, a command holding its lock, the live bridge (unless `bridge: false`: it only reads). */
+export function atWork(root, opts = {}) {
+    return liveWorkers(root).length > 0 || runsAtWork(root).length > 0 || Boolean(liveHolder(path.join(root, ".strom", "tree.lock"))) || (opts.bridge !== false && Boolean(liveRunning(root)));
 }
 /** `trees`: the folders of the trees strom knows (those inside `from` move along). */
 export function planMove(from, to, trees) {
     const names = entries(from);
     const inside = trees.filter((t) => within(t, from));
-    const busy = inside.filter(atWork).map((t) => path.basename(t));
+    const busy = inside.filter((t) => atWork(t)).map((t) => path.basename(t));
     // The top of a disk (its own hidden folders only): into a folder named like the old one there.
     const there = entries(to);
     const target = there.length && there.every((n) => DISK.has(n)) ? path.join(to, path.basename(from) || "Strom") : to;

package/dist/core/session.js

@@ -11,6 +11,7 @@ import { UsageError } from "./errors.js";
 import { now, VERSION } from "./tree.js";
 import { makeNote } from "./actions.js";
 import { detectAgent } from "./which.js";
+import { finishAsked, finishFile } from "./clock.js";
 import { isLiveWorker, isWorkerId } from "./workers.js";
 function currentFile(tree, env = tree.env) {
     const w = env.STROM_WORKER;
@@ -121,7 +122,7 @@ export function sessionNote(tree, s, text) {
 export function closeSession(tree, s, input) {
     if (!input.interrupted && (!input.summary.trim() || !input.next.trim()))
         throw new UsageError("closing needs --summary and --next", { hint: 'e.g. --summary "found the baptism, parents Josef and Marie" --next "marriage of Josef ~1898 in B0002"' });
-    return tree.withTreeLock(() => {
+    const closed = tree.withTreeLock(() => {
         s = tree.get(s.id) ?? s;
         const task = s.task ? tree.get(s.task) : undefined;
         if (task && task.state === "doing") {
@@ -140,7 +141,8 @@ export function closeSession(tree, s, input) {
             ...(input.summary.trim() ? { summary: input.summary.trim() } : {}),
             ...(input.next.trim() ? { next: input.next.trim() } : {}),
             ...(input.metrics ? { metrics: input.metrics } : {}),
-            ...(input.endedBy ? { endedBy: input.endedBy } : {}),
+            // asked to finish by the user (strom session finish): theirs, and a run stops after it
+            ...(input.endedBy ? { endedBy: input.endedBy } : finishAsked(tree.root, s.id) ? { endedBy: "user" } : {}),
         };
         tree.put(closed, { op: "session.close", targets: [s.id], summary: `${s.id} ${closed.state}: ${(input.summary || "no summary").slice(0, 80)}` });
         // Only the session this agent calls its current one is forgotten — not another agent's.
@@ -148,6 +150,10 @@ export function closeSession(tree, s, input) {
             setCurrent(tree, undefined);
         return closed;
     });
+    // asked to finish (strom session finish): done
+    if (!tree.dryRun)
+        fs.rmSync(finishFile(tree.root, closed.id), { force: true });
+    return closed;
 }
 /** The last closed sessions (newest first), optionally of one research. */
 export function recentSessions(tree, research, n = 2) {

package/dist/core/trash.js

@@ -0,0 +1,72 @@
+// Into the system's trash, never deleted for good: a person can take it back.
+// macOS: ~/.Trash (Finder's own delete when it lies on another disk); Windows:
+// the Recycle Bin (PowerShell's VisualBasic FileSystem); Linux: gio trash, else
+// the XDG trash folder of the user's home.
+import fs from "node:fs";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+import { StromError } from "./errors.js";
+import { userHome } from "./paths.js";
+function free(dir, name) {
+    let to = path.join(dir, name);
+    for (let n = 2; fs.existsSync(to); n++)
+        to = path.join(dir, `${name} (${n})`);
+    return to;
+}
+function run(command, args, env) {
+    const r = spawnSync(command, args, { stdio: "ignore", windowsHide: true, timeout: 120_000, env: { ...process.env, ...env } });
+    return !r.error && r.status === 0;
+}
+/** Move a file or folder into the trash; `name` is what it is called there. Throws when no trash takes it. */
+export function moveToTrash(target, env, name = path.basename(target), platform = process.platform) {
+    if (!fs.existsSync(target))
+        return;
+    const fail = () => new StromError(`could not put ${target} into the trash`, { hint: "move the folder into the trash yourself" });
+    if (env.STROM_TRASH) {
+        // a test's own trash: nothing of the computer's
+        fs.mkdirSync(env.STROM_TRASH, { recursive: true });
+        fs.renameSync(target, free(env.STROM_TRASH, name));
+        return;
+    }
+    if (platform === "darwin") {
+        const trash = path.join(userHome(env), ".Trash");
+        try {
+            fs.mkdirSync(trash, { recursive: true });
+            fs.renameSync(target, free(trash, name));
+            return;
+        }
+        catch (e) {
+            if (e.code !== "EXDEV")
+                throw fail();
+        }
+        // on another disk: Finder puts it into that disk's own trash
+        const script = `tell application "Finder" to delete (POSIX file ${JSON.stringify(target)} as alias)`;
+        if (!run("osascript", ["-e", script], env))
+            throw fail();
+        return;
+    }
+    if (platform === "win32") {
+        const kind = fs.statSync(target).isDirectory() ? "DeleteDirectory" : "DeleteFile";
+        const lit = `'${target.replace(/'/g, "''")}'`;
+        const ps = `Add-Type -AssemblyName Microsoft.VisualBasic; [Microsoft.VisualBasic.FileIO.FileSystem]::${kind}(${lit}, 'OnlyErrorDialogs', 'SendToRecycleBin')`;
+        if (!run("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", ps], env) || fs.existsSync(target))
+            throw fail();
+        return;
+    }
+    if (run("gio", ["trash", target], env) && !fs.existsSync(target))
+        return;
+    // the XDG trash of the home: the file, and a note of where it came from
+    const base = env.XDG_DATA_HOME || path.join(userHome(env), ".local", "share");
+    const files = path.join(base, "Trash", "files");
+    const info = path.join(base, "Trash", "info");
+    try {
+        fs.mkdirSync(files, { recursive: true });
+        fs.mkdirSync(info, { recursive: true });
+        const to = free(files, name);
+        fs.renameSync(target, to);
+        fs.writeFileSync(path.join(info, `${path.basename(to)}.trashinfo`), `[Trash Info]\nPath=${encodeURI(target)}\nDeletionDate=${new Date().toISOString().slice(0, 19)}\n`);
+    }
+    catch {
+        throw fail();
+    }
+}

package/dist/core/tree.js

@@ -23,7 +23,7 @@ import * as git from "./git.js";
 import { commitSeal, createKey, fingerprint, loadKey, sha256, signOp } from "./seal.js";
 import { stringifyCanonical } from "./json.js";
 export const TREE_FILE = "strom.json";
-export const VERSION = "1.7.0";
+export const VERSION = "1.8.0";
 const GITIGNORE = `# Strom Research — local state and large files are not versioned
 .strom/
 /media/

package/dist/core/workers.js

@@ -9,6 +9,26 @@ import { acquireLock, liveHolder } from "./lock.js";
 function dir(root) {
     return path.join(root, ".strom", "workers");
 }
+function pauseFile(root, id) {
+    return path.join(dir(root), `${id}.paused`);
+}
+/** A run waits for its gate (the app shows it paused, not at work) — or goes on (undefined). */
+export function markPaused(root, id, paused) {
+    const file = pauseFile(root, id);
+    if (!paused)
+        return fs.rmSync(file, { force: true });
+    fs.mkdirSync(dir(root), { recursive: true });
+    fs.writeFileSync(file, JSON.stringify(paused));
+}
+function pausedOf(root, id) {
+    try {
+        const p = JSON.parse(fs.readFileSync(pauseFile(root, id), "utf8"));
+        return typeof p.until === "string" ? { until: p.until, ...(typeof p.reason === "string" ? { reason: p.reason } : {}) } : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 /** A worker's name, safe as a file name. */
 export function isWorkerId(id) {
     return !!id && /^[\w.-]{1,80}$/.test(id);
@@ -29,11 +49,16 @@ export function liveWorkers(root) {
     }
     for (const f of files) {
         const file = path.join(dir(root), f);
+        const id = f.slice(0, -5);
         const info = liveHolder(file, 7 * 24 * 3600_000);
-        if (info)
-            out.push({ id: f.slice(0, -5), label: info.owner, since: info.at });
-        else
+        if (info) {
+            const paused = pausedOf(root, id);
+            out.push({ id, label: info.owner, since: info.at, ...(paused ? { paused } : {}) });
+        }
+        else {
             fs.rmSync(file, { force: true });
+            fs.rmSync(pauseFile(root, id), { force: true });
+        }
     }
     return out;
 }

package/dist/runners/claude.js

@@ -13,7 +13,7 @@
 // are on only when a connector fetches through the browser (--chrome), and off
 // otherwise (--no-chrome), whatever Claude Code's own default is.
 import { randomUUID } from "node:crypto";
-import { appendLog, looksLikeLimit, spawnAgent, stopTree } from "./runner.js";
+import { appendLog, looksLikeLimit, OWN_GROUP, spawnAgent, stopTree } from "./runner.js";
 function describeTool(block) {
     const input = block.input ?? {};
     if (block.name === "Bash" && typeof input.command === "string")
@@ -71,6 +71,7 @@ function attempt(opts, args, input, timeoutMs) {
             env: opts.interactive ? opts.env : headlessEnv(opts.env, opts.timeoutMs),
             stdio: opts.interactive ? "inherit" : ["pipe", "pipe", "pipe"],
             windowsHide: !opts.interactive,
+            detached: !opts.interactive && OWN_GROUP,
         });
         // The brief goes in on stdin: no limit on its length on any platform.
         if (!opts.interactive)

package/dist/runners/jsonl.js

@@ -4,7 +4,7 @@
 // recognised — the same for every such agent; each runner only reads its own
 // events. Stopped at its time limit, an agent that can resume its session gets a
 // few minutes to write down what it found (RunOptions.wrapUp).
-import { appendLog, looksLikeLimit, spawnAgent, stopTree } from "./runner.js";
+import { appendLog, looksLikeLimit, OWN_GROUP, spawnAgent, stopTree } from "./runner.js";
 export async function runJsonLines(command, args, env, opts, resume, onEvent) {
     const started = Date.now();
     const heard = { metrics: {}, text: "", isError: false, denied: [] };
@@ -54,7 +54,7 @@ export async function runJsonLines(command, args, env, opts, resume, onEvent) {
 /** One start of the agent; its events go to `heard`. */
 function attempt(command, args, input, env, opts, timeoutMs, heard, onEvent) {
     return new Promise((resolve) => {
-        const child = spawnAgent(command, args, { cwd: opts.cwd, env, stdio: ["pipe", "pipe", "pipe"], windowsHide: true });
+        const child = spawnAgent(command, args, { cwd: opts.cwd, env, stdio: ["pipe", "pipe", "pipe"], windowsHide: true, detached: OWN_GROUP });
         child.stdin?.end(input);
         let timedOut = false;
         const timer = timeoutMs

package/dist/runners/runner.js

@@ -47,17 +47,30 @@ export function spawnAgent(command, args, opts) {
     }
     return spawn(found, args, { ...opts, env: opts.env });
 }
-/** Stop a child and everything it started (Windows: the whole process tree). */
+/**
+ * A headless agent in a process group of its own (not on Windows, whose console sends Ctrl-C to every process of
+ * it): Ctrl-C in the terminal reaches strom alone, which asks the session to finish first (strom run).
+ */
+export const OWN_GROUP = process.platform !== "win32";
+/** Stop a child and everything it started (Windows: the whole process tree; elsewhere its own group, when it has one). */
 export function stopTree(child) {
     if (child.exitCode !== null || child.pid === undefined)
         return;
     if (process.platform === "win32")
         spawn("taskkill", ["/pid", String(child.pid), "/T", "/F"], { stdio: "ignore", windowsHide: true });
     else {
-        child.kill("SIGTERM");
+        const kill = (sig) => {
+            try {
+                process.kill(-child.pid, sig); // its group: what it started too
+            }
+            catch {
+                child.kill(sig); // no group of its own
+            }
+        };
+        kill("SIGTERM");
         setTimeout(() => {
             if (child.exitCode === null)
-                child.kill("SIGKILL");
+                kill("SIGKILL");
         }, 5000).unref();
     }
 }

package/dist/runners/script.js

@@ -3,7 +3,7 @@
 // (run with node); it gets the same environment an agent would, and the
 // prompt both on stdin (like a headless agent) and in STROM_PROMPT.
 import { spawn } from "node:child_process";
-import { appendLog, looksLikeLimit, stopTree } from "./runner.js";
+import { appendLog, looksLikeLimit, OWN_GROUP, stopTree } from "./runner.js";
 export const scriptRunner = {
     id: "script",
     command: process.execPath,
@@ -26,6 +26,7 @@ function once(opts, prompt, timeoutMs, wrapUp) {
             cwd: opts.cwd,
             env: { ...opts.env, STROM_PROMPT: prompt, ...(wrapUp ? { STROM_WRAP_UP: "1" } : {}) },
             stdio: ["pipe", "pipe", "pipe"],
+            detached: OWN_GROUP,
         });
         child.stdin.end(prompt);
         let timedOut = false;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "strom-research",
-  "version": "1.7.0",
+  "version": "1.8.0",
   "description": "Genealogical research toolkit for AI coding agents",
   "type": "module",
   "bin": {