parawatch 0.0.0-stage → 0.2.0

package/dist/bin/cli.js

@@ -0,0 +1,491 @@
+#!/usr/bin/env node
+import { execFileSync } from "node:child_process";
+import fs from "node:fs";
+import { Command } from "commander";
+import { UserError, addProject, answerCard, beatRun, claimSession, closeCard, commentCard, consumerName, editCard, endRun, linkPr, listeners, listenersFor, noteRun, openCard, prEvent, readInbox, removeProject, startListening, startRun, unlinkPr, waitInbox, } from "../core/ops.js";
+import { githubConfig, readCache, resolvePrRef, syncGithub, prViews } from "../core/github.js";
+import { digest, digestText, localDate } from "../core/digest.js";
+import { readEvents } from "../core/store.js";
+import { followEvents } from "../core/follow.js";
+import { fold } from "../core/state.js";
+import { collectRuns } from "../core/runs.js";
+import { askRows, cardDetail, cardLine, cardRows, inboxLine, prRows, runsTree, view } from "../core/format.js";
+import { hookContext, notify, writeInstructions } from "../core/integrate.js";
+import { installSkill, skillSource, skillTargets } from "../core/skill.js";
+import { cardContextLine, resolveGoto } from "../core/desktop.js";
+import { snapshot } from "../core/snapshot.js";
+import { SCHEMA_VERSION } from "../core/types.js";
+const collect = (v, prev = []) => [...prev, v];
+const int = (v) => {
+    const n = Number(v);
+    if (!Number.isInteger(n))
+        throw new UserError(`"${v}" is not a whole number`);
+    return n;
+};
+const print = (x) => process.stdout.write(JSON.stringify(x) + "\n");
+/** The agent session running this command, when its runtime says so. */
+function currentSession() {
+    return process.env.CLAUDE_CODE_SESSION_ID || process.env.CODEX_THREAD_ID || undefined;
+}
+const program = new Command();
+program
+    .name("parawatch")
+    .description("See what your agents are doing, what needs you, and wake the right agent when you answer.")
+    .version("0.2.0");
+/** Read GitHub when the last reading is old; never fails the command. */
+async function refreshGithub(force = false) {
+    try {
+        await syncGithub({ state: fold(readEvents()), force });
+    }
+    catch (err) {
+        if (force)
+            throw err;
+    }
+}
+// ------------------------------------------------------------------ cards
+function cardCommand(kind, name, summary) {
+    return program
+        .command(`${name} <title>`)
+        .description(summary)
+        .requiredOption("-p, --project <name>", "project this card belongs to")
+        .option("-t, --task <task>", "task within the project")
+        .option("-b, --body <text>", "two or three lines of context")
+        .option("--attach <file>", "image, video or file to look at (repeatable)", collect)
+        .option("--from <who>", "who is asking (defaults to the calling session's claimed title)")
+        .option("--session <id>", "the agent session asking (defaults to the calling session)")
+        .option("--since <date>", "when the matter first came up, if earlier (YYYY-MM-DD)")
+        .option("--json", "print the card as JSON");
+}
+/** Options every card kind shares. */
+function common(o) {
+    return {
+        project: o.project,
+        task: o.task,
+        body: o.body,
+        attach: o.attach,
+        from: o.from,
+        session: o.session ?? currentSession(),
+        since: o.since,
+    };
+}
+function finishCard(input, json) {
+    const card = openCard(input);
+    notify(card);
+    if (json)
+        print(card);
+    else
+        process.stdout.write(`${card.id}\n`);
+}
+cardCommand("decide", "ask", "ask the human to decide, or to approve a prepared action")
+    .option("-o, --option <text>", "a choice (repeatable)", collect)
+    .option("-r, --recommend <n>", "the recommended choice, 1-based", int)
+    .option("--action <text>", "the exact command or step that runs on yes (options default to Do it / Don't)")
+    .option("--preview <file>", "a file with the text the action sends or changes (a message, a diff)")
+    .action((title, o) => finishCard({ kind: "decide", title, ...common(o), options: o.option, recommend: o.recommend, action: o.action, preview: o.preview }, o.json));
+cardCommand("try", "try", "ask the human to try a build, watch a video or look at a screen")
+    .option("--open <path>", "app, file or URL to open (repeatable)", collect)
+    .option("-l, --look <text>", "what to look at")
+    .action((title, o) => finishCard({ kind: "try", title, ...common(o), open: o.open, look: o.look }, o.json));
+cardCommand("block", "block", "something only the human can do, and you are stuck until they do it")
+    .action((title, o) => finishCard({ kind: "block", title, ...common(o) }, o.json));
+cardCommand("todo", "todo", "something only the human can do, but nothing waits on it now")
+    .action((title, o) => finishCard({ kind: "todo", title, ...common(o) }, o.json));
+program
+    .command("edit <card>")
+    .description("change a card: its kind, wording, task, who asked or when it came up (an empty value clears)")
+    .option("-k, --kind <kind>", "decide, try, block or todo")
+    .option("--title <text>", "new title")
+    .option("-b, --body <text>", "new body")
+    .option("-t, --task <task>", "task within the project")
+    .option("--from <who>", "who asked")
+    .option("--session <id>", "the agent session that asked")
+    .option("--since <date>", "when the matter first came up (YYYY-MM-DD)")
+    .option("--json", "print the card as JSON")
+    .action((id, o) => {
+    const card = editCard(id, { kind: o.kind, title: o.title, body: o.body, task: o.task, from: o.from, session: o.session, since: o.since });
+    if (o.json)
+        print(card);
+    else
+        process.stdout.write(cardLine(card) + "\n");
+});
+program
+    .command("goto <target>")
+    .description("open the agent session behind a card, a pull request (URL, owner/repo#N, repo#N) or a session id in the Claude desktop app")
+    .option("--copy", "also put a line about the card on the clipboard, to paste into that session")
+    .option("--print", "print the link instead of opening it")
+    .action((target, o) => {
+    const g = resolveGoto(target, fold(readEvents()));
+    if (o.copy && g.card) {
+        const line = cardContextLine(g.card);
+        try {
+            execFileSync("pbcopy", { input: line });
+        }
+        catch {
+            process.stderr.write(`parawatch: could not copy to the clipboard; the line is: ${line}\n`);
+        }
+    }
+    if (!g.url)
+        throw new UserError(`${g.name} is not a Claude desktop session. In a terminal: claude --resume ${g.session}`);
+    if (o.print) {
+        process.stdout.write(g.url + "\n");
+        return;
+    }
+    execFileSync("open", [g.url]);
+    process.stdout.write(`Opened ${g.name}${g.desktop?.archived ? " (archived)" : ""}\n`);
+});
+program
+    .command("answer <card>")
+    .description("answer a card (this is what wakes the waiting agent)")
+    .option("-c, --choice <n>", "chosen option, 1-based", int)
+    .option("-m, --comment <text>", "free text")
+    .option("--attach <file>", "a screenshot or file (repeatable)", collect)
+    .option("--by <who>", "who answers", "human")
+    .action((id, o) => answerCard(id, { choice: o.choice, comment: o.comment, attach: o.attach, by: o.by }));
+program
+    .command("comment <card> <text>")
+    .description("add a comment to a card")
+    .option("--by <who>", "who comments (use 'human' to wake the agent)", "agent")
+    .action((id, text, o) => commentCard(id, text, o.by));
+program
+    .command("close <card>")
+    .description("close a card once it has been acted on")
+    .option("-n, --note <text>", "what was done")
+    .action((id, o) => closeCard(id, o.note));
+program
+    .command("show <card>")
+    .description("show one card with its answers")
+    .option("--json", "JSON output")
+    .action((id, o) => {
+    const card = fold(readEvents()).cards.get(id);
+    if (!card)
+        throw new UserError(`no card "${id}"`);
+    if (o.json) {
+        print(card);
+        return;
+    }
+    const waits = card.status === "closed" ? [] : listenersFor(card, listeners());
+    const delivery = card.status === "closed"
+        ? ""
+        : waits.length
+            ? `\nDelivery: an agent is waiting (${waits.map((l) => l.consumer).join(", ")}); an answer wakes it now.`
+            : "\nDelivery: no agent is waiting; an answer is kept until the agent next checks (its next turn, or its next wait).";
+    process.stdout.write(cardDetail(card) + delivery + "\n");
+});
+program
+    .command("cards")
+    .description("list cards (open and answered by default)")
+    .option("-p, --project <name>", "only this project")
+    .option("-a, --all", "include closed cards")
+    .option("--json", "JSON output")
+    .action((o) => {
+    const cards = [...fold(readEvents()).cards.values()].filter((c) => (o.all || c.status !== "closed") && (!o.project || c.project === o.project));
+    if (o.json)
+        print({ v: SCHEMA_VERSION, cards });
+    else
+        process.stdout.write(cards.length ? cardRows(cards, view()).join("\n") + "\n" : "No cards.\n");
+});
+// ------------------------------------------------------------------ inbox
+function inboxOptions(c) {
+    return c
+        .option("-p, --project <name>", "only answers for this project")
+        .option("--card <id>", "only answers to this card")
+        .option("--as <consumer>", "cursor name (defaults to the project)")
+        .option("--json", "JSON output");
+}
+inboxOptions(program.command("wait").description("block until the human answers, print the answers and exit"))
+    .option("--timeout <seconds>", "give up after this long (exit code 2); 0 waits forever", int, 0)
+    .action(async (o) => {
+    startListening({ consumer: consumerName(o), project: o.project, card: o.card, session: currentSession() });
+    // while waiting, keep GitHub fresh so news on linked pull requests wakes this wait
+    const tick = () => void refreshGithub();
+    tick();
+    const timer = setInterval(tick, 60_000);
+    timer.unref();
+    const items = await waitInbox(consumerName(o), { project: o.project, card: o.card }, o.timeout * 1000);
+    clearInterval(timer);
+    if (!items.length) {
+        process.exitCode = 2;
+        return;
+    }
+    if (o.json)
+        print({ v: SCHEMA_VERSION, items });
+    else
+        process.stdout.write(items.map(inboxLine).join("\n") + "\n");
+});
+inboxOptions(program.command("inbox").description("print unhandled answers without waiting"))
+    .option("--peek", "do not mark them as seen")
+    .action((o) => {
+    const items = readInbox(consumerName(o), { project: o.project, card: o.card }, !o.peek);
+    if (o.json)
+        print({ v: SCHEMA_VERSION, items });
+    else if (items.length)
+        process.stdout.write(items.map(inboxLine).join("\n") + "\n");
+});
+program
+    .command("watch")
+    .description("stream every new event as one JSON line (for plugins and monitors)")
+    .option("--from <seq>", "replay events after this sequence number first", int)
+    .action(async (o) => {
+    followEvents(print, o.from);
+    await new Promise(() => { });
+});
+// ------------------------------------------------------------------ runs
+program
+    .command("runs")
+    .description("agents seen in their logs, grouped by project")
+    .option("-p, --project <name>", "only this project")
+    .option("--since <hours>", "look at logs touched in the last N hours", int, 6)
+    .option("-a, --all", "include runs that ended a while ago")
+    .option("--runtime <name>", "only this adapter (repeatable)", collect)
+    .option("--every", "list each run of a scheduled task instead of one row per task")
+    .option("-w, --wide", "show runtime and ids")
+    .option("--json", "JSON output")
+    .action((o) => {
+    const runs = collectRuns(fold(readEvents()), { sinceHours: o.since, project: o.project, includeEnded: o.all, runtimes: o.runtime, keepRepeats: o.every });
+    if (o.json)
+        print({ v: SCHEMA_VERSION, runs });
+    else
+        process.stdout.write((runs.length ? runsTree(runs, view({ wide: o.wide, all: o.all })) : "Nothing running.") + "\n");
+});
+const run = program.command("run").description("report a job that leaves no agent log");
+run
+    .command("start <title>")
+    .requiredOption("-p, --project <name>", "project")
+    .option("-t, --task <task>", "task")
+    .option("--parent <id>", "the run that started this one (defaults to the calling session)")
+    .option("--heartbeat <seconds>", "count the run as stalled after this long without a beat, a note or log output", int)
+    .option("--log <file>", "a log file the job writes; each change counts as a beat")
+    .action((title, o) => {
+    process.stdout.write(startRun({ title, project: o.project, task: o.task, parent: o.parent ?? currentSession(), heartbeat: o.heartbeat, log: o.log }) + "\n");
+});
+run.command("note <id> <text>").description("say how it is going (also counts as a beat)").action((id, text) => noteRun(id, text));
+run.command("beat <id>").description("say it is still alive").action((id) => beatRun(id));
+run
+    .command("end <id>")
+    .option("--failed", "it failed")
+    .option("-n, --note <text>", "how it ended")
+    .action((id, o) => endRun(id, o.failed ? "failed" : "done", o.note));
+program
+    .command("claim [session]")
+    .description("say which project and task an agent session works on (id prefix, 6+ characters; defaults to the calling session)")
+    .option("-p, --project <name>", "project (may be left out once the session has claimed one)")
+    .option("-t, --task <task>", "task: a ticket key, a PR, a short name")
+    .option("--role <role>", "for example lead or worker")
+    .option("--title <title>", "name to show")
+    .option("--kind <kind>", "'scheduled' for a session a schedule starts again and again")
+    .option("--done <summary>", "the work is finished; one line on how it ended")
+    .action((session, o) => {
+    const id = session ?? currentSession();
+    if (!id)
+        throw new UserError("no session id given and none found in the environment (CLAUDE_CODE_SESSION_ID, CODEX_THREAD_ID)");
+    if (o.kind !== undefined && o.kind !== "scheduled")
+        throw new UserError("--kind can only be 'scheduled'");
+    const c = claimSession({ session: id, project: o.project, task: o.task, role: o.role, title: o.title, kind: o.kind, done: o.done });
+    process.stdout.write(`${id.slice(0, 8)} → ${c.project}${c.task ? ` / ${c.task}` : ""}${c.role ? ` (${c.role})` : ""}${c.done ? " · done" : ""}\n`);
+});
+// ------------------------------------------------------------------ pull requests
+const pr = program.command("pr").description("pull requests and what they wait on (reads GitHub through gh)");
+pr.command("link <pr>")
+    .description("say this pull request belongs to the calling session: news on it wakes the session's wait")
+    .option("-p, --project <name>", "project (defaults to the session's claim)")
+    .option("-t, --task <task>", "task (defaults to the session's claim)")
+    .option("--session <id>", "the owning session (defaults to the calling session)")
+    .action((ref, o) => {
+    const r = resolvePrRef(ref);
+    const session = o.session ?? currentSession();
+    linkPr({ pr: r, session, project: o.project, task: o.task });
+    process.stdout.write(`${r.repo}#${r.number} → ${session ? session.slice(0, 8) : o.project ?? "no session"}\n`);
+});
+pr.command("unlink <pr>")
+    .description("forget which session owns a pull request")
+    .action((ref) => unlinkPr(resolvePrRef(ref).key));
+pr.command("list")
+    .description("open pull requests you wrote or are asked to review, with what each waits on")
+    .option("-p, --project <name>", "only this project")
+    .option("--offline", "do not read GitHub, show the last reading")
+    .option("--json", "JSON output")
+    .action(async (o) => {
+    if (!o.offline)
+        await refreshGithub();
+    const state = fold(readEvents());
+    const runs = collectRuns(state, { sinceHours: 72 });
+    let prs = prViews(readCache(), state, runs);
+    if (o.project)
+        prs = prs.filter((p) => p.project === o.project);
+    if (o.json)
+        print({ v: SCHEMA_VERSION, prs });
+    else
+        process.stdout.write(prs.length ? prRows(prs, view()).join("\n") + "\n" : githubNote() ?? "No open pull requests.\n");
+});
+pr.command("sync")
+    .description("read GitHub now")
+    .action(async () => {
+    const c = await syncGithub({ state: fold(readEvents()), force: true });
+    if (c.error)
+        process.stderr.write(`parawatch: ${c.error}\n`);
+    process.stdout.write(`${c.prs.filter((p) => p.state === "open").length} open pull requests on ${(c.hosts ?? []).join(", ") || "no host"}\n`);
+});
+pr.command("event <pr> <change>")
+    .description("record news another tool saw on a pull request (a merge bot, a ticket system); it wakes the owner like GitHub's own")
+    .option("-m, --text <text>", "what happened")
+    .option("--by <who>", "who did it")
+    .action((ref, change, o) => prEvent(resolvePrRef(ref), change, { text: o.text, by: o.by }));
+function githubNote() {
+    if (!githubConfig().enabled)
+        return "GitHub is turned off in config.json.\n";
+    const c = readCache();
+    if (c.hosts && !c.hosts.length)
+        return "GitHub: gh is not installed or not signed in (gh auth login).\n";
+    return undefined;
+}
+program
+    .command("digest")
+    .description("what each session did on a day: work claimed, cards, jobs, pull request news, how it ended")
+    .option("-d, --date <YYYY-MM-DD>", "the day (default: today)")
+    .option("--json", "JSON output")
+    .action((o) => {
+    const d = digest(o.date ?? localDate());
+    if (o.json)
+        print({ v: SCHEMA_VERSION, ...d });
+    else
+        process.stdout.write(digestText(d) + "\n");
+});
+// ------------------------------------------------------------------ status
+program
+    .command("status")
+    .description("everything at a glance: what needs you, what waits on others, then what is running")
+    .option("-p, --project <name>", "only this project")
+    .option("--since <hours>", "look at logs touched in the last N hours", int, 6)
+    .option("--offline", "do not read GitHub, show the last reading")
+    .option("-w, --wide", "show runtime and ids")
+    .option("--json", "JSON output")
+    .action(async (o) => {
+    if (!o.offline)
+        await refreshGithub();
+    const snap = snapshot({ sinceHours: o.since, project: o.project });
+    if (o.json) {
+        print(snap);
+        return;
+    }
+    const { cards, runs } = snap;
+    const prs = snap.prs ?? [];
+    const v = view({ wide: o.wide });
+    const now = Date.now();
+    const head = (title, n, ...extra) => v.color ? `\x1b[1m${title}\x1b[0m  \x1b[2m${n}${extra.join("")}\x1b[0m` : `${title}  ${n}${extra.join("")}`;
+    const open = cards.filter((c) => c.status === "open" && c.kind !== "todo");
+    const todo = cards.filter((c) => c.status === "open" && c.kind === "todo");
+    const answered = cards.filter((c) => c.status === "answered");
+    const asking = runs.filter((r) => r.asks);
+    const reviews = prs.filter((p) => p.reviewRequested && !p.mine);
+    const waiting = prs.filter((p) => !(p.reviewRequested && !p.mine));
+    const ls = snap.listeners ?? [];
+    const out = [];
+    out.push(head("NEEDS YOU", open.length || "nothing"));
+    out.push(...cardRows(open, v, now, "  "));
+    if (asking.length) {
+        out.push("", head("ASKED IN CHAT, NO CARD", asking.length, "  (read from the log)"));
+        out.push(...askRows(asking, v, now, "  "));
+    }
+    if (reviews.length) {
+        out.push("", head("REVIEWS ASKED OF YOU", reviews.length));
+        out.push(...prRows(reviews, v, now, "  "));
+    }
+    if (todo.length) {
+        out.push("", head("TO DO, NOTHING WAITS ON IT", todo.length));
+        out.push(...cardRows(todo, v, now, "  "));
+    }
+    if (answered.length) {
+        const notes = {};
+        for (const c of answered)
+            if (!listenersFor(c, ls).length)
+                notes[c.id] = "no agent waiting";
+        out.push("", head("ANSWERED, WAITING FOR THE AGENT", answered.length));
+        out.push(...cardRows(answered, v, now, "  ", notes));
+    }
+    if (waiting.length) {
+        const stuck = waiting.filter((p) => p.stalled).length;
+        out.push("", head("WAITING ON OTHERS", waiting.length, stuck ? ` · ${stuck} stuck` : ""));
+        out.push(...prRows(waiting, v, now, "  "));
+    }
+    const working = runs.filter((r) => r.state === "working" || r.state === "waiting").length;
+    out.push("", head("AGENTS", runs.length ? `${working} working` : "nothing running"));
+    if (runs.length)
+        out.push(runsTree(runs, v));
+    if (snap.github?.error && snap.github.enabled)
+        out.push("", v.color ? `\x1b[2mGitHub: ${snap.github.error}\x1b[0m` : `GitHub: ${snap.github.error}`);
+    process.stdout.write(out.join("\n") + "\n");
+});
+// ------------------------------------------------------------------ skill
+const skill = program.command("skill").description("the agent skill that teaches agents to use parawatch");
+skill
+    .command("path")
+    .description("print where the skill lives")
+    .action(() => {
+    process.stdout.write(skillSource() + "\n");
+});
+skill
+    .command("install")
+    .description("link the skill into Claude Code (~/.claude/skills) and Codex (~/.codex/skills)")
+    .option("--runtime <name>", "only this runtime: claude-code or codex (repeatable)", collect)
+    .option("--force", "replace a folder that is already there")
+    .action((o) => {
+    for (const r of installSkill(skillTargets(), { only: o.runtime, force: o.force })) {
+        process.stdout.write(`${r.runtime.padEnd(12)} ${r.result.padEnd(15)} ${r.path}${r.note ? `  (${r.note})` : ""}\n`);
+    }
+});
+// ------------------------------------------------------------------ setup
+const project = program.command("project").description("projects you work on");
+project
+    .command("add <name> [paths...]")
+    .description("register a project and the checkouts or folders it lives in")
+    .action((name, paths) => addProject(name, paths.length ? paths : [process.cwd()]));
+project.command("remove <name>").action((name) => removeProject(name));
+project
+    .command("list")
+    .option("--json", "JSON output")
+    .action((o) => {
+    const ps = [...fold(readEvents()).projects.values()];
+    if (o.json)
+        print({ v: SCHEMA_VERSION, projects: ps });
+    else
+        process.stdout.write(ps.map((p) => `${p.name}  ${p.paths.join(", ")}`).join("\n") + (ps.length ? "\n" : "No projects.\n"));
+});
+program
+    .command("init")
+    .description("add parawatch instructions for agents to an instruction file")
+    .option("-f, --file <path>", "file to write", "AGENTS.md")
+    .option("-p, --project <name>", "project name to put in the examples")
+    .action((o) => {
+    const changed = writeInstructions(o.file, o.project);
+    process.stdout.write(changed ? `Updated ${o.file}\n` : `${o.file} already up to date\n`);
+});
+program
+    .command("hook <runtime>")
+    .description("hook entry point; 'claude-code' reads the hook JSON on stdin")
+    .option("-p, --project <name>", "project, when it cannot be told from the session")
+    .action((runtime, o) => {
+    if (runtime !== "claude-code")
+        throw new UserError(`no hook for "${runtime}"`);
+    let input = {};
+    try {
+        input = JSON.parse(fs.readFileSync(0, "utf8") || "{}");
+    }
+    catch {
+        input = {};
+    }
+    const text = hookContext(input, o.project);
+    if (!text)
+        return;
+    if (input.hook_event_name)
+        print({ hookSpecificOutput: { hookEventName: input.hook_event_name, additionalContext: text } });
+    else
+        process.stdout.write(text + "\n");
+});
+program.parseAsync().catch((err) => {
+    if (err instanceof UserError) {
+        process.stderr.write(`parawatch: ${err.message}\n`);
+        process.exit(1);
+    }
+    throw err;
+});
+//# sourceMappingURL=cli.js.map

package/dist/core/desktop.js

@@ -0,0 +1,102 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { parsePrRef } from "./github.js";
+import { sessionTitle, UserError } from "./ops.js";
+/**
+ * Where the Claude desktop app keeps its Code sessions: one JSON file per session, named
+ * `local_<id>.json`, holding the CLI session id the app runs (`cliSessionId`).
+ */
+export function desktopSessionsDir() {
+    return (process.env.PARAWATCH_CLAUDE_DESKTOP_DIR ||
+        path.join(os.homedir(), "Library", "Application Support", "Claude", "claude-code-sessions"));
+}
+function* sessionFiles(dir, depth = 0) {
+    let entries;
+    try {
+        entries = fs.readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const e of entries) {
+        const p = path.join(dir, e.name);
+        if (e.isDirectory() && depth < 3)
+            yield* sessionFiles(p, depth + 1);
+        else if (e.isFile() && /^local_[A-Za-z0-9-]+\.json$/.test(e.name))
+            yield p;
+    }
+}
+/** The desktop app session running a CLI session (full id or a prefix of 6+ characters). */
+export function findDesktopSession(cliSession, dir = desktopSessionsDir()) {
+    if (cliSession.length < 6)
+        return undefined;
+    let best;
+    for (const file of sessionFiles(dir)) {
+        let d;
+        try {
+            d = JSON.parse(fs.readFileSync(file, "utf8"));
+        }
+        catch {
+            continue;
+        }
+        const ids = [d.cliSessionId, d.lastAssistantCliSessionId].filter((x) => typeof x === "string");
+        if (!ids.some((x) => x.startsWith(cliSession)))
+            continue;
+        const s = {
+            id: typeof d.sessionId === "string" ? d.sessionId : path.basename(file, ".json"),
+            cliSessionId: ids[0],
+            title: typeof d.title === "string" ? d.title : undefined,
+            cwd: typeof d.cwd === "string" ? d.cwd : undefined,
+            archived: d.isArchived === true,
+            lastActivityAt: typeof d.lastActivityAt === "number" ? d.lastActivityAt : 0,
+        };
+        // prefer a live session, then the most recent one
+        if (!best || (best.archived && !s.archived) || (best.archived === s.archived && s.lastActivityAt > best.lastActivityAt))
+            best = s;
+    }
+    return best;
+}
+/** A link that opens the session in the Claude desktop app. */
+export function desktopSessionUrl(s) {
+    return `claude://code/continue?session=${encodeURIComponent(s.id)}&source=parawatch`;
+}
+/** The session that owns a pull request: by URL, `owner/repo#N`, or `#N` / `repo#N` when only one matches. */
+function prSession(target, state) {
+    const ref = parsePrRef(target);
+    if (ref) {
+        const link = state.prLinks.get(ref.key);
+        if (!link)
+            throw new UserError(`no session owns ${ref.repo}#${ref.number}; link it from that session with: parawatch pr link ${ref.url}`);
+        if (!link.session)
+            throw new UserError(`${ref.repo}#${ref.number} is linked to a project but not to a session`);
+        return link.session;
+    }
+    const m = /^(?:([^/\s#]+))?#(\d+)$/.exec(target.trim());
+    if (!m)
+        return undefined;
+    const hits = [...state.prLinks.values()].filter((l) => l.pr.number === Number(m[2]) && (!m[1] || l.pr.repo.split("/")[1] === m[1]));
+    if (!hits.length)
+        throw new UserError(`no session owns a pull request ${target}`);
+    if (hits.length > 1)
+        throw new UserError(`${target} matches ${hits.map((h) => h.pr.repo + "#" + h.pr.number).join(", ")}; give owner/repo#N`);
+    if (!hits[0].session)
+        throw new UserError(`${target} is linked to a project but not to a session`);
+    return hits[0].session;
+}
+/** Where `goto` leads for a card id, a pull request, or a session id (prefix). */
+export function resolveGoto(target, state) {
+    const card = state.cards.get(target);
+    const session = card ? card.session : (prSession(target, state) ?? target);
+    if (!session) {
+        throw new UserError(`card ${target} does not say which session opened it (set one with: parawatch edit ${target} --session <id>)`);
+    }
+    const desktop = findDesktopSession(session);
+    const name = sessionTitle(state.claims, session) ?? desktop?.title ?? session.slice(0, 8);
+    return { name, session, card, desktop, url: desktop ? desktopSessionUrl(desktop) : undefined };
+}
+/** A line to paste into the session so it knows which card the human means. */
+export function cardContextLine(card) {
+    return `About parawatch card ${card.id} ("${card.title}"): `;
+}
+//# sourceMappingURL=desktop.js.map