parawatch 0.2.0 → 0.3.1

package/dist/core/follow.js

@@ -1,62 +1,49 @@
 import fs from "node:fs";
-import { eventsPath, homeDir, parseEventLines } from "./store.js";
+import { endOf, eventFiles, eventsDir, isAfter, parseEventLines, readEvents } from "./store.js";
 /**
- * Call `onEvent` for every event appended after `afterSeq` (or after the current end when it is
- * undefined). Watches the store folder and also checks once a second. Returns a stop function.
+ * Call `onEvent` for every event appended after `after` (or after the current end when it is
+ * undefined), in any machine's log. Watches the log folder and also checks once a second, so a
+ * log a sync tool brings in from another machine shows up too. Returns a stop function.
  */
-export function followEvents(onEvent, afterSeq) {
-    const file = eventsPath();
-    let offset = 0;
-    let lastSeq = afterSeq ?? Infinity;
-    try {
-        const text = fs.readFileSync(file, "utf8");
-        offset = Buffer.byteLength(text);
-        const events = parseEventLines(text);
-        const end = events[events.length - 1]?.seq ?? 0;
-        if (afterSeq === undefined)
-            lastSeq = end;
-        else {
-            for (const ev of events)
-                if (ev.seq > afterSeq)
-                    onEvent(ev);
-            lastSeq = Math.max(afterSeq, end);
-        }
-    }
-    catch {
-        lastSeq = afterSeq ?? 0;
-    }
+export function followEvents(onEvent, after) {
+    const offsets = new Map();
+    let pos = after ?? endOf(readEvents());
     const pump = () => {
-        let size = 0;
-        try {
-            size = fs.statSync(file).size;
-        }
-        catch {
-            return;
-        }
-        if (size < offset)
-            offset = 0; // file replaced
-        if (size === offset)
-            return;
-        const fd = fs.openSync(file, "r");
-        const buf = Buffer.alloc(size - offset);
-        fs.readSync(fd, buf, 0, buf.length, offset);
-        fs.closeSync(fd);
-        const text = buf.toString("utf8");
-        const cut = text.lastIndexOf("\n");
-        if (cut < 0)
-            return;
-        offset += Buffer.byteLength(text.slice(0, cut + 1));
-        for (const ev of parseEventLines(text.slice(0, cut + 1))) {
-            if (ev.seq > lastSeq) {
+        for (const f of eventFiles()) {
+            let size = 0;
+            try {
+                size = fs.statSync(f.file).size;
+            }
+            catch {
+                continue;
+            }
+            let offset = offsets.get(f.file) ?? 0;
+            if (size < offset)
+                offset = 0; // file replaced
+            if (size === offset)
+                continue;
+            const fd = fs.openSync(f.file, "r");
+            const buf = Buffer.alloc(size - offset);
+            fs.readSync(fd, buf, 0, buf.length, offset);
+            fs.closeSync(fd);
+            const text = buf.toString("utf8");
+            const cut = text.lastIndexOf("\n");
+            if (cut < 0)
+                continue;
+            offsets.set(f.file, offset + Buffer.byteLength(text.slice(0, cut + 1)));
+            for (const ev of parseEventLines(text.slice(0, cut + 1), f.device)) {
+                if (!isAfter(ev, pos))
+                    continue;
+                pos = { ...pos, [f.device]: ev.seq };
                 onEvent(ev);
-                lastSeq = ev.seq;
             }
         }
     };
+    pump();
     let watcher;
     try {
-        fs.mkdirSync(homeDir(), { recursive: true });
-        watcher = fs.watch(homeDir(), () => pump());
+        fs.mkdirSync(eventsDir(), { recursive: true });
+        watcher = fs.watch(eventsDir(), () => pump());
     }
     catch {
         watcher = undefined; // the timer alone still works

package/dist/core/format.js

@@ -138,9 +138,13 @@ export function cardDetail(c) {
     if (c.from || c.session)
         out.push(`From: ${[c.from, c.session ? `session ${c.session.slice(0, 8)}` : ""].filter(Boolean).join(", ")}`);
     out.push(`Opened: ${new Date(c.openedAt).toLocaleString()}${c.since ? `, first came up ${new Date(c.since).toLocaleDateString()}` : ""}`);
+    if (c.dev)
+        out.push(`Machine: ${c.dev}`);
     for (const a of c.answers) {
         const choice = a.choice !== undefined ? ` chose ${a.choice}${c.options?.[a.choice - 1] ? ` (${c.options[a.choice - 1]})` : ""}` : "";
-        out.push("", `${a.by}${choice}${a.comment ? `: ${a.comment}` : ""}`);
+        const where = a.dev ? ` on ${a.dev}` : "";
+        const late = a.late ? "  (not used: given at the same time as the answer before it, which stands)" : "";
+        out.push("", `${a.by}${where}${choice}${a.comment ? `: ${a.comment}` : ""}${late}`);
         for (const f of a.attach ?? [])
             out.push(`  attached ${f}`);
     }
@@ -348,4 +352,26 @@ export function runsTree(runs, v = PLAIN, now = Date.now(), indent = "") {
     }
     return out.join("\n");
 }
+// ------------------------------------------------------------------ sharing
+/** `parawatch sync status` as text. */
+export function syncText(st, color = false, now = Date.now()) {
+    const v = { ...PLAIN, color };
+    if (!st)
+        return "This machine keeps its log to itself. To share it with another machine: parawatch sync setup <folder> --device <name>";
+    const lines = [
+        `${paint(v, st.device, "bold")} writes to ${st.dir}`,
+        `adapter  ${st.adapter}${st.ok ? "" : paint(v, " (not reachable)", "yellow")}${st.lastSync ? ` · last in step ${ago(st.lastSync, now)} ago` : ""}${st.pending ? ` · ${st.pending} file(s) on the way` : ""}`,
+    ];
+    if (!st.peers.length)
+        lines.push("peers    none yet");
+    for (const p of st.peers) {
+        const state = p.connected === true ? paint(v, "connected", "green") : p.connected === false ? paint(v, "not connected", "yellow") : "seen";
+        lines.push(`peer     ${p.name}  ${state}${p.lastSeen && p.connected !== true ? ` · last ${ago(p.lastSeen, now)} ago` : ""}${p.address ? ` · ${p.address}` : ""}${p.version ? ` · parawatch ${p.version}` : ""}`);
+    }
+    if (st.conflicts.length)
+        lines.push(paint(v, `conflicts ${st.conflicts.length}:`, "yellow"), ...st.conflicts.map((c) => `  ${c}`));
+    if (st.error)
+        lines.push(paint(v, st.error, "yellow"));
+    return lines.join("\n");
+}
 //# sourceMappingURL=format.js.map

package/dist/core/integrate.js

@@ -1,9 +1,8 @@
 import { spawn } from "node:child_process";
 import fs from "node:fs";
 import path from "node:path";
-import { readInbox, inboxFrom } from "./ops.js";
+import { readInbox, inboxFrom, readState } from "./ops.js";
 import { homeDir, readCursor, readEvents } from "./store.js";
-import { fold } from "./state.js";
 import { inboxLine } from "./format.js";
 export const BEGIN = "<!-- parawatch:begin -->";
 export const END = "<!-- parawatch:end -->";
@@ -52,6 +51,44 @@ export function writeInstructions(file, project) {
     fs.writeFileSync(file, next);
     return true;
 }
+/** Take the parawatch block out of an instruction file. Returns true when the file changed. */
+export function removeInstructions(file) {
+    let text;
+    try {
+        text = fs.readFileSync(file, "utf8");
+    }
+    catch (err) {
+        if (err.code === "ENOENT")
+            return false;
+        throw err;
+    }
+    const a = text.indexOf(BEGIN);
+    const b = text.indexOf(END);
+    if (a < 0 || b < a)
+        return false;
+    const before = text.slice(0, a).replace(/\n+$/, "");
+    const after = text.slice(b + END.length).replace(/^\n+/, "");
+    const next = before && after ? `${before}\n\n${after}` : before ? `${before}\n` : after;
+    fs.writeFileSync(file, next);
+    return true;
+}
+/** Whether a file has the parawatch block, and whether it is the one this version writes. */
+export function instructionState(file) {
+    let text;
+    try {
+        text = fs.readFileSync(file, "utf8");
+    }
+    catch {
+        return "absent";
+    }
+    const a = text.indexOf(BEGIN);
+    const b = text.indexOf(END);
+    if (a < 0 || b < a)
+        return "absent";
+    const block = text.slice(a, b + END.length);
+    const project = /--project (\S+)/.exec(block)?.[1];
+    return block === instructions(project === "<project>" ? undefined : project) ? "current" : "outdated";
+}
 /**
  * Claude Code hook: given the hook's JSON on stdin, return text to add to the turn
  * when the human has answered something for this session's project. Peeks only;
@@ -59,7 +96,7 @@ export function writeInstructions(file, project) {
  */
 export function hookContext(input, project) {
     const events = readEvents();
-    const state = fold(events);
+    const state = readState(events);
     let name = project;
     if (!name && input.session_id)
         name = state.claims.find((c) => input.session_id.startsWith(c.session))?.project;
@@ -70,7 +107,7 @@ export function hookContext(input, project) {
     }
     if (!name)
         return undefined;
-    const items = inboxFrom(events, readCursor(name), { project: name });
+    const items = inboxFrom(events, readCursor(name), { project: name }, state);
     if (!items.length)
         return undefined;
     const cards = items.filter((i) => i.kind !== "pr").length;

package/dist/core/ops.js

@@ -1,9 +1,18 @@
 import fs from "node:fs";
 import path from "node:path";
-import { appendEvent, eventsPath, homeDir, readCursor, readEvents, writeCursor } from "./store.js";
-import { fold, nextId } from "./state.js";
+import { UserError } from "./errors.js";
+import { advance, appendEvent, deviceName, eventsDir, homeDir, isAfter, readCursor, readEvents, sharedDir, writeCursor } from "./store.js";
+import { findId, fold, nextId } from "./state.js";
+import { pathMap } from "./sync.js";
 import { CARD_KINDS, HUMAN, PR_CHANGES } from "./types.js";
-export class UserError extends Error {
+export { UserError };
+/** Current state, with other machines' paths made local. */
+export function readState(events = readEvents()) {
+    return fold(events, pathMap());
+}
+/** The machine name ids carry, when the log is shared. */
+function idDevice() {
+    return sharedDir() ? deviceName() : undefined;
 }
 function cleanList(xs) {
     const out = (xs ?? []).map((x) => x.trim()).filter(Boolean);
@@ -22,7 +31,7 @@ export function addProject(name, paths) {
     }));
 }
 export function removeProject(name) {
-    const s = fold(readEvents());
+    const s = readState();
     if (!s.projects.has(name))
         throw new UserError(`no project named "${name}"`);
     appendEvent(() => ({ type: "project.remove", name }));
@@ -80,7 +89,7 @@ export function openCard(input) {
     const since = input.since?.trim() ? parseWhen(input.since) : undefined;
     let id = "";
     appendEvent((events) => {
-        id = nextId(events, "c");
+        id = nextId(events, "c", idDevice());
         const session = input.session?.trim() || undefined;
         const from = input.from?.trim() || sessionTitle(fold(events).claims, session);
         return {
@@ -105,19 +114,31 @@ export function openCard(input) {
             },
         };
     });
-    const card = fold(readEvents()).cards.get(id);
+    const card = readState().cards.get(id);
     if (!card)
         throw new Error("card vanished right after it was written");
     return card;
 }
+/** A card by id; a shared id may leave out its machine (`c3` for `pc-c3`). */
+export function findCard(state, id) {
+    const k = findId(state.cards, id);
+    return k ? state.cards.get(k) : undefined;
+}
 function requireCard(id) {
-    const card = fold(readEvents()).cards.get(id);
+    const card = findCard(readState(), id);
     if (!card)
         throw new UserError(`no card "${id}"`);
     return card;
 }
+function requireRun(id) {
+    const k = findId(readState().runs, id);
+    if (!k)
+        throw new UserError(`no declared run "${id}"`);
+    return k;
+}
 export function answerCard(id, a) {
     const card = requireCard(id);
+    id = card.id;
     if (card.status === "closed")
         throw new UserError(`card ${id} is already closed`);
     if (a.choice === undefined && !a.comment?.trim() && !cleanList(a.attach)) {
@@ -129,23 +150,26 @@ export function answerCard(id, a) {
             throw new UserError(n ? `--choice must be between 1 and ${n}` : `card ${id} has no options`);
         }
     }
-    appendEvent(() => ({
+    const shared = !!sharedDir();
+    appendEvent((events) => ({
         type: "card.answer",
         card: id,
         by: a.by || HUMAN,
         choice: a.choice,
         comment: a.comment?.trim() || undefined,
         attach: absPaths(a.attach),
+        // what this machine knew when answering, so a crossing answer from another machine shows
+        seen: shared ? events.filter((e) => e.type === "card.answer" && e.card === id).length : undefined,
     }));
 }
 export function commentCard(id, text, by) {
-    requireCard(id);
+    id = requireCard(id).id;
     if (!text.trim())
         throw new UserError("a comment needs text");
     appendEvent(() => ({ type: "card.comment", card: id, by, text: text.trim() }));
 }
 export function editCard(id, set) {
-    requireCard(id);
+    id = requireCard(id).id;
     const clean = {};
     if (set.kind !== undefined)
         clean.kind = checkKind(set.kind);
@@ -175,7 +199,7 @@ export function closeCard(id, note) {
     const card = requireCard(id);
     if (card.status === "closed")
         return;
-    appendEvent(() => ({ type: "card.close", card: id, note: note?.trim() || undefined }));
+    appendEvent(() => ({ type: "card.close", card: card.id, note: note?.trim() || undefined }));
 }
 export function startRun(r) {
     if (r.heartbeat !== undefined && (!Number.isFinite(r.heartbeat) || r.heartbeat <= 0))
@@ -183,25 +207,22 @@ export function startRun(r) {
     const log = r.log?.trim() ? path.resolve(r.log) : undefined;
     let id = "";
     appendEvent((events) => {
-        id = nextId(events, "r");
+        id = nextId(events, "r", idDevice());
         return { type: "run.start", run: { id, project: r.project, task: r.task, title: r.title, parent: r.parent, heartbeat: r.heartbeat, log } };
     });
     return id;
 }
 export function noteRun(id, text) {
-    if (!fold(readEvents()).runs.has(id))
-        throw new UserError(`no declared run "${id}"`);
-    appendEvent(() => ({ type: "run.note", run: id, text }));
+    const run = requireRun(id);
+    appendEvent(() => ({ type: "run.note", run, text }));
 }
 export function beatRun(id) {
-    if (!fold(readEvents()).runs.has(id))
-        throw new UserError(`no declared run "${id}"`);
-    appendEvent(() => ({ type: "run.beat", run: id }));
+    const run = requireRun(id);
+    appendEvent(() => ({ type: "run.beat", run }));
 }
 export function endRun(id, status, note) {
-    if (!fold(readEvents()).runs.has(id))
-        throw new UserError(`no declared run "${id}"`);
-    appendEvent(() => ({ type: "run.end", run: id, status, note }));
+    const run = requireRun(id);
+    appendEvent(() => ({ type: "run.end", run, status, note }));
 }
 /**
  * Say which project and task a session works on. A claim without a project keeps the session's
@@ -210,7 +231,7 @@ export function endRun(id, status, note) {
 export function claimSession(input) {
     if (input.session.length < 6)
         throw new UserError("give at least 6 characters of the session id");
-    const before = fold(readEvents()).claims.find((c) => c.session === input.session);
+    const before = readState().claims.find((c) => c.session === input.session);
     const project = input.project?.trim() || before?.project;
     if (!project)
         throw new UserError("this session has not claimed a project yet: give --project");
@@ -233,7 +254,7 @@ export function claimSession(input) {
 }
 // ---------------------------------------------------------------- pull requests
 export function linkPr(link) {
-    const claims = fold(readEvents()).claims;
+    const claims = readState().claims;
     const claim = link.session ? claims.find((c) => link.session.startsWith(c.session)) : undefined;
     const project = link.project?.trim() || claim?.project;
     appendEvent(() => ({
@@ -242,7 +263,7 @@ export function linkPr(link) {
     }));
 }
 export function unlinkPr(key) {
-    if (!fold(readEvents()).prLinks.has(key))
+    if (!readState().prLinks.has(key))
         throw new UserError(`no linked pull request ${key}`);
     appendEvent(() => ({ type: "pr.unlink", pr: key }));
 }
@@ -252,26 +273,45 @@ export function prEvent(pr, change, opts = {}) {
         throw new UserError(`change must be one of ${PR_CHANGES.join(", ")}`);
     appendEvent(() => ({ type: "pr.change", pr, change: change, by: opts.by, text: opts.text?.trim() || undefined, title: opts.title, source: "external" }));
 }
+/** Two machines that both read GitHub report the same change; the later report is an echo. */
+const ECHO_MS = 30 * 60_000;
 /**
- * Human answers and comments newer than `afterSeq`, on cards that are not closed, and news on pull
- * requests linked to the project.
+ * Human answers and comments after `after` (a position, or a seq on a single machine), on cards
+ * that are not closed, and news on pull requests linked to the project. An answer given on
+ * another machine before it saw an earlier answer is kept on the card but not delivered.
  */
-export function inboxFrom(events, afterSeq, filter) {
-    const state = fold(events);
+export function inboxFrom(events, after, filter, state = readState(events)) {
+    const pos = typeof after === "number" ? { [deviceName()]: after } : after;
     const out = [];
+    const reported = new Map();
+    const answerNo = new Map();
     for (const ev of events) {
-        if (ev.seq <= afterSeq)
-            continue;
         if (ev.type === "pr.change") {
+            const k = `${ev.pr.key}|${ev.change}|${ev.text ?? ""}`;
+            const prev = reported.get(k);
+            const at = Date.parse(ev.ts);
+            reported.set(k, { dev: ev.dev, at });
+            if (prev && prev.dev !== ev.dev && at - prev.at < ECHO_MS)
+                continue;
+            if (!isAfter(ev, pos))
+                continue;
             const link = state.prLinks.get(ev.pr.key);
             if (!link || filter.card || (filter.project && link.project !== filter.project))
                 continue;
-            out.push({ seq: ev.seq, at: ev.ts, kind: "pr", by: ev.by ?? ev.source, pr: { ref: ev.pr, change: ev.change, title: ev.title, text: ev.text, project: link.project } });
+            out.push({ seq: ev.seq, dev: ev.dev, at: ev.ts, kind: "pr", by: ev.by ?? ev.source, pr: { ref: ev.pr, change: ev.change, title: ev.title, text: ev.text, project: link.project } });
             continue;
         }
         if (ev.type !== "card.answer" && ev.type !== "card.comment")
             continue;
-        if (ev.by !== HUMAN)
+        let late = false;
+        if (ev.type === "card.answer") {
+            const n = answerNo.get(ev.card) ?? 0;
+            answerNo.set(ev.card, n + 1);
+            late = typeof ev.seen === "number" && ev.seen < n;
+        }
+        if (!isAfter(ev, pos))
+            continue;
+        if (ev.by !== HUMAN || late)
             continue;
         const card = state.cards.get(ev.card);
         if (!card || card.status === "closed")
@@ -283,6 +323,7 @@ export function inboxFrom(events, afterSeq, filter) {
         if (ev.type === "card.answer") {
             out.push({
                 seq: ev.seq,
+                dev: ev.dev,
                 at: ev.ts,
                 kind: "answer",
                 card,
@@ -294,26 +335,50 @@ export function inboxFrom(events, afterSeq, filter) {
             });
         }
         else {
-            out.push({ seq: ev.seq, at: ev.ts, kind: "comment", card, by: ev.by, comment: ev.text });
+            out.push({ seq: ev.seq, dev: ev.dev, at: ev.ts, kind: "comment", card, by: ev.by, comment: ev.text });
         }
     }
     return out;
 }
 // ---------------------------------------------------------------- listeners
+/** Waits are visible to every machine when the log is shared. */
 function listenersDir() {
-    return path.join(homeDir(), "listeners");
+    return path.join(sharedDir() ?? homeDir(), "listeners");
 }
+/** How often a wait says it is still there, and when one on another machine counts as gone. */
+const LISTENER_BEAT_MS = 60_000;
+const LISTENER_GONE_MS = 3 * LISTENER_BEAT_MS;
 /** Mark this process as waiting, so cards can say whether an answer reaches an agent at once. */
 export function startListening(l) {
-    const file = path.join(listenersDir(), `${process.pid}.json`);
+    const shared = !!sharedDir();
+    const file = path.join(listenersDir(), shared ? `${deviceName()}-${process.pid}.json` : `${process.pid}.json`);
     fs.mkdirSync(listenersDir(), { recursive: true });
-    const me = { ...l, pid: process.pid, since: new Date().toISOString() };
-    fs.writeFileSync(file, JSON.stringify(me) + "\n");
+    const me = { ...l, pid: process.pid, since: new Date().toISOString(), ...(shared ? { device: deviceName(), beat: new Date().toISOString() } : {}) };
+    const write = () => {
+        try {
+            const tmp = `${file}.tmp`;
+            fs.writeFileSync(tmp, JSON.stringify(me) + "\n");
+            fs.renameSync(tmp, file);
+        }
+        catch {
+            // the folder may be busy syncing; the next beat writes it again
+        }
+    };
+    write();
+    const timer = shared
+        ? setInterval(() => {
+            me.beat = new Date().toISOString();
+            write();
+        }, LISTENER_BEAT_MS)
+        : undefined;
+    timer?.unref();
     let done = false;
     const stop = () => {
         if (done)
             return;
         done = true;
+        if (timer)
+            clearInterval(timer);
         fs.rmSync(file, { force: true });
     };
     process.once("exit", stop);
@@ -334,8 +399,11 @@ function alive(pid) {
         return err.code === "EPERM";
     }
 }
-/** Waits running now. Files left by a process that died are removed. */
-export function listeners() {
+/**
+ * Waits running now, on this machine and (when shared) the others. Files left by a process that
+ * died here are removed; a wait on another machine counts while its beat is fresh.
+ */
+export function listeners(now = Date.now()) {
     let names;
     try {
         names = fs.readdirSync(listenersDir()).filter((f) => f.endsWith(".json"));
@@ -343,12 +411,17 @@ export function listeners() {
     catch {
         return [];
     }
+    const me = deviceName();
     const out = [];
     for (const n of names) {
         const file = path.join(listenersDir(), n);
         try {
             const l = JSON.parse(fs.readFileSync(file, "utf8"));
-            if (alive(l.pid))
+            if (l.device && l.device !== me) {
+                if (l.beat && now - Date.parse(l.beat) < LISTENER_GONE_MS)
+                    out.push(l);
+            }
+            else if (alive(l.pid))
                 out.push(l);
             else
                 fs.rmSync(file, { force: true });
@@ -366,12 +439,12 @@ export function listenersFor(card, ls) {
 export function consumerName(opts) {
     return opts.as || opts.project || (opts.card ? `card-${opts.card}` : "default");
 }
-export function readInbox(consumer, filter, advance) {
+export function readInbox(consumer, filter, move) {
     const events = readEvents();
-    const items = inboxFrom(events, readCursor(consumer), filter);
-    const last = items[items.length - 1];
-    if (advance && last)
-        writeCursor(consumer, last.seq);
+    const pos = readCursor(consumer);
+    const items = inboxFrom(events, pos, filter);
+    if (move && items.length)
+        writeCursor(consumer, advance(pos, items));
     return items;
 }
 /**
@@ -383,7 +456,7 @@ export async function waitInbox(consumer, filter, timeoutMs, pollMs = 1000) {
     let watcher;
     let wake;
     try {
-        const dir = path.dirname(eventsPath());
+        const dir = eventsDir();
         fs.mkdirSync(dir, { recursive: true });
         watcher = fs.watch(dir, () => wake?.());
     }

package/dist/core/semver.js

@@ -0,0 +1,22 @@
+/** Comparing x.y.z versions; shared by the command line and the desktop app. */
+/** Negative when a is older than b, positive when newer, 0 when the same. A pre-release is older than its release. */
+export function compareVersions(a, b) {
+    const parse = (v) => {
+        const [core = "", pre] = v.trim().replace(/^v/, "").split("-", 2);
+        const nums = core.split(".").map((x) => Number.parseInt(x, 10) || 0);
+        return { nums: [nums[0] ?? 0, nums[1] ?? 0, nums[2] ?? 0], pre };
+    };
+    const x = parse(a);
+    const y = parse(b);
+    for (let i = 0; i < 3; i++)
+        if (x.nums[i] !== y.nums[i])
+            return x.nums[i] - y.nums[i];
+    if (x.pre === y.pre)
+        return 0;
+    if (!x.pre)
+        return 1;
+    if (!y.pre)
+        return -1;
+    return x.pre < y.pre ? -1 : 1;
+}
+//# sourceMappingURL=semver.js.map

package/dist/core/skill.js

@@ -64,4 +64,60 @@ export function installSkill(targets, opts = {}) {
     }
     return out;
 }
+/** Where a skill link points, or undefined when `dest` is not a link. */
+function linkTarget(dest) {
+    try {
+        if (!fs.lstatSync(dest).isSymbolicLink())
+            return undefined;
+        return path.resolve(path.dirname(dest), fs.readlinkSync(dest));
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Remove the skill links `installSkill` made. Only links to a parawatch skill go; a real folder is
+ * left alone, since it may be someone's own copy.
+ */
+export function uninstallSkill(targets, opts = {}) {
+    const out = [];
+    for (const t of targets) {
+        if (opts.only && !opts.only.includes(t.runtime))
+            continue;
+        const dest = path.join(t.dir, "parawatch");
+        let exists = true;
+        try {
+            fs.lstatSync(dest);
+        }
+        catch {
+            exists = false;
+        }
+        if (!exists) {
+            out.push({ runtime: t.runtime, path: dest, result: "not installed" });
+            continue;
+        }
+        const target = linkTarget(dest);
+        if (!target) {
+            out.push({ runtime: t.runtime, path: dest, result: "skipped", note: "a folder, not a link parawatch made; remove it yourself if it is a copy" });
+            continue;
+        }
+        if (path.basename(target) !== "parawatch" || path.basename(path.dirname(target)) !== "skills") {
+            out.push({ runtime: t.runtime, path: dest, result: "skipped", note: `links to ${target}, not a parawatch skill` });
+            continue;
+        }
+        fs.unlinkSync(dest);
+        out.push({ runtime: t.runtime, path: dest, result: "removed", note: target === skillSource() ? undefined : `was ${target}` });
+    }
+    return out;
+}
+/** How the skill is installed for one runtime. */
+export function skillState(t) {
+    const dest = path.join(t.dir, "parawatch");
+    const target = linkTarget(dest);
+    if (target)
+        return { state: target === skillSource() ? "linked" : "linked elsewhere", target };
+    if (fs.existsSync(dest))
+        return { state: "folder" };
+    return { state: fs.existsSync(t.home) ? "missing" : "no runtime" };
+}
 //# sourceMappingURL=skill.js.map