@armanckeser/downstream 0.0.0-stage → 0.1.0

package/dist/server/home.js

@@ -0,0 +1,325 @@
+// The home page's server side: the inbox for the account you're looking
+// through (cached, refreshed in the background), sorted into the matrix with
+// your choices applied, and starting the agent on a pull request.
+import { Hono } from "hono";
+import { streamSSE } from "hono/streaming";
+import { z } from "zod";
+import { arrange, MOVES, Quadrant, toItems, withTouches } from "../domain/inbox.js";
+import { prKey } from "../domain/agent.js";
+import { nextMove } from "../domain/next-move.js";
+import { accounts } from "./gh.js";
+import { fetchAvatar, fetchDetail, fetchPrs, fetchTouches } from "./github.js";
+import { promptFor, stalePrompt } from "./prompts.js";
+import { decide, GitHubRefused, NotOffered, StaleDecision } from "./stale.js";
+import { ActionError } from "./actions.js";
+const STALE_AFTER_MS = 60_000;
+/** One account's PRs, fetched at most once at a time, kept until the next fetch lands. */
+class InboxCache {
+    snapshots = new Map();
+    inflight = new Map();
+    errors = new Map();
+    onChange;
+    constructor(onChange) {
+        this.onChange = onChange;
+    }
+    get(account) {
+        return this.snapshots.get(account) ?? null;
+    }
+    error(account) {
+        return this.errors.get(account) ?? null;
+    }
+    refreshing(account) {
+        return this.inflight.has(account);
+    }
+    /** Fetch if never fetched or stale (or `force`); returns once the fetch is done. */
+    refresh(account, force = false) {
+        const snap = this.get(account);
+        const fresh = snap && Date.now() - Date.parse(snap.at) < STALE_AFTER_MS;
+        if (fresh && !force)
+            return Promise.resolve();
+        const running = this.inflight.get(account);
+        if (running)
+            return running;
+        // Without the activity feed the inbox still works, just without knowing your focus.
+        const p = Promise.all([fetchPrs(account), fetchTouches(account).catch(() => [])])
+            .then(([prs, touches]) => {
+            this.snapshots.set(account, { prs: withTouches(prs, touches), touches, at: new Date().toISOString() });
+            this.errors.delete(account);
+        })
+            .catch((e) => {
+            this.errors.set(account, e.message.split("\n").slice(0, 2).join(" "));
+        })
+            .finally(() => {
+            this.inflight.delete(account);
+            this.onChange();
+        });
+        this.inflight.set(account, p);
+        this.onChange();
+        return p;
+    }
+}
+export function homeRoutes(deps) {
+    const { home, repos, agents } = deps;
+    const app = new Hono();
+    const cache = new InboxCache(() => home.changed());
+    let known = null;
+    const accountList = () => (known ??= accounts());
+    const avatars = new Map();
+    const avatarOf = (login) => {
+        if (!avatars.has(login)) {
+            avatars.set(login, null);
+            void fetchAvatar(login).then((url) => {
+                avatars.set(login, url);
+                if (url)
+                    home.changed();
+            });
+        }
+        return avatars.get(login) ?? null;
+    };
+    const currentAccount = () => {
+        const chosen = home.account();
+        const list = accountList();
+        return chosen && list.includes(chosen) ? chosen : (list[0] ?? null);
+    };
+    const items = (account) => toItems(cache.get(account)?.prs ?? []);
+    function sessions() {
+        const out = {};
+        const at = (key) => (out[key] ??= { agent: null, review: null });
+        for (const v of agents.views()) {
+            // What the agent said, never the commands it ran: those are its business, not yours.
+            const said = [...v.activity].reverse().find((a) => a.kind === "text");
+            const line = said?.kind === "text" ? said.text.split("\n")[0].slice(0, 140) : null;
+            at(prKey(v.repo, v.pr)).agent = { status: v.status, line, approvals: v.approvals.length };
+        }
+        for (const repo of repos.withReviews()) {
+            if (!repo.nameWithOwner)
+                continue;
+            const seen = new Set();
+            for (const review of repo.store.listReviews()) {
+                if (review.pr === null || seen.has(review.pr))
+                    continue;
+                seen.add(review.pr);
+                const state = repo.store.state(review.id);
+                if (!state)
+                    continue;
+                at(prKey(repo.nameWithOwner, review.pr)).review = { path: `/r/${repo.id}?review=${review.id}`, title: review.title, move: nextMove(state, new Set(state.visited)) };
+            }
+        }
+        return out;
+    }
+    function view() {
+        const account = currentAccount();
+        const snap = account ? cache.get(account) : null;
+        if (account)
+            void cache.refresh(account);
+        return {
+            accounts: accountList().map((login) => ({ login, avatar: avatarOf(login) })),
+            account,
+            inbox: snap && account ? arrange(items(account), home.choices(account), new Date(), snap.touches) : null,
+            fetchedAt: snap?.at ?? null,
+            refreshing: account ? cache.refreshing(account) : false,
+            error: account ? cache.error(account) : "gh isn't logged in to any GitHub account. Run `gh auth login`.",
+            sessions: sessions(),
+        };
+    }
+    /** A PR in the stale sweep, or a 404 the browser shows as "refresh". */
+    function staleItem(account, key) {
+        const inbox = arrange(items(account), home.choices(account), new Date(), cache.get(account)?.touches ?? []);
+        const item = inbox.stale.find((i) => i.key === key);
+        if (!item)
+            throw new ActionError("That pull request isn't stale any more. Refresh.", 404);
+        return item;
+    }
+    /**
+     * Start (or resume) the agent on an item. Returns where the browser should go.
+     * `stale` asks for a recommendation instead of the item's move.
+     */
+    async function start(account, key, ask = "move") {
+        const item = ask === "stale" ? staleItem(account, key) : items(account).find((i) => i.key === key);
+        if (!item)
+            throw new ActionError("That pull request isn't in your inbox any more. Refresh.", 404);
+        const pr = item.lead;
+        const opens = MOVES[item.move.kind].opens;
+        if (ask === "move" && opens === "github")
+            return { url: pr.url };
+        const agentKey = prKey(pr.repo, pr.number);
+        const existing = sessions()[agentKey];
+        const where = existing?.review ? { path: existing.review.path } : { path: `/s/${encodeURIComponent(agentKey)}` };
+        if (agents.live(agentKey))
+            return where;
+        const root = repos.find(pr.repo) ?? (await repos.clone(pr.repo, account));
+        repos.register(root);
+        const prompt = ask === "stale" ? stalePrompt(item) : promptFor(item);
+        if (!prompt)
+            return { url: pr.url };
+        const previous = home.launch(pr.repo, pr.number);
+        home.putLaunch({ account, repo: pr.repo, pr: pr.number, root, sessionId: null });
+        const resumeId = previous?.root === root ? previous.sessionId : null;
+        agents.start({ key: agentKey, repo: pr.repo, pr: pr.number, root, account, prompt: resumeId ? "I'm back. Pick up where we left off; run `downstream wait` if you're mid-review." : prompt, resumeId });
+        return where;
+    }
+    // The session id appears a moment after start; keep it so a later visit can resume.
+    agents.bus.on("changed", (key) => {
+        const v = agents.view(key);
+        if (v?.sessionId) {
+            const launch = home.launch(v.repo, v.pr);
+            if (launch && launch.sessionId !== v.sessionId)
+                home.putLaunch({ ...launch, sessionId: v.sessionId });
+        }
+        home.changed();
+    });
+    // A message you write in a review reaches an agent that went idle.
+    const WAKES = new Set(["ask", "note.replied", "note.added", "review.verdict"]);
+    repos.bus.on("event", (repo, reviewId, e) => {
+        home.changed();
+        if (e.actor !== "user" || !WAKES.has(e.type) || !repo.nameWithOwner)
+            return;
+        const pr = repo.store.review(reviewId)?.pr;
+        if (pr != null)
+            agents.nudge(prKey(repo.nameWithOwner, pr));
+    });
+    app.get("/home", async (c) => {
+        const account = currentAccount();
+        if (account && !cache.get(account))
+            await cache.refresh(account);
+        return c.json(view());
+    });
+    // Details change with every push; a minute keeps j/k through the list instant without going stale.
+    const details = new Map();
+    app.get("/prs/:owner/:name/:number", async (c) => {
+        const account = currentAccount();
+        if (!account)
+            return c.json({ error: "No GitHub account." }, 400);
+        const repo = `${c.req.param("owner")}/${c.req.param("name")}`;
+        const number = Number(c.req.param("number"));
+        const key = `${account}:${repo}#${number}`;
+        let hit = details.get(key);
+        if (!hit || Date.now() - hit.at > STALE_AFTER_MS) {
+            hit = { at: Date.now(), detail: fetchDetail(account, repo, number) };
+            details.set(key, hit);
+            hit.detail.catch(() => details.delete(key));
+        }
+        try {
+            return c.json(await hit.detail);
+        }
+        catch (e) {
+            return c.json({ error: e.message.split("\n")[0] }, 502);
+        }
+    });
+    app.get("/agents/:key", (c) => {
+        const v = agents.view(c.req.param("key"));
+        return v ? c.json(v) : c.json({ error: "No agent session for this pull request." }, 404);
+    });
+    const HomeActions = {
+        "home.account": z.object({ login: z.string() }),
+        "home.choose": z.object({ key: z.string(), quadrant: Quadrant.nullable() }),
+        "home.refresh": z.object({}),
+        "home.start": z.object({ key: z.string() }),
+        "stale.decide": z.object({ key: z.string(), decision: StaleDecision }),
+        "stale.ask": z.object({ key: z.string() }),
+        "agent.send": z.object({ key: z.string(), text: z.string().min(1) }),
+        "agent.decide": z.object({ key: z.string(), approvalId: z.string(), allow: z.boolean() }),
+        "agent.handoff": z.object({ key: z.string() }),
+    };
+    app.post("/home/actions/:name", async (c) => {
+        const name = c.req.param("name");
+        const schema = HomeActions[name];
+        if (!schema)
+            return c.json({ error: `Unknown action ${name}` }, 404);
+        const input = schema.parse((await c.req.json().catch(() => ({}))).input ?? {});
+        const account = currentAccount();
+        switch (name) {
+            case "home.account": {
+                const { login } = input;
+                if (!accountList().includes(login))
+                    throw new ActionError(`gh isn't logged in as ${login}.`);
+                home.setAccount(login);
+                void cache.refresh(login);
+                return c.json({ ok: true });
+            }
+            case "home.choose": {
+                if (!account)
+                    throw new ActionError("No GitHub account.");
+                const { key, quadrant } = input;
+                home.choose(account, key, quadrant);
+                return c.json({ ok: true });
+            }
+            case "home.refresh":
+                if (account)
+                    await cache.refresh(account, true);
+                return c.json({ ok: true });
+            case "home.start": {
+                if (!account)
+                    throw new ActionError("No GitHub account.");
+                return c.json(await start(account, input.key));
+            }
+            case "stale.decide": {
+                if (!account)
+                    throw new ActionError("No GitHub account.");
+                const { key, decision } = input;
+                try {
+                    await decide(account, staleItem(account, key), decision, () => home.choose(account, key, "hidden"));
+                }
+                catch (e) {
+                    if (e instanceof NotOffered)
+                        throw new ActionError(e.message, 422);
+                    if (e instanceof GitHubRefused)
+                        throw new ActionError(`GitHub refused: ${e.message}`, 502);
+                    throw e;
+                }
+                // The hide shows at once; what GitHub now says arrives with the next fetch.
+                void cache.refresh(account, true);
+                return c.json({ ok: true });
+            }
+            case "stale.ask": {
+                if (!account)
+                    throw new ActionError("No GitHub account.");
+                return c.json(await start(account, input.key, "stale"));
+            }
+            case "agent.send": {
+                const { key, text } = input;
+                agents.send(key, text);
+                return c.json({ ok: true });
+            }
+            case "agent.decide": {
+                const { key, approvalId, allow } = input;
+                agents.decide(key, approvalId, allow);
+                return c.json({ ok: true });
+            }
+            case "agent.handoff":
+                return c.json({ command: await agents.handOff(input.key) });
+        }
+    });
+    /** Live updates for the home page and agent panels: "home" to refetch, "agent" with a session's new state. */
+    app.get("/events", (c) => streamSSE(c, async (stream) => {
+        let open = true;
+        let timer = null;
+        const onHome = () => {
+            if (timer || !open)
+                return;
+            timer = setTimeout(() => {
+                timer = null;
+                if (open)
+                    void stream.writeSSE({ event: "home", data: "{}" });
+            }, 150);
+        };
+        const onAgent = (key) => {
+            const v = agents.view(key);
+            if (open && v)
+                void stream.writeSSE({ event: "agent", data: JSON.stringify(v) });
+        };
+        home.bus.on("changed", onHome);
+        agents.bus.on("changed", onAgent);
+        stream.onAbort(() => {
+            open = false;
+            home.bus.off("changed", onHome);
+            agents.bus.off("changed", onAgent);
+        });
+        while (open) {
+            await stream.sleep(25_000);
+            if (open)
+                void stream.writeSSE({ event: "ping", data: "{}" });
+        }
+    }));
+    return app;
+}

package/dist/server/install.js

@@ -0,0 +1,12 @@
+// Where Downstream's own files live. A clone runs the TypeScript sources in
+// place; a published copy (npx, npm install) sits under node_modules, where
+// Node won't strip types, so it runs the JavaScript compiled into dist/.
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+const compiledExtension = ".js";
+export const install = import.meta.url.endsWith(compiledExtension) ? "published" : "clone";
+/** Holds package.json, SKILL.md, bin/ and web/dist/. */
+export const packageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), install === "published" ? "../.." : "..");
+/** Holds cli/, server/ and domain/ in the form Node runs. */
+export const codeRoot = install === "published" ? path.join(packageRoot, "dist") : packageRoot;
+export const serverEntry = path.join(codeRoot, "server", install === "published" ? "main.js" : "main.ts");

package/dist/server/main.js

@@ -0,0 +1,228 @@
+// The Downstream server: one per machine. The home page lives at `/`; each
+// repository's reviews at `/r/<repo>/`, each with its own database in the repo.
+import { Hono } from "hono";
+import { streamSSE } from "hono/streaming";
+import { serve } from "@hono/node-server";
+import { serveStatic } from "@hono/node-server/serve-static";
+import { writeFileSync, rmSync, existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+import { z } from "zod";
+import { actions, ActionError } from "./actions.js";
+import { HomeStore, downstreamHome } from "./home-store.js";
+import { RepoRegistry } from "./repos.js";
+import { AgentHost } from "./agent-host.js";
+import { homeRoutes } from "./home.js";
+import { packageRoot } from "./install.js";
+const args = Object.fromEntries(process.argv
+    .slice(2)
+    .map((a) => a.match(/^--([^=]+)=(.*)$/))
+    .filter((m) => !!m)
+    .map((m) => [m[1], m[2]]));
+const port = Number(args.port ?? 4317);
+const dir = downstreamHome();
+const home = new HomeStore();
+const repos = new RepoRegistry(home);
+const agents = new AgentHost();
+const actorOf = (h) => (h === "agent" ? "agent" : "user");
+const app = new Hono();
+app.onError((err, c) => {
+    if (err instanceof ActionError)
+        return c.json({ error: err.message }, err.status);
+    if (err instanceof z.ZodError)
+        return c.json({ error: "Invalid input", issues: err.issues }, 400);
+    console.error(err);
+    return c.json({ error: err instanceof Error ? err.message : String(err) }, 500);
+});
+const startedAt = Date.now();
+app.get("/api/health", (c) => c.json({ ok: true, pid: process.pid, startedAt, home: dir }));
+/** The CLI registers the repository it runs in and gets back the id its reviews live under. */
+app.post("/api/repos", async (c) => {
+    const { root } = z.object({ root: z.string() }).parse(await c.req.json());
+    if (!existsSync(root))
+        throw new ActionError(`No such directory: ${root}`);
+    const repo = repos.register(root);
+    return c.json({ id: repo.id, root: repo.root, nameWithOwner: repo.nameWithOwner });
+});
+app.route("/api", homeRoutes({ home, repos, agents }));
+// --- one repository's reviews ---------------------------------------------------
+const review = new Hono();
+review.use(async (c, next) => {
+    const repo = repos.get(c.req.param("repo") ?? "");
+    if (!repo)
+        return c.json({ error: "Unknown repository. Run `downstream open` inside it." }, 404);
+    c.set("repo", repo);
+    await next();
+});
+const reviewOf = (c, q) => q || c.var.repo.store.currentReviewId();
+review.get("/reviews", (c) => c.json({ current: c.var.repo.store.currentReviewId(), reviews: c.var.repo.store.listReviews() }));
+review.get("/state", (c) => {
+    const id = reviewOf(c, c.req.query("review"));
+    if (!id)
+        return c.json({ error: "No review yet. Run `downstream open`." }, 404);
+    const state = c.var.repo.store.state(id);
+    return state ? c.json(state) : c.json({ error: `No review ${id}` }, 404);
+});
+review.get("/actions", (c) => c.json([...actions.values()].map((a) => ({ name: a.name, description: a.description, readOnly: !!a.readOnly, input: z.toJSONSchema(a.input, { io: "input", unrepresentable: "any" }) }))));
+review.post("/actions/:name", async (c) => {
+    const def = actions.get(c.req.param("name"));
+    if (!def)
+        return c.json({ error: `Unknown action ${c.req.param("name")}. GET /api/actions lists them.` }, 404);
+    const body = (await c.req.json().catch(() => ({})));
+    const actor = actorOf(c.req.header("x-downstream-actor"));
+    const repo = c.var.repo;
+    const reviewId = def.name === "review.open" ? "" : reviewOf(c, body.review);
+    if (def.name !== "review.open" && !reviewId)
+        throw new ActionError("No review yet. Run `downstream open` first.", 404);
+    if (actor === "agent")
+        repo.store.touchAgent();
+    const ctx = {
+        store: repo.store,
+        actor,
+        root: repo.root,
+        nameWithOwner: repo.nameWithOwner,
+        accountFor: (pr) => home.accountFor(repo.root, pr),
+        workspace: (id) => repo.workspace(id),
+        dropWorkspace: (id) => repo.dropWorkspace(id),
+        reviewId: reviewId ?? "",
+    };
+    const result = await def.run(ctx, def.input.parse(body.input ?? {}));
+    return c.json(result ?? { ok: true });
+});
+review.get("/frame", (c) => {
+    const id = reviewOf(c, c.req.query("review"));
+    const symbol = c.var.repo.store.symbol(id, c.req.query("symbol") ?? "");
+    if (!symbol)
+        return c.json({ error: "No such symbol" }, 404);
+    const frame = c.var.repo.workspace(id).frame(symbol);
+    return frame ? c.json(frame) : c.json({ error: `Can't read ${symbol.file}` }, 404);
+});
+review.get("/file", (c) => {
+    const id = reviewOf(c, c.req.query("review"));
+    const side = c.req.query("side") === "old" ? "old" : "new";
+    const text = c.var.repo.workspace(id).read(c.req.query("path") ?? "", side);
+    return text === null ? c.json({ error: "Not found" }, 404) : c.json({ text });
+});
+const pos = (c) => ({
+    file: c.req.query("file") ?? "",
+    line: Number(c.req.query("line")),
+    col: Number(c.req.query("col")),
+    side: (c.req.query("side") === "old" ? "old" : "new"),
+});
+review.get("/hover", (c) => {
+    const id = reviewOf(c, c.req.query("review"));
+    const p = pos(c);
+    return c.json(c.var.repo.workspace(id).hover(p.file, p.line, p.col, p.side));
+});
+review.get("/definition", (c) => {
+    const id = reviewOf(c, c.req.query("review"));
+    const p = pos(c);
+    return c.json(c.var.repo.workspace(id).definition(p.file, p.line, p.col, p.side, c.var.repo.store.symbols(id)));
+});
+review.get("/symbol-at", (c) => {
+    const id = reviewOf(c, c.req.query("review"));
+    return c.json(c.var.repo.workspace(id).symbolAt(c.req.query("file") ?? "", Number(c.req.query("line"))));
+});
+/** Live sync for the browser: every event, plus presence changes. */
+review.get("/events", (c) => {
+    const id = reviewOf(c, c.req.query("review"));
+    const { store } = c.var.repo;
+    return streamSSE(c, async (stream) => {
+        let open = true;
+        const onEvent = (reviewId, e) => {
+            if (open && reviewId === id)
+                void stream.writeSSE({ event: "change", data: JSON.stringify(e), id: String(e.id) });
+        };
+        const onPresence = () => {
+            if (open)
+                void stream.writeSSE({ event: "presence", data: JSON.stringify(store.presence()) });
+        };
+        store.bus.on("event", onEvent);
+        store.bus.on("presence", onPresence);
+        onPresence();
+        stream.onAbort(() => {
+            open = false;
+            store.bus.off("event", onEvent);
+            store.bus.off("presence", onPresence);
+        });
+        while (open) {
+            await stream.sleep(20_000);
+            if (open)
+                onPresence();
+        }
+    });
+});
+/**
+ * The agent's ear. Blocks until the user does something (replies, asks,
+ * resolves, gives a verdict, ends the session) and returns those events.
+ * While it blocks, the UI shows the agent as listening.
+ */
+const LISTEN_TO = new Set(["note.added", "note.replied", "note.status", "note.updated", "ask", "review.verdict", "review.done", "review.published", "symbol.annotated", "symbol.added", "edge.added", "steps.set"]);
+review.get("/wait", async (c) => {
+    const { store } = c.var.repo;
+    const id = reviewOf(c, c.req.query("review"));
+    if (!id)
+        return c.json({ error: "No review" }, 404);
+    const after = Number(c.req.query("after") ?? store.cursor(id));
+    const timeout = Math.min(Number(c.req.query("timeout") ?? 600), 3600) * 1000;
+    const pending = () => store.events(id, after, "user").filter((e) => LISTEN_TO.has(e.type));
+    const ready = pending();
+    if (ready.length) {
+        store.markRead(id, ready);
+        return c.json({ events: ready, cursor: store.cursor(id), timedOut: false });
+    }
+    store.waiterJoined();
+    try {
+        const events = await new Promise((resolve) => {
+            let timer;
+            const onEvent = (reviewId, e) => {
+                if (reviewId !== id || e.actor !== "user" || !LISTEN_TO.has(e.type))
+                    return;
+                // Let a burst (e.g. reply + resolve) land together.
+                setTimeout(() => finish(pending()), 400);
+            };
+            const finish = (evs) => {
+                clearTimeout(timer);
+                store.bus.off("event", onEvent);
+                c.req.raw.signal.removeEventListener("abort", onAbort);
+                resolve(evs);
+            };
+            const onAbort = () => finish([]);
+            timer = setTimeout(() => finish([]), timeout);
+            store.bus.on("event", onEvent);
+            c.req.raw.signal.addEventListener("abort", onAbort);
+        });
+        store.markRead(id, events);
+        return c.json({ events, cursor: store.cursor(id), timedOut: events.length === 0 });
+    }
+    finally {
+        store.waiterLeft();
+    }
+});
+app.route("/r/:repo/api", review);
+const dist = path.join(packageRoot, "web", "dist");
+if (existsSync(dist)) {
+    const rel = path.relative(process.cwd(), dist) || ".";
+    app.use("/*", serveStatic({ root: rel }));
+    // Read per request: a rebuilt UI points at new asset hashes, and a cached copy would load the old bundle.
+    app.get("*", (c) => c.html(readFileSync(path.join(dist, "index.html"), "utf8")));
+}
+else {
+    app.get("/", (c) => c.text("The web UI isn't built. Run `npm run build` in the downstream skill directory."));
+}
+const server = serve({ fetch: app.fetch, port, hostname: "127.0.0.1" }, (info) => {
+    const url = `http://127.0.0.1:${info.port}`;
+    writeFileSync(path.join(dir, "server.json"), JSON.stringify({ url, port: info.port, pid: process.pid }, null, 2));
+    console.log(`downstream listening on ${url}`);
+});
+const shutdown = () => {
+    try {
+        agents.stopAll();
+        rmSync(path.join(dir, "server.json"), { force: true });
+    }
+    finally {
+        server.close();
+        process.exit(0);
+    }
+};
+process.on("SIGINT", shutdown);
+process.on("SIGTERM", shutdown);

package/dist/server/prompts.js

@@ -0,0 +1,32 @@
+// The first message of an agent session Downstream starts, by the move you
+// pressed. From there the agent drives Downstream (or the repo) as usual.
+import path from "node:path";
+import { packageRoot } from "./install.js";
+const skillDir = packageRoot;
+/** What the agent is asked to do, by the move that was pressed. */
+const PROMPTS = {
+    review: ({ number, repo }) => reviewPrompt(number, repo),
+    rereview: ({ number, repo }) => `${reviewPrompt(number, repo)} I reviewed it before; start from what changed since my last review.`,
+    "address-feedback": ({ number, url }) => `Pull request #${number} (${url}) has review feedback I haven't addressed. Read every unresolved thread and the review comments (\`gh pr view ${number} --comments\`, and the review threads through \`gh api graphql\`). Work in a git worktree on the PR's branch so my current checkout is untouched. For each thread, tell me what you'd change and why; change code only once I agree.`,
+    "fix-checks": ({ number, url }) => `Checks are failing on pull request #${number} (${url}). Find the failing check and its log (\`gh pr checks ${number}\`), reproduce it locally in a git worktree on the PR's branch so my current checkout is untouched, and propose the fix before you push anything.`,
+    "resolve-conflicts": ({ number, url }) => `Pull request #${number} (${url}) conflicts with its base. In a git worktree on its branch, rebase onto the base (it may be part of a \`gh stack\`; if so use \`gh stack rebase\`), and walk me through each conflict before resolving it. Don't push until I say so.`,
+    "finish-draft": ({ number, url }) => `Pull request #${number} (${url}) is still a draft. Read the PR and its branch and tell me, in a short list, what's left before it's ready for review. Don't change anything yet.`,
+};
+function reviewPrompt(number, repo) {
+    return [
+        `Review pull request #${number} of ${repo} with me in Downstream.`,
+        `Downstream is a skill at ${skillDir}: read ${path.join(skillDir, "SKILL.md")} first and follow it.`,
+        `Wherever it says \${CLAUDE_SKILL_DIR}, use ${skillDir}. Start with \`node ${path.join(skillDir, "bin", "downstream.mjs")} open --pr ${number}\`.`,
+        "You're running inside Downstream: I read the review and your replies in its margin, so talk to me there and keep `downstream wait` running between turns.",
+    ].join(" ");
+}
+/** For a PR nobody has touched in weeks: a recommendation, with nothing posted. */
+export function stalePrompt(item) {
+    const { number, url, role } = item.lead;
+    const options = role === "author" ? "ask the reviewers to look, close it, or leave it" : "remove myself as a reviewer, ask the author whether it's still going, review it, or leave it";
+    return `Pull request #${number} (${url}) has had no activity for weeks. Read the description, the conversation and the review threads (\`gh pr view ${number} --comments\`, review threads through \`gh api graphql\`) and tell me in a few lines where it stands and whether I should ${options}. Don't post, push or change anything.`;
+}
+export function promptFor(item) {
+    const make = PROMPTS[item.move.kind];
+    return make ? make({ number: item.lead.number, repo: item.lead.repo, url: item.lead.url }) : null;
+}