@vincemakes/kiso-web 0.53.0 → 0.54.0

package/dist/main/agent.js

@@ -1,9 +1,9 @@
 import { homedir } from "node:os";
 import { join } from "node:path";
-import { Agent, createAgent, kisoHome, runsACheck } from "@vincemakes/kiso-runtime";
+import { Agent, createAgent, kisoHome, readEnvironment, runsACheck } from "@vincemakes/kiso-runtime";
 import { adapterOptionsFor } from "@vincemakes/kiso-code/config";
 import { createCodingTools } from "@vincemakes/kiso-tools-node";
-import { CODING_TOOL_RULES, breakerExtension, composeSystemPrompt, floorExtension, modeExtensions, modeSystemPrompt, protectedShellExtension, readOnlyShellExtension, setMode, } from "@vincemakes/kiso-code/policy";
+import { CODING_TOOL_RULES, breakerExtension, composeSystemPrompt, fileStopRoots, floorExtension, modeExtensions, modeSystemPrompt, protectedShellExtension, readOnlyShellExtension, setMode, } from "@vincemakes/kiso-code/policy";
 import { observedRevisionFrom } from "./observed-revision.js";
 /** The adapter identity a model is routed by (what pricing is looked up on). */
 export const routeOf = (model) => (model.kind === "adapter" ? model.route : model.profile.kind);
@@ -39,6 +39,9 @@ export function createWebAgent(options) {
         excludeRoots: [kisoHome()],
         secretEnvNames: options.secretEnvNames ?? [],
         protectedFiles: protectedFiles(),
+        // ADR-0058 Amendment 19: read on every call, so an add, a removal or a mode change applies at the next one
+        access: (sessionId) => ({ added: readEnvironment(store.root, sessionId ?? options.sessionId).added, outside: options.tier() === "full-access" ? "allow" : "deny" }),
+        stopRoots: fileStopRoots(homedir(), kisoHome()),
         tasks: options.tasks.shellTasks,
         observedRevision: observedRevisionFrom(store, workspace),
         ...(options.toolLimits !== undefined ? { limits: options.toolLimits } : {}),
@@ -54,7 +57,7 @@ export function createWebAgent(options) {
         // the terminal's chain, in its order: the guards that deny speak first
         extensions: [
             protectedShellExtension({ files: protectedFiles, workspaceRoot: root, env: () => ({ home: homedir(), kisoHome: kisoHome() }) }),
-            floorExtension(() => true, root),
+            floorExtension(() => true, root, undefined, () => readEnvironment(store.root, options.sessionId).added),
             breakerExtension(),
             ...modeExtensions(root, options.tier),
             readOnlyShellExtension(() => ({ workspaceRoot: workspace, excludeRoots: toolOptions.excludeRoots })),

package/dist/main/approvals.js

@@ -4,6 +4,7 @@ export class ApprovalWatch {
     #spaces;
     #notify;
     #presence;
+    #unread;
     /** decisions already announced, per `key/session`; forgotten once answered */
     #told = new Map();
     /** Works seen running at the last look */
@@ -11,10 +12,11 @@ export class ApprovalWatch {
     #notices = [];
     #seq = 0;
     #timer;
-    constructor(spaces, notify, presence) {
+    constructor(spaces, notify, presence, unread = () => undefined) {
         this.#spaces = spaces;
         this.#notify = notify;
         this.#presence = presence;
+        this.#unread = unread;
     }
     start(everyMs = 1_000) {
         this.#timer = setInterval(() => void this.poll(), everyMs);
@@ -34,9 +36,19 @@ export class ApprovalWatch {
             this.#notices.shift();
         this.#notify?.(full);
     }
-    async poll() {
+    #here() {
         const p = this.#presence();
-        const here = p !== null && p.focused && Date.now() - p.at < FRESH_MS ? p : null;
+        return p !== null && p.focused && Date.now() - p.at < FRESH_MS ? p : null;
+    }
+    /** Whether the person is looking at something other than this Work. */
+    away(key, sessionId) {
+        const here = this.#here();
+        return here === null || here.key !== key || here.session !== sessionId;
+    }
+    async poll() {
+        const here = this.#here();
+        if (here !== null)
+            this.#unread(here.session, false);
         for (const space of this.#spaces()) {
             for (const sessionId of space.opened()) {
                 const id = `${space.key}/${sessionId}`;

package/dist/main/artifacts.js

@@ -73,6 +73,9 @@ export function artifactsOf(event, workId, call, root, dir) {
             return outside(raw, since);
         if (kind === undefined || rel.startsWith("..") || out.some((a) => a.uri === `file:${rel}`))
             return;
+        // a file that is not there is the common case in a replay: no refusal is built for it
+        if (!existsSync(resolve(root, rel)))
+            return;
         try {
             const stat = statSync(resolveInside(root, rel));
             if (stat.isFile() && (since === null || stat.mtimeMs >= since - SLACK_MS))

package/dist/main/desk-api.js

@@ -6,11 +6,15 @@ import { contextParts } from "./context.js";
 import { rename } from "./names.js";
 import { forkWork } from "./fork.js";
 import { WORK_ACTS, workAct } from "./works.js";
-import { commit, gitOf, openPr, prDraft } from "./git.js";
+import { commit, gitOf, openPr, prDraft, tryRun } from "./git.js";
+import { prOfUrl } from "./prs.js";
 import { existing, Refusal, resolveInside } from "./files.js";
 import { artifactKind } from "./artifacts.js";
 import { listDirs, validateFolder } from "./folders.js";
+import { pickFolder } from "./pick-folder.js";
 import { folderInfo } from "./folder-info.js";
+import { changeFolders, foldersOf, stopRoots } from "./work-folders.js";
+import { environmentRows, openRow } from "./environment.js";
 const json = (status, body) => ({ status, body });
 const BODY_CAP = 16 * 1024;
 async function readJson(req) {
@@ -40,7 +44,8 @@ export async function deskApi(ctx, req, url) {
         if (path === "/desk/at-files") {
             if (space === null)
                 return json(404, {});
-            return req.method === "GET" ? json(200, atFiles(space)) : json(405, {});
+            const session = url.searchParams.get("session") ?? "";
+            return req.method === "GET" ? json(200, atFiles(space, SAFE_ID.test(session) && space.store.ids().includes(session) ? foldersOf(space, session).added.filter((a) => !a.missing).map((a) => a.path) : [], stopRoots())) : json(405, {});
         }
         if (path === "/desk/context") {
             if (space === null)
@@ -69,7 +74,42 @@ export async function deskApi(ctx, req, url) {
             const body = await readJson(req);
             if (path === "/desk/commit")
                 return json(200, await commit(space.workspace, str(body["message"]) ?? "", Array.isArray(body["paths"]) ? body["paths"].filter((p) => typeof p === "string") : []));
-            return json(200, await openPr(space.workspace, str(body["title"]) ?? "", str(body["body"]) ?? ""));
+            const pr = await openPr(space.workspace, str(body["title"]) ?? "", str(body["body"]) ?? "");
+            const session = str(body["session"]) ?? "";
+            if (SAFE_ID.test(session) && space.store.ids().includes(session))
+                ctx.settings.setPr(session, pr);
+            return json(200, pr);
+        }
+        if (path === "/desk/work-pr") {
+            // link a Work to a pull request by its URL or its number in the folder's repository, or (pr: null) unlink it
+            if (!post)
+                return json(405, {});
+            if (space === null)
+                return json(404, {});
+            const body = await readJson(req);
+            const session = str(body["session"]) ?? "";
+            if (!SAFE_ID.test(session) || !space.store.ids().includes(session))
+                return json(404, {});
+            if (body["pr"] === null)
+                return (ctx.settings.setPr(session, null), json(200, { pr: null }));
+            const asked = (str(body["pr"]) ?? "").trim().replace(/^#/, "");
+            const pr = prOfUrl(asked) ?? (/^\d+$/.test(asked) ? prOfUrl((await tryRun(space.workspace, "gh", ["pr", "view", asked, "--json", "url", "--jq", ".url"], 8000)) ?? "") : null);
+            if (pr === null)
+                throw new Refusal(400, "give a pull request's GitHub URL, or its number in this folder's repository");
+            ctx.settings.setPr(session, pr);
+            return json(200, { pr });
+        }
+        if (path === "/desk/work-folders") {
+            // a Work's added folders: asked, or changed by path; refused in words (ADR-0058 Amendment 19)
+            if (space === null)
+                return json(404, {});
+            const body = post ? await readJson(req) : {};
+            const session = post ? (str(body["session"]) ?? "") : (url.searchParams.get("session") ?? "");
+            if (!SAFE_ID.test(session) || !space.store.ids().includes(session))
+                return json(404, {});
+            if (post)
+                await changeFolders(space, session, str(body["add"]), str(body["remove"]));
+            return json(200, foldersOf(space, session));
         }
         if (path === "/desk/rename") {
             if (!post)
@@ -172,7 +212,18 @@ export async function deskApi(ctx, req, url) {
                 return json(405, {});
             const session = url.searchParams.get("session") ?? undefined;
             const fork = session === undefined ? undefined : ctx.settings.forkOf(session);
-            return json(200, { ...folderInfo(space.workspace, ctx.settings.tierOf(session)), ...(fork === undefined ? {} : { fork: { parent: fork.parent, title: fork.title, at: fork.at } }) });
+            const rows = session !== undefined && SAFE_ID.test(session) && space.store.ids().includes(session) ? { rows: environmentRows(space, session, ctx.settings.marksOf(session).pr) } : {};
+            return json(200, { ...folderInfo(space.workspace, ctx.settings.tierOf(session)), ...rows, ...(fork === undefined ? {} : { fork: { parent: fork.parent, title: fork.title, at: fork.at } }) });
+        }
+        if (path === "/desk/env-open" && post) {
+            if (space === null)
+                return json(404, {});
+            const body = await readJson(req);
+            const session = str(body["session"]) ?? "";
+            if (!SAFE_ID.test(session) || !space.store.ids().includes(session))
+                return json(404, {});
+            openRow(space, session, ctx.settings.marksOf(session).pr, Number(body["index"]), str(body["door"]) ?? "", str(body["path"]) ?? "");
+            return json(200, {});
         }
         if (path === "/desk/history")
             return req.method === "GET" ? json(200, await ctx.history.snapshot({ key: ctx.current.key, dir: ctx.current.dir }, url.searchParams.get("fresh") ?? undefined)) : json(405, {});
@@ -208,6 +259,10 @@ export async function deskApi(ctx, req, url) {
             const opened = ctx.spaceFor(basename(dir));
             return opened === null ? json(500, {}) : json(200, { key: opened.key, folder: basename(workspace) });
         }
+        if (path === "/desk/pick-folder" && post) {
+            const picked = await pickFolder();
+            return json(200, picked === null ? { cancelled: true } : { path: picked });
+        }
         if (path === "/desk/recent" && req.method === "GET") {
             const rows = ctx.settings.recents().flatMap((p) => {
                 try {

package/dist/main/environment.js

@@ -0,0 +1,102 @@
+import { execFile } from "node:child_process";
+import { existsSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { basename, dirname } from "node:path";
+import { cdTargets, isGhPrCreate } from "@vincemakes/kiso-code/policy";
+import { Refusal } from "./files.js";
+import { branchOf, githubOf } from "./folder-info.js";
+import { tryRun } from "./git.js";
+import { lastPrOfText } from "./prs.js";
+import { foldersOf } from "./work-folders.js";
+/**
+ * A Work's Environment rows. Recent folders and Repositories are DERIVED from the log and granted nothing (plan rev 4.1, 4 and 5):
+ * a folder this Work's shell moved into (a literal `cd` in a call that did not fail), a repository it has a pull request in (a parsed
+ * `gh pr create` whose result is not an error, else the Work's linked one). Cached by the log's last seq; nothing is stored.
+ */
+const RECENT_MAX = 8;
+const cache = new Map();
+/** A pull request's branch from `gh`, asked once off the request (retried after a minute when it could not be read); the row shows it once known. */
+const branches = new Map();
+function branchOfPr(url) {
+    const held = branches.get(url);
+    if (held === undefined || (held.branch === undefined && Date.now() - held.at > 60_000)) {
+        branches.set(url, { at: Date.now() });
+        void tryRun(process.cwd(), "gh", ["pr", "view", url, "--json", "headRefName", "--jq", ".headRefName"], 8000).then((b) => b !== null && b !== "" && branches.set(url, { branch: b, at: Date.now() }));
+    }
+    return held?.branch;
+}
+const isDir = (p) => {
+    try {
+        return statSync(p).isDirectory();
+    }
+    catch {
+        return false;
+    }
+};
+const repoOf = (pr) => ({ repo: /github\.com\/([\w.-]+\/[\w.-]+)\//.exec(pr.url)[1], number: pr.number, url: pr.url });
+/** What a log says: the folders a shell moved to and the repositories a `gh pr create` printed, newest first. A call whose arguments did not parse (`input` null) reads as no command. */
+export function scanLog(events, base, home, dir = isDir) {
+    const calls = new Map();
+    const recent = [];
+    const repos = [];
+    for (const e of events) {
+        const input = e.type === "tool_call_end" ? e.input : null;
+        if (e.type === "tool_call_end" && e.name === "shell" && typeof input === "object" && input !== null && typeof input.command === "string")
+            calls.set(e.callId, input.command);
+        if (e.type !== "tool_result" || e.isError || !calls.has(e.callId))
+            continue;
+        const line = calls.get(e.callId);
+        for (const d of cdTargets(line, base, home))
+            if (dir(d))
+                recent.unshift(d);
+        const text = typeof e.content === "string" ? e.content : e.content.map((b) => (b.type === "text" ? b.text : "")).join("\n");
+        const pr = isGhPrCreate(line) ? lastPrOfText(text) : null; // the last URL printed: the one the command made comes after any it quoted
+        if (pr !== null)
+            repos.unshift(repoOf(pr));
+    }
+    return { recent, repos };
+}
+function derive(space, session, linked) {
+    const records = space.store.load(session);
+    const seq = records.at(-1)?.event.seq ?? -1;
+    const slot = `${space.key}\0${session}`; // two folders can hold a Work of the same id and the same last seq
+    const held = cache.get(slot);
+    // both sources, one row per repository: the Work's own link (the person's latest word) first, then what the log printed
+    const both = (log) => [...(linked === undefined ? [] : [repoOf(linked)]), ...log].filter((r, i, all) => all.findIndex((x) => x.repo === r.repo) === i);
+    if (held !== undefined && held.seq === seq)
+        return { recent: held.recent, repos: both(held.repos) };
+    const { recent, repos } = scanLog(records.map((r) => r.event), space.workspace, homedir());
+    const kept = [...new Set(recent)].filter((d, _, all) => !all.some((o) => o !== d && d.startsWith(`${o}/`))).slice(0, RECENT_MAX);
+    const out = { seq, recent: kept, repos: repos.filter((r, i) => repos.findIndex((x) => x.repo === r.repo) === i) };
+    cache.set(slot, out);
+    return { recent: out.recent, repos: both(out.repos) };
+}
+const shown = (p) => (p.startsWith(`${homedir()}/`) ? `~${p.slice(homedir().length)}` : p);
+/** The rows, in the card's order: the primary, the added folders, then what only records. */
+export function environmentRows(space, session, linked) {
+    const { added, damaged } = foldersOf(space, session);
+    const { recent, repos } = derive(space, session, linked);
+    const row = (kind, path) => ({ kind, path, shown: shown(path), name: basename(path) || path, parent: shown(dirname(path)), branch: branchOf(path), github: githubOf(path), missing: !existsSync(path) });
+    const roots = [space.workspace, ...added.map((a) => a.path)];
+    const inside = (d, root) => d === root || d.startsWith(`${root}/`);
+    // a recent folder in an added folder is not shown; one in the primary, or around any root, is shown but can never be added (nested)
+    const folders = [row("primary", space.workspace), ...added.map((a) => row("added", a.path)), ...recent.filter((d) => !added.some((a) => inside(d, a.path)) && d !== space.workspace).map((d) => ({ ...row("recent", d), addable: !roots.some((r) => inside(d, r) || inside(r, d)) }))];
+    const withBranch = repos.map((r) => ({ ...r, ...(branchOfPr(r.url) === undefined ? {} : { branch: branchOfPr(r.url) }) }));
+    return { folders, repos: withBranch, doors: process.platform === "darwin" || process.env["KISO_WEB_OPENER"] !== undefined ? ["reveal", "terminal"] : [], damaged };
+}
+/** Show in Finder / Open in terminal: by Work and row index, the path recomputed here, never taken from the page. */
+export function openRow(space, session, linked, index, door, path) {
+    const folder = environmentRows(space, session, linked).folders[index];
+    if (folder === undefined || !existsSync(folder.path))
+        throw new Refusal(404, "that folder is not there any more");
+    // the page sends the row's path only to be compared: the rows moved since it drew them when they differ
+    if (folder.path !== path)
+        throw new Refusal(409, "the folders changed; try again");
+    if ((process.platform !== "darwin" && process.env["KISO_WEB_OPENER"] === undefined) || (door !== "reveal" && door !== "terminal"))
+        throw new Refusal(501, "this host cannot open it");
+    const custom = process.env["KISO_WEB_OPENER"]; // the proofs: a program run as `opener <door> <path>` instead of the system's
+    if (custom !== undefined && custom !== "")
+        execFile(custom, [door, folder.path], () => undefined);
+    else
+        execFile("open", door === "reveal" ? ["-R", folder.path] : ["-a", "Terminal", folder.path], () => undefined);
+}

package/dist/main/folder-info.js

@@ -16,7 +16,7 @@ function gitDir(from) {
     }
 }
 /** The branch a folder is on (a short commit when detached); null outside a git folder. */
-function branchOf(workspace) {
+export function branchOf(workspace) {
     try {
         const git = gitDir(workspace);
         if (git === null)
@@ -34,3 +34,20 @@ export function folderInfo(workspace, mode) {
     const home = homedir();
     return { folder: basename(workspace), path: workspace.startsWith(`${home}/`) ? `~${workspace.slice(home.length)}` : workspace, root: workspace, branch: branchOf(workspace), mode };
 }
+/** `owner/repo` of a folder's GitHub remote: `origin`'s, else any other remote that is on GitHub. */
+export function githubOf(folder) {
+    try {
+        const git = gitDir(folder);
+        const config = git === null ? "" : readFileSync(join(git.replace(/\/worktrees\/[^/]+$/, ""), "config"), "utf8");
+        const urls = [...config.matchAll(/\[remote "([^"]+)"\][^\[]*?url\s*=\s*(\S+)/g)].map((m) => [m[1], m[2]]);
+        for (const [, url] of [...urls.filter(([n]) => n === "origin"), ...urls.filter(([n]) => n !== "origin")]) {
+            const m = /^(?:https:\/\/|git@|ssh:\/\/git@)github\.com[:/]([\w.-]+\/[\w.-]+?)(?:\.git)?$/.exec(url);
+            if (m !== null)
+                return m[1];
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/main/fs-routes.js

@@ -39,10 +39,27 @@ export function deskRead(url, space) {
 const AT_CAP = 2000;
 const AT_SKIP = new Set([".git", "node_modules", ".kiso", "dist", "build", ".next", ".venv", "__pycache__"]);
 /** The files `@` can name, as the terminal lists them: git's own list (tracked and untracked, ignores honoured), else a bounded walk; `truncated` when the cap cut it. */
-export function atFiles(space) {
+export function atFiles(space, extra = [], stops = []) {
+    const own = rootFiles(space.workspace, "");
+    // only a root that is still its own real path (one replaced by a symlink is refused by the file tools, so it is not listed), and the walk
+    // itself leaves out the stop roots (`~/.ssh`, `~/.aws`, the kiso home ...): they are not listed and filtered out afterwards
+    const roots = extra.filter((r) => {
+        try {
+            return realpathSync(r) === r;
+        }
+        catch {
+            return false;
+        }
+    });
+    const files = roots.reduce((all, root) => [...all, ...rootFiles(root, `${root}/`, stops)], own);
+    return { files: files.slice(0, AT_CAP), truncated: files.length > AT_CAP };
+}
+/** One root's files, each under `prefix` (the primary's are relative; an added folder's are absolute, as the model must name them). */
+function rootFiles(cwd, prefix, stops = []) {
     let files;
+    const out = stops.filter((s) => s.startsWith(`${cwd}/`)).map((s) => `:(exclude)${s.slice(cwd.length + 1)}`);
     try {
-        files = execFileSync("git", ["ls-files", "-c", "-o", "--exclude-standard"], { cwd: space.workspace, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], maxBuffer: 1 << 24, timeout: 3000 }).split("\n").filter((p) => p !== "");
+        files = execFileSync("git", ["ls-files", "-c", "-o", "--exclude-standard", ...(out.length > 0 ? ["--", ".", ...out] : [])], { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], maxBuffer: 1 << 24, timeout: 3000 }).split("\n").filter((p) => p !== "").map((p) => `${prefix}${p}`);
     }
     catch {
         files = [];
@@ -51,7 +68,7 @@ export function atFiles(space) {
                 for (const e of readdirSync(dir, { withFileTypes: true })) {
                     if (files.length > AT_CAP)
                         return;
-                    if (AT_SKIP.has(e.name))
+                    if (AT_SKIP.has(e.name) || stops.includes(`${dir}/${e.name}`))
                         continue;
                     if (e.isDirectory())
                         walk(`${dir}/${e.name}`, `${prefix}${e.name}/`);
@@ -63,7 +80,7 @@ export function atFiles(space) {
                 // an unreadable directory adds nothing
             }
         };
-        walk(space.workspace, "");
+        walk(cwd, prefix);
     }
-    return { files: files.slice(0, AT_CAP), truncated: files.length > AT_CAP };
+    return files;
 }

package/dist/main/git.js

@@ -6,7 +6,7 @@ import { Refusal } from "./files.js";
  * from the dialog's confirm (POST), never by themselves, and refuse what they cannot do in words.
  */
 const run = (cwd, cmd, args, timeout = 3000) => new Promise((resolve, reject) => execFile(cmd, [...args], { cwd, timeout, maxBuffer: 1 << 23, env: { ...process.env, GIT_TERMINAL_PROMPT: "0", GH_PROMPT_DISABLED: "1" } }, (err, out, errOut) => (err === null ? resolve(out) : reject(new Error((errOut || err.message).trim())))));
-const tryRun = (cwd, cmd, args, timeout) => run(cwd, cmd, args, timeout).then((o) => o.trim(), () => null);
+export const tryRun = (cwd, cmd, args, timeout) => run(cwd, cmd, args, timeout).then((o) => o.trim(), () => null);
 let ghSignedIn = null;
 /** `gh auth status`, asked once per host process: a sign-in does not come and go between two clicks. */
 const ghReady = (cwd) => (ghSignedIn ??= tryRun(cwd, "gh", ["auth", "status"], 5000).then((o) => o !== null));

package/dist/main/history.js

@@ -13,17 +13,6 @@ import { sessionFolders } from "@vincemakes/kiso-code/config";
  */
 const MIN_AGE_MS = 3_000;
 const MAX_ROWS = 400;
-/** What the host knows about a Work it holds open: a run live, or waiting for an answer. */
-/** A delegated child's parent (the longest id of its folder that `sub-<id>-` starts with: a parent id may have any shape) and its
- *  role (what follows the task's number; a role starts with a letter, a hex delegation id may be all digits); nothing for any
- *  other session. */
-export function delegated(id, ids) {
-    if (!id.startsWith("sub-"))
-        return {};
-    const parent = ids.filter((p) => p !== id && id.startsWith(`sub-${p}-`)).sort((a, b) => b.length - a.length)[0];
-    const role = /-\d+-(\D.*)$/.exec(id.slice(4 + (parent?.length ?? 0)))?.[1];
-    return { ...(parent === undefined ? {} : { parent }), ...(role === undefined ? {} : { role }) };
-}
 /** The folder's files as one string: it changes when a log is added or written, or a Work's name file (`<id>.meta.json`, the
  *  runtime's titles read it) is written by a rename. */
 function printOf(dir) {
@@ -86,13 +75,11 @@ export class History {
             if (read === undefined)
                 continue;
             const key = basename(folder.dir);
-            const ids = read.metas.map((m) => m.id);
             for (const meta of read.metas) {
                 rows.push({
                     // a fork's parent: the store's own record (any app made it), else the host's (forks it made before)
                     ...(meta.forkedFrom !== undefined ? { parent: meta.forkedFrom } : {}),
                     ...this.#marksOf(meta.id),
-                    ...delegated(meta.id, ids),
                     id: meta.id,
                     key,
                     folder: basename(folder.workspace),

package/dist/main/host.js

@@ -10,6 +10,7 @@ import { ApprovalWatch } from "./approvals.js";
 import { deskApi } from "./desk-api.js";
 import { History } from "./history.js";
 import { Previews } from "./preview.js";
+import { PrStates, prOfEvents } from "./prs.js";
 import { createSpace } from "./space.js";
 export async function startHost(options) {
     const token = options.token ?? randomBytes(32).toString("hex");
@@ -30,6 +31,15 @@ export async function startHost(options) {
         ...(options.toolLimits !== undefined ? { toolLimits: options.toolLimits } : {}),
         followUps: options.followUps ?? true,
         titles: options.titles ?? true,
+        // a run settled (however short; the watch's one-second look can miss it): out of sight, its Work is unread; the PR its own
+        // `gh pr create` printed becomes the Work's (an earlier run's never replaces a later link)
+        onSettled: (sessionId, runId, store) => {
+            if (watch.away(key, sessionId))
+                unread(sessionId, true);
+            const pr = prOfEvents(store.load(sessionId).filter((r) => r.runId === runId).map((r) => r.event));
+            if (pr !== null && options.settings.marksOf(sessionId).pr?.url !== pr.url)
+                options.settings.setPr(sessionId, pr);
+        },
     });
     // the folder in use: its directory is claimed (named after its path) the way the terminal claims it
     const workspace = canonicalPath(options.workspace);
@@ -49,19 +59,26 @@ export async function startHost(options) {
         spaces.set(key, space);
         return space;
     };
+    const prStates = new PrStates();
     const history = new History(home, async (key, sessionId) => {
         const space = spaces.get(key);
         if (space === undefined || !space.service.isRunning(sessionId))
             return "idle";
         return (await space.service.pendingApprovals(sessionId)).length > 0 ? "waiting" : "running";
-    }, (id) => options.settings.marksOf(id));
+    }, (id) => {
+        const marks = options.settings.marksOf(id);
+        const state = marks.pr === undefined ? undefined : prStates.stateOf(marks.pr.url);
+        return marks.pr === undefined || state === undefined ? marks : { ...marks, pr: { ...marks.pr, state } };
+    });
     const rendererDir = fileURLToPath(new URL("../../out/renderer/", import.meta.url));
     const tokenBytes = Buffer.from(token);
     let auth;
     let presence = null;
     const previews = new Previews(options.previewLog);
     const requestLog = options.requestLog;
-    const watch = new ApprovalWatch(() => spaces.values(), options.notify, () => presence);
+    // written only when it changes: the person in front of a Work clears it every second
+    const unread = (sessionId, on) => void ((options.settings.marksOf(sessionId).unread === true) !== on && options.settings.mark(sessionId, "unread", on));
+    const watch = new ApprovalWatch(() => spaces.values(), options.notify, () => presence, unread);
     watch.start();
     const desk = { home, settings: options.settings, current, history, spaceFor, setPresence: (p) => (presence = p), notices: (seq) => watch.since(seq), previews };
     let origins = new Set();

package/dist/main/pick-folder.js

@@ -0,0 +1,41 @@
+import { execFile } from "node:child_process";
+import { Refusal } from "./files.js";
+/**
+ * The system's own folder picker, shown on the machine the host runs on (the host listens on this computer only, so that is the
+ * person's screen): macOS `osascript`, Linux `zenity`. The page asks and waits; a path comes back, or null when the person cancels.
+ * Elsewhere, or when the program is missing, it answers 501 and the page falls back to its own folder browser. The host judges the
+ * path again when it is opened, as for a typed one. KISO_WEB_PICKER names another program to run instead (the proofs): it prints
+ * the path and exits 0, or exits 1 for a cancel.
+ */
+function command() {
+    const custom = process.env["KISO_WEB_PICKER"];
+    if (custom !== undefined && custom !== "")
+        return { cmd: custom, args: [] };
+    if (process.platform === "darwin")
+        return { cmd: "osascript", args: ["-e", "tell me to activate", "-e", 'POSIX path of (choose folder with prompt "Choose a folder")'] };
+    if (process.platform === "linux")
+        return { cmd: "zenity", args: ["--file-selection", "--directory", "--title=Choose a folder"] };
+    return null;
+}
+/** One picker at a time: every request would otherwise put another system window on screen. */
+let open = false;
+export function pickFolder() {
+    const run = command();
+    if (run === null)
+        return Promise.reject(new Refusal(501, "this computer has no system folder picker the page can open"));
+    if (open)
+        return Promise.reject(new Refusal(409, "a folder picker is already open"));
+    open = true;
+    return new Promise((resolve, reject) => {
+        execFile(run.cmd, [...run.args], { timeout: 10 * 60_000, encoding: "utf8" }, (err, stdout, stderr) => {
+            open = false;
+            if (err === null)
+                return resolve(stdout.trim().replace(/(.)\/$/, "$1") || null);
+            if (err.code === "ENOENT")
+                return reject(new Refusal(501, `${run.cmd} is not installed`));
+            if (err.code === 1)
+                return /canceled|cancelled/i.test(stderr) || stderr.trim() === "" ? resolve(null) : reject(new Refusal(500, stderr.trim().slice(0, 200)));
+            reject(new Refusal(500, err.message.slice(0, 200)));
+        });
+    });
+}

package/dist/main/prs.js

@@ -0,0 +1,37 @@
+import { tryRun } from "./git.js";
+const PR_URL = /https:\/\/github\.com\/[\w.-]+\/[\w.-]+\/pull\/(\d+)/;
+/** The last pull request URL in a text (a command's output: what it quoted comes before what it made). */
+export const lastPrOfText = (text) => {
+    const all = [...text.matchAll(new RegExp(PR_URL, "g"))];
+    const m = all.at(-1);
+    return m === undefined ? null : { number: Number(m[1]), url: m[0] };
+};
+export const prOfUrl = (text) => {
+    const m = PR_URL.exec(text);
+    return m === null ? null : { number: Number(m[1]), url: m[0] };
+};
+/** The last PR a `gh pr create` call of these events printed, if any. */
+export function prOfEvents(events) {
+    const calls = new Set(events.filter((e) => e.type === "tool_call_end" && JSON.stringify(e.input ?? "").includes("gh pr create")).map((e) => e.callId));
+    let found = null;
+    for (const e of events)
+        if (e.type === "tool_result" && calls.has(e.callId))
+            found = prOfUrl(typeof e.content === "string" ? e.content : JSON.stringify(e.content ?? "")) ?? found;
+    return found;
+}
+const FRESH_MS = 60_000;
+export class PrStates {
+    #known = new Map();
+    /** The last state known (none yet: asked now, in the background). */
+    stateOf(url) {
+        const held = this.#known.get(url);
+        if (held === undefined || Date.now() - held.at > FRESH_MS) {
+            this.#known.set(url, { ...(held?.state !== undefined ? { state: held.state } : {}), at: Date.now() });
+            void tryRun(process.cwd(), "gh", ["pr", "view", url, "--json", "state", "--jq", ".state"], 8000).then((s) => {
+                if (s === "OPEN" || s === "MERGED" || s === "CLOSED")
+                    this.#known.set(url, { state: s, at: Date.now() });
+            });
+        }
+        return held?.state;
+    }
+}

package/dist/main/settings.js

@@ -2,13 +2,14 @@ import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { applyEffortDeclarations, contextWindowOf, demoScript, authForProfile, effortOptions, loadUserConfig, mergeConfigs, preferences, profileAvailable, rememberEffort, startingEffort, } from "@vincemakes/kiso-code/config";
 import { MODE_LABEL, OFFERED_MODES } from "@vincemakes/kiso-code/policy";
-import { lookupModelMetadata } from "@vincemakes/kiso-runtime/internal";
+import { lookupInputModalities } from "@vincemakes/kiso-runtime/internal";
 import { fauxSkip } from "./faux.js";
 import { storeKey } from "./login.js";
 const MAX_RECENT = 10;
 const SAFE_SESSION = /^[A-Za-z0-9._-]+$/;
-/** Whether the model table says the profile's model reads images; unknown is no (nothing is sent that might be dropped). */
-const readsImages = (p) => lookupModelMetadata(p.model, p.baseUrl)?.capabilities.inputModalities?.includes("image") === true;
+/** What the model table (its route's row, else the release snapshot of the model's weights) says of reading pictures: true, false (its input modalities are listed without "image": evidence), or null (unknown). */
+export const imagesOf = (modalities) => (modalities === null || modalities === undefined ? null : modalities.includes("image"));
+const readsImages = (p) => imagesOf(lookupInputModalities(p.model, p.baseUrl));
 const isTier = (value) => OFFERED_MODES.some((m) => m === value);
 export class Settings {
     #file;
@@ -123,23 +124,29 @@ export class Settings {
     forkOf(session) {
         return this.#read().forks?.[session];
     }
-    /** Pin or archive a Work (a pin goes first), or take it off. */
+    /** Pin, archive or mark unread a Work (a pin goes first), or take it off. */
     mark(session, list, on) {
         const rest = (this.#read()[list] ?? []).filter((id) => id !== session);
         this.write({ [list]: on ? [session, ...rest] : rest });
     }
-    /** What the sidebar shows of a Work beyond its log: the fork's parent, its pin's place, whether it is archived. */
+    /** A Work's pull request, or none. */
+    setPr(session, pr) {
+        const { [session]: _, ...rest } = this.#read().prs ?? {};
+        this.write({ prs: pr === null ? rest : { ...rest, [session]: pr } });
+    }
+    /** What the sidebar shows of a Work beyond its log: the fork's parent, its pin's place, whether it is archived or unread, its PR. */
     marksOf(session) {
         const own = this.#read();
         const parent = own.forks?.[session]?.parent;
         const pinned = own.pins?.indexOf(session) ?? -1;
-        return { ...(parent !== undefined ? { parent } : {}), ...(pinned >= 0 ? { pinned } : {}), ...(own.archived?.includes(session) ? { archived: true } : {}) };
+        const pr = own.prs?.[session];
+        return { ...(parent !== undefined ? { parent } : {}), ...(pinned >= 0 ? { pinned } : {}), ...(own.archived?.includes(session) ? { archived: true } : {}), ...(own.unread?.includes(session) ? { unread: true } : {}), ...(pr !== undefined ? { pr } : {}) };
     }
     /** A deleted Work leaves nothing here; a fork's record of it stays (its notice still names the parent). */
     forget(session) {
         const own = this.#read();
         const drop = (m) => Object.fromEntries(Object.entries(m ?? {}).filter(([k]) => k !== session));
-        this.write({ tiers: drop(own.tiers), works: drop(own.works), forks: drop(own.forks), pins: (own.pins ?? []).filter((id) => id !== session), archived: (own.archived ?? []).filter((id) => id !== session) });
+        this.write({ tiers: drop(own.tiers), works: drop(own.works), forks: drop(own.forks), pins: (own.pins ?? []).filter((id) => id !== session), archived: (own.archived ?? []).filter((id) => id !== session), unread: (own.unread ?? []).filter((id) => id !== session), prs: drop(own.prs) });
     }
     restoreWork(session, work) {
         const { [session]: _, ...rest } = this.#read().works ?? {};