@vincemakes/kiso-web 0.52.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);
@@ -27,6 +27,10 @@ class WebAgent extends Agent {
         return session;
     }
 }
+/** The system prompt a Work's agent is built with: the terminal's prompt for the folder (its project instructions included), and the tier's note. */
+export function promptOf(workspace, tier) {
+    return [composeSystemPrompt(workspace, protectedFiles()), modeSystemPrompt(tier)].join("\n\n");
+}
 export function createWebAgent(options) {
     const { store, workspace, model } = options;
     const root = () => workspace;
@@ -35,24 +39,25 @@ 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 } : {}),
     };
     const window = model.kind === "profile" ? model.contextWindow : undefined;
-    const prompt = composeSystemPrompt(workspace, protectedFiles());
-    const modeNote = modeSystemPrompt(options.tier());
     const definition = {
         model: model.kind === "adapter" ? model.model : model.profile.model,
         store,
         workspace,
-        systemPrompt: modeNote === undefined ? prompt : `${prompt}\n\n${modeNote}`,
+        systemPrompt: promptOf(workspace, options.tier()),
         toolRules: CODING_TOOL_RULES,
         tools: [...createCodingTools(toolOptions)],
         // 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

@@ -1,10 +1,16 @@
-import { closeSync, fstatSync, openSync, readSync, statSync } from "node:fs";
-import { extname, isAbsolute, join, relative, resolve } from "node:path";
+import { closeSync, copyFileSync, existsSync, fstatSync, mkdirSync, openSync, readdirSync, readFileSync, readSync, statSync } from "node:fs";
+import { basename, extname, isAbsolute, join, relative, resolve } from "node:path";
 import { resolveInside } from "./files.js";
 /**
  * What a tool call made that the page can show, each "best effort, never a guess": an image block of its result; an artifact
  * file a successful write or edit touched; or, for a command, a path its text or its output head names that is inside the
  * folder, of an artifact type, exists, and changed at or after the step began. No folder scan, no watcher.
+ *
+ * A picture a command made OUTSIDE the folder (a browser tool saving a screenshot under /tmp: owner 2026-11-03, the screenshot
+ * must show in the stream) is kept as a copy in the Work's own `<id>.files/`, under the result's `log:` address: the page only
+ * ever reads the copy, never the outside path. Only a raster picture (no svg: it can carry script), named by the command or its
+ * output, changed during the step, at most KEEP_MAX bytes; it is copied once, so a later file of the same name does not replace
+ * it. This widens the 2026-10-31 rule "a file named outside the folder is not taken" for pictures only.
  */
 const KINDS = {
     ".png": "image", ".jpg": "image", ".jpeg": "image", ".gif": "image", ".webp": "image", ".svg": "image",
@@ -14,25 +20,62 @@ const KINDS = {
 const NAMED = /[\w@+./-]+\.(?:png|jpe?g|gif|webp|svg|html?|md|pdf|csv|mp4|webm|mov|mp3|wav)\b/gi;
 /** a file's clock and the log's may differ by the file system's granularity */
 const SLACK_MS = 50;
+const KEPT = { ".png": "image/png", ".jpg": "image/jpeg", ".jpeg": "image/jpeg", ".gif": "image/gif", ".webp": "image/webp" };
+const KEEP_MAX = 10 * 1024 * 1024;
+/** where a kept copy lives: the Work's own folder of files beside its log */
+const keptDir = (dir, workId) => join(dir, `${workId}.files`);
 export const artifactKind = (path) => KINDS[extname(path).toLowerCase()];
-/** `root`: the folder's real path. */
-export function artifactsOf(event, workId, call, root) {
+/** `root`: the folder's real path; `dir`: the sessions directory, where a picture made outside the folder is kept. */
+export function artifactsOf(event, workId, call, root, dir) {
     const out = [];
-    const ref = (n, kind, uri, mediaType) => {
-        out.push({ id: `${event.callId}:${n}`, workId, callId: event.callId, kind, uri, ...(mediaType !== undefined ? { mediaType } : {}) });
+    const ref = (n, kind, uri, mediaType, name) => {
+        out.push({ id: `${event.callId}:${n}`, workId, callId: event.callId, kind, uri, ...(mediaType !== undefined ? { mediaType } : {}), ...(name !== undefined ? { name } : {}) });
     };
-    if (Array.isArray(event.content))
+    if (Array.isArray(event.content)) {
+        const blocks = event.content.filter((b) => b.type === "image").length;
+        let k = 0;
         event.content.forEach((b, n) => {
-            if (b.type === "image" && ((b.sourceType === "base64" && b.data !== undefined) || b.url?.startsWith("https:") === true))
-                ref(n, "image", `log:${event.seq}/${n}`, b.mediaType);
+            if (b.type !== "image" || !((b.sourceType === "base64" && b.data !== undefined) || b.url?.startsWith("https:") === true))
+                return;
+            // an image block has no file name: the tool, the result's number and, of several, its place
+            const ext = (b.mediaType ?? "image/png").split("/")[1]?.replace("jpeg", "jpg") ?? "png";
+            ref(n, "image", `log:${event.seq}/${n}`, b.mediaType, `${call?.name ?? "image"}-${event.seq}${blocks > 1 ? `-${(k += 1)}` : ""}.${ext}`);
         });
+    }
     if (event.isError || call === null)
         return out;
+    let kept = 0;
+    const outside = (full, since) => {
+        const ext = extname(full).toLowerCase();
+        if (KEPT[ext] === undefined || out.some((a) => a.id === `${event.callId}:${full}`))
+            return;
+        const name = `${event.seq}-k${kept}${ext}`;
+        const copy = join(keptDir(dir, workId), name);
+        try {
+            if (!existsSync(copy)) {
+                const stat = statSync(full);
+                if (!stat.isFile() || stat.mtimeMs < since - SLACK_MS || stat.size > KEEP_MAX)
+                    return;
+                mkdirSync(keptDir(dir, workId), { recursive: true });
+                copyFileSync(full, copy);
+            }
+        }
+        catch {
+            return;
+        }
+        ref(full, "image", `log:${event.seq}/k${kept}`, KEPT[ext], basename(full));
+        kept += 1;
+    };
     const file = (raw, since) => {
         const rel = relative(root, isAbsolute(raw) ? raw : resolve(root, raw));
         const kind = artifactKind(rel);
+        if (rel.startsWith("..") && isAbsolute(raw) && since !== null)
+            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))
@@ -53,7 +96,7 @@ export function artifactsOf(event, workId, call, root) {
     return out;
 }
 /**
- * Image blocks of results, read from the session's log: an index of seq to the byte range of its line, built once per log and
+ * Image blocks of results and of the person's own lines, read from the session's log: an index of seq to the byte range of its line, built once per log and
  * extended as it grows, so a request reads one event, never the whole log.
  */
 export class LogImages {
@@ -62,14 +105,28 @@ export class LogImages {
     constructor(dir) {
         this.#dir = dir;
     }
-    /** The n-th block of the result at `seq`: its bytes, an https address to pass on, or null. */
+    /** The n-th block of the result or the line at `seq`: its bytes, an https address to pass on, or null; `k<n>`: the n-th
+     *  picture of that result kept from outside the folder. */
     block(sessionId, seq, n) {
+        if (typeof n === "string") {
+            const name = (() => {
+                try {
+                    return readdirSync(keptDir(this.#dir, sessionId)).find((f) => f.startsWith(`${seq}-${n}.`));
+                }
+                catch {
+                    return undefined;
+                }
+            })();
+            const type = name === undefined ? undefined : KEPT[extname(name)];
+            return name === undefined || type === undefined ? null : { type, bytes: readFileSync(join(keptDir(this.#dir, sessionId), name)) };
+        }
         const file = join(this.#dir, `${sessionId}.jsonl`);
         const at = this.#index(file).get(seq);
         if (at === undefined)
             return null;
+        // a tool's result, or the person's own line (a picture pasted into the composer)
         const event = JSON.parse(read(file, at[0], at[1]).toString("utf8")).event;
-        const b = event.type === "tool_result" && Array.isArray(event.content) ? event.content[n] : undefined;
+        const b = (event.type === "tool_result" || event.type === "user_input") && Array.isArray(event.content) ? event.content[n] : undefined;
         if (b?.type !== "image")
             return null;
         if (b.sourceType === "base64" && b.data !== undefined)

package/dist/main/context.js

@@ -0,0 +1,20 @@
+import { kisoHome } from "@vincemakes/kiso-runtime";
+import { tiersFor } from "@vincemakes/kiso-runtime/internal";
+import { CODING_TOOL_RULES, composeSystemPrompt, SYSTEM_PROMPT } from "@vincemakes/kiso-code/policy";
+import { createCodingTools } from "@vincemakes/kiso-tools-node";
+import { promptOf, protectedFiles } from "./agent.js";
+/** What the Work's requests always carry, in bytes, for the rail's Context breakdown (an estimate the page labels as one), and where
+ *  compaction starts and must happen for the stated window (the runtime's own tiers; null without a stated window). */
+export function contextParts(workspace, tier, window) {
+    const bytes = (s) => Buffer.byteLength(s, "utf8");
+    const prompt = promptOf(workspace, tier);
+    const instructions = Math.max(0, bytes(composeSystemPrompt(workspace, protectedFiles())) - bytes(SYSTEM_PROMPT));
+    const tools = createCodingTools({ workspaceRoot: workspace, excludeRoots: [kisoHome()], secretEnvNames: [], protectedFiles: protectedFiles() });
+    const tiers = window === null ? null : tiersFor(window, 0);
+    return {
+        system: bytes(prompt) - instructions + CODING_TOOL_RULES.reduce((n, r) => n + bytes(r.line) + 1, 0),
+        instructions,
+        tools: { count: tools.length, bytes: tools.reduce((n, t) => n + bytes(JSON.stringify({ name: t.name, description: t.description, parameters: t.parameters })), 0) },
+        compaction: tiers === null ? null : { starts: tiers.soft, must: tiers.hard },
+    };
+}

package/dist/main/desk-api.js

@@ -1,11 +1,20 @@
 import { realpathSync, statSync } from "node:fs";
 import { basename } from "node:path";
 import { canonicalPath, claimProjectDir, projectDirFor } from "@vincemakes/kiso-code/config";
-import { deskRead } from "./fs-routes.js";
+import { atFiles, deskRead, SAFE_ID } from "./fs-routes.js";
+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, 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) {
@@ -32,6 +41,124 @@ export async function deskApi(ctx, req, url) {
     const space = where === null || where === "" ? ctx.current : ctx.spaceFor(where);
     const post = req.method === "POST";
     try {
+        if (path === "/desk/at-files") {
+            if (space === null)
+                return json(404, {});
+            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)
+                return json(404, {});
+            const session = url.searchParams.get("session") ?? undefined;
+            let window = null;
+            try {
+                const m = ctx.settings.model(session === undefined ? undefined : { sessionId: session, sessionsDir: space.dir });
+                window = m.kind === "profile" ? (m.contextWindow ?? null) : null;
+            }
+            catch {
+                // no model: the parts are still known, the compaction sizes are not
+            }
+            return req.method === "GET" ? json(200, contextParts(space.workspace, ctx.settings.tierOf(session), window)) : json(405, {});
+        }
+        if (path === "/desk/git") {
+            if (space === null)
+                return json(404, {});
+            return req.method === "GET" ? json(200, url.searchParams.has("draft") ? await prDraft(space.workspace) : await gitOf(space.workspace)) : json(405, {});
+        }
+        if (path === "/desk/commit" || path === "/desk/pr") {
+            if (!post)
+                return json(405, {});
+            if (space === null)
+                return json(404, {});
+            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") : []));
+            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)
+                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, {});
+            return json(200, { name: rename(space.dir, session, str(body["name"]) ?? "") });
+        }
+        if (path === "/desk/fork") {
+            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))
+                return json(404, {});
+            const atSeq = typeof body["atSeq"] === "number" ? body["atSeq"] : undefined;
+            return json(200, { id: forkWork(space, ctx.settings, session, atSeq).id });
+        }
+        if (path === "/desk/work") {
+            if (!post)
+                return json(405, {});
+            if (space === null)
+                return json(404, {});
+            const body = await readJson(req);
+            const session = str(body["session"]) ?? "";
+            const act = str(body["act"]) ?? "";
+            if (!SAFE_ID.test(session) || !WORK_ACTS.includes(act))
+                return json(404, {});
+            workAct(space, ctx.settings, session, act);
+            return json(200, { ok: true });
+        }
+        if (path === "/desk/task-stop") {
+            if (!post)
+                return json(405, {});
+            if (space === null)
+                return json(404, {});
+            const body = await readJson(req);
+            const session = str(body["session"]) ?? "";
+            const task = str(body["task"]) ?? "";
+            if (!SAFE_ID.test(session) || !SAFE_ID.test(task) || !space.store.ids().includes(session))
+                return json(404, {});
+            return json(200, { stopped: space.tasks.managerFor(session).stop(task, "person") });
+        }
         if (path === "/desk/fs/tree" || path === "/desk/fs/file" || path === "/desk/task-log") {
             if (space === null)
                 return json(404, {});
@@ -43,11 +170,11 @@ export async function deskApi(ctx, req, url) {
             return post ? json(200, { found: existing(realpathSync(space.workspace), (await readJson(req))["paths"]) }) : json(405, {});
         }
         // an image block of a result, from the Work's log: its bytes, or an https address passed on
-        const image = /^\/desk\/image\/([A-Za-z0-9._-]+)\/(\d+)\/(\d+)$/.exec(path);
+        const image = /^\/desk\/image\/([A-Za-z0-9._-]+)\/(\d+)\/(\d+|k\d+)$/.exec(path);
         if (image !== null) {
             if (space === null || req.method !== "GET" || !space.store.ids().includes(image[1]))
                 return json(404, {});
-            const b = space.images.block(image[1], Number(image[2]), Number(image[3]));
+            const b = space.images.block(image[1], Number(image[2]), image[3].startsWith("k") ? image[3] : Number(image[3]));
             if (b === null)
                 return json(404, {});
             return "url" in b ? { status: 302, body: null, headers: { location: b.url } } : { status: 200, body: b.bytes, headers: { "content-type": b.type, "x-content-type-options": "nosniff", "cache-control": "private, max-age=86400" } };
@@ -66,19 +193,62 @@ export async function deskApi(ctx, req, url) {
             ctx.previews.close(String((await readJson(req))["url"] ?? ""));
             return json(200, { ok: true });
         }
+        // the line the person may send next after the run that ended at `seq` (asked once, after that run; "" for none)
+        if (path === "/desk/followup") {
+            if (space === null)
+                return json(404, {});
+            if (req.method !== "GET")
+                return json(405, {});
+            const session = url.searchParams.get("session") ?? "";
+            const seq = Number(url.searchParams.get("seq"));
+            if (!space.store.ids().includes(session) || !Number.isInteger(seq))
+                return json(404, {});
+            return json(200, { line: await space.followUp(session, seq) });
+        }
         if (path === "/desk/env") {
             if (space === null)
                 return json(404, {});
-            return req.method === "GET" ? json(200, folderInfo(space.workspace, ctx.settings.tierOf(url.searchParams.get("session") ?? undefined))) : json(405, {});
+            if (req.method !== "GET")
+                return json(405, {});
+            const session = url.searchParams.get("session") ?? undefined;
+            const fork = session === undefined ? undefined : ctx.settings.forkOf(session);
+            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, {});
         if (path === "/desk/settings") {
-            if (post)
-                ctx.settings.apply((await readJson(req)));
+            let session = url.searchParams.get("session") ?? undefined;
+            if (post) {
+                const patch = (await readJson(req));
+                // a patch for one Work is answered with that Work's settings
+                session ??= patch.session;
+                const before = patch.session === undefined ? undefined : ctx.settings.workOf(patch.session);
+                const work = ctx.settings.apply(patch);
+                // a Work's model changed: rebuild it from its log so its next run uses it; a run in flight refuses, and the choice is put back
+                if (work !== null && space !== null && space.opened().has(work)) {
+                    try {
+                        await space.service.reopen(work);
+                    }
+                    catch {
+                        ctx.settings.restoreWork(work, before);
+                        return json(409, { message: "a run is going: switch the model when it ends" });
+                    }
+                }
+            }
             else if (req.method !== "GET")
                 return json(405, {});
-            return json(200, ctx.settings.snapshot(url.searchParams.get("session") ?? undefined));
+            return json(200, ctx.settings.snapshot(session));
         }
         if (path === "/desk/folder" && post) {
             const workspace = validateFolder((await readJson(req))["path"]);
@@ -89,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/env.js

@@ -96,6 +96,8 @@ export async function startFromEnv(options = {}) {
         ...(options.port !== undefined ? { port: options.port } : {}),
         ...(process.env["KISO_WEB_TOKEN"] !== undefined ? { token: process.env["KISO_WEB_TOKEN"] } : {}),
         sanitizer: process.env["KISO_WEB_SANITIZER"] === "default" ? "default" : "web",
+        followUps: process.env["KISO_WEB_FOLLOWUP"] !== "off",
+        titles: process.env["KISO_AUTO_TITLE"] !== "off",
         ...(Number.isFinite(keepalive) && keepalive > 0 ? { keepaliveMs: keepalive } : {}),
         ...(process.env["KISO_WEB_MIN_FG_MS"] !== undefined && Number.isFinite(minFg) ? { toolLimits: { minForegroundMs: minFg } } : {}),
     });

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;
+    }
+}