@vincemakes/kiso-web 0.52.0 → 0.54.0

package/dist/main/fork.js

@@ -0,0 +1,25 @@
+import { ForkRefusedError } from "@vincemakes/kiso-runtime";
+import { Refusal } from "./files.js";
+/**
+ * Fork a Work: the runtime's SessionStore.fork (one rule for the terminal, the web app and the products, plan fork rev 2),
+ * after the run that ended at `atSeq` (absent: the last). The runtime copies the log to that run's end, writes the fork's
+ * sidecar (the parent's profile, "… (fork)", its origin) and gives the fork note to the model with the fork's first input,
+ * after the copied history: never in the system prompt, where it cost the fork's first request the whole history's cache
+ * (0% against 88% measured on co). The host still remembers the lineage for the forks it made before.
+ */
+export function forkWork(space, settings, parent, atSeq) {
+    if (!space.store.ids().includes(parent))
+        throw new Refusal(404, "no such Work in this folder");
+    let made;
+    try {
+        made = space.store.fork(parent, atSeq === undefined ? {} : { afterSeq: atSeq });
+    }
+    catch (error) {
+        if (error instanceof ForkRefusedError)
+            throw new Refusal(409, error.message.replace(/session/g, "Work"));
+        throw error;
+    }
+    const fork = { parent, title: made.origin.title, atSeq: made.origin.afterSeq, at: made.origin.at };
+    settings.forked(parent, made.id, fork);
+    return { id: made.id, fork };
+}

package/dist/main/fs-routes.js

@@ -1,12 +1,13 @@
-import { realpathSync } from "node:fs";
+import { execFileSync } from "node:child_process";
+import { readdirSync, realpathSync } from "node:fs";
 import { listDir, readPreview, readTaskLog, Refusal } from "./files.js";
 /**
- * The read doors of the page: a Work's folder (a tree, a file) and a
- * background task's log. GET only, behind the host's guard; every path is
+ * The read doors of the page: a Work's folder (a tree, a file, the list the
+ * composer's @ picks from) and a background task's log. GET only, behind the host's guard; every path is
  * judged by files.ts, a task id only by the task manager of a session that
  * exists in the Work's folder.
  */
-const SAFE_ID = /^[A-Za-z0-9._-]+$/;
+export const SAFE_ID = /^[A-Za-z0-9._-]+$/;
 export function deskRead(url, space) {
     try {
         const rel = url.searchParams.get("path") ?? "";
@@ -35,3 +36,51 @@ export function deskRead(url, space) {
         return { status: 500, body: { code: "internal", message: "unreadable" } };
     }
 }
+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, 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", ...(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 = [];
+        const walk = (dir, prefix) => {
+            try {
+                for (const e of readdirSync(dir, { withFileTypes: true })) {
+                    if (files.length > AT_CAP)
+                        return;
+                    if (AT_SKIP.has(e.name) || stops.includes(`${dir}/${e.name}`))
+                        continue;
+                    if (e.isDirectory())
+                        walk(`${dir}/${e.name}`, `${prefix}${e.name}/`);
+                    else if (e.isFile())
+                        files.push(`${prefix}${e.name}`);
+                }
+            }
+            catch {
+                // an unreadable directory adds nothing
+            }
+        };
+        walk(cwd, prefix);
+    }
+    return files;
+}

package/dist/main/git.js

@@ -0,0 +1,117 @@
+import { execFile } from "node:child_process";
+import { Refusal } from "./files.js";
+/**
+ * The rail's Changes from git, and the one write it can make on the person's word: commit the files they ticked, push the branch
+ * and open a pull request with `gh`. Reads are bounded (a timeout each, nothing on a folder outside git); the writes run only
+ * 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())))));
+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));
+async function baseOf(cwd) {
+    const head = await tryRun(cwd, "git", ["symbolic-ref", "--short", "refs/remotes/origin/HEAD"]);
+    if (head !== null)
+        return head.replace(/^origin\//, "");
+    for (const name of ["main", "master"])
+        if ((await tryRun(cwd, "git", ["rev-parse", "--verify", "--quiet", `refs/heads/${name}`])) !== null)
+            return name;
+    return null;
+}
+/** The changed paths and their two-letter codes (`git status -z`: NUL-separated, so a path with a space or a quote is read whole; a rename gives its new path). */
+async function statusOf(cwd) {
+    const out = (await run(cwd, "git", ["status", "--porcelain=v1", "-z", "--untracked-files=all"]).catch(() => "")).split("\0");
+    const map = new Map();
+    for (let i = 0; i < out.length; i++) {
+        const e = out[i];
+        if (e.length < 4)
+            continue;
+        map.set(e.slice(3), e.slice(0, 2));
+        if (e[0] === "R" || e[0] === "C")
+            i += 1; // the old path follows a rename or a copy
+    }
+    return map;
+}
+/** The base as a ref to compare with: origin's copy when there is one (what the PR is judged against), else the local branch. */
+const baseRef = async (cwd, base) => ((await tryRun(cwd, "git", ["rev-parse", "--verify", "--quiet", `refs/remotes/origin/${base}`])) !== null ? `origin/${base}` : base);
+export async function gitOf(cwd) {
+    const none = { repo: false, branch: null, base: null, ahead: 0, files: [], dirty: false, canPr: false, pr: null };
+    if ((await tryRun(cwd, "git", ["rev-parse", "--is-inside-work-tree"])) !== "true")
+        return none;
+    const branch = await tryRun(cwd, "git", ["symbolic-ref", "--short", "HEAD"]);
+    const base = await baseOf(cwd);
+    const ref = base === null ? null : await baseRef(cwd, base);
+    const fork = ref === null ? null : await tryRun(cwd, "git", ["merge-base", ref, "HEAD"]);
+    const ahead = ref === null ? 0 : Number((await tryRun(cwd, "git", ["rev-list", "--count", `${ref}..HEAD`])) ?? 0);
+    const dirty = await statusOf(cwd);
+    const numstat = fork === null ? "" : await run(cwd, "git", ["diff", "--numstat", "-z", "--no-renames", fork]).catch(() => "");
+    const files = new Map();
+    for (const entry of numstat.split("\0").filter((l) => l !== "")) {
+        const [a, r, path] = entry.split("\t");
+        files.set(path, { path, added: a === "-" ? null : Number(a), removed: r === "-" ? null : Number(r), state: "modified", dirty: dirty.has(path) });
+    }
+    for (const [path, code] of dirty) {
+        const state = code.includes("?") || code.includes("A") ? "new" : code.includes("D") ? "deleted" : "modified";
+        files.set(path, { ...(files.get(path) ?? { path, added: null, removed: null }), state, dirty: true });
+    }
+    const remote = await tryRun(cwd, "git", ["remote", "get-url", "origin"]);
+    const canPr = branch !== null && base !== null && branch !== base && remote !== null && (await ghReady(cwd));
+    let pr = null;
+    if (canPr) {
+        const json = await tryRun(cwd, "gh", ["pr", "view", "--json", "number,title,url,state,statusCheckRollup"], 6000);
+        if (json !== null) {
+            const p = JSON.parse(json);
+            const checks = p.statusCheckRollup ?? [];
+            pr = { number: p.number, title: p.title, url: p.url, state: p.state, checks: { total: checks.length, done: checks.filter((c) => c.status === "COMPLETED").length, failed: checks.filter((c) => c.conclusion === "FAILURE").length } };
+        }
+    }
+    return { repo: true, branch, base, ahead, files: [...files.values()], dirty: dirty.size > 0, canPr, pr };
+}
+/** Commit the files the person ticked, with their message: those paths only (never `git add -A`), so nothing they did not see is committed. */
+export async function commit(cwd, message, paths) {
+    if (message.trim() === "")
+        throw new Refusal(400, "a commit needs a message");
+    if (paths.length === 0)
+        throw new Refusal(400, "no file was chosen");
+    const listed = await statusOf(cwd);
+    const strange = paths.filter((p) => !listed.has(p));
+    if (strange.length > 0)
+        throw new Refusal(400, `not a changed file of this folder: ${strange.join(", ")}`);
+    await run(cwd, "git", ["add", "--", ...paths]);
+    await run(cwd, "git", ["commit", "-m", message, "--", ...paths]).catch((e) => {
+        throw new Refusal(409, `git refused the commit: ${e.message}`);
+    });
+    return { sha: (await run(cwd, "git", ["rev-parse", "--short", "HEAD"])).trim() };
+}
+/** Push the branch and open its pull request into the base; refused with the reason when the folder cannot. */
+export async function openPr(cwd, title, body) {
+    const g = await gitOf(cwd);
+    if (!g.canPr || g.branch === null || g.base === null)
+        throw new Refusal(409, "a pull request needs a branch other than the base, a remote named origin, and gh signed in");
+    if (g.dirty)
+        throw new Refusal(409, "commit the changes first: a pull request carries commits, not the working tree");
+    if (g.ahead === 0)
+        throw new Refusal(409, `${g.branch} has no commit that ${g.base} does not have`);
+    if (title.trim() === "")
+        throw new Refusal(400, "a pull request needs a title");
+    await run(cwd, "git", ["push", "-u", "origin", "HEAD"], 60_000).catch((e) => {
+        throw new Refusal(409, `git push failed: ${e.message}`);
+    });
+    const out = await run(cwd, "gh", ["pr", "create", "--base", g.base, "--head", g.branch, "--title", title, "--body", body], 60_000).catch((e) => {
+        throw new Refusal(409, `gh pr create failed: ${e.message}`);
+    });
+    const url = out.trim().split("\n").pop() ?? "";
+    return { number: Number(/\/pull\/(\d+)/.exec(url)?.[1] ?? 0), url };
+}
+/** The dialog's starting draft from the branch's own commits: one commit gives its subject; several, the branch's name and a list. */
+export async function prDraft(cwd) {
+    const g = await gitOf(cwd);
+    if (g.base === null)
+        return { title: "", body: "" };
+    const ref = await baseRef(cwd, g.base);
+    const subjects = ((await tryRun(cwd, "git", ["log", "--format=%s", `${ref}..HEAD`])) ?? "").split("\n").filter((s) => s !== "").reverse();
+    if (subjects.length === 1)
+        return { title: subjects[0], body: "" };
+    return { title: (g.branch ?? "").replace(/^[^/]*\//, "").replace(/[-_]/g, " "), body: subjects.map((s) => `- ${s}`).join("\n") };
+}

package/dist/main/history.js

@@ -13,16 +13,22 @@ import { sessionFolders } from "@vincemakes/kiso-code/config";
  */
 const MIN_AGE_MS = 3_000;
 const MAX_ROWS = 400;
-/** The folder's files as one string: it changes when a log is added or written. */
+/** 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) {
     let count = 0;
     let bytes = 0;
     let newest = 0;
     for (const name of readdirSync(dir)) {
-        if (!name.endsWith(".jsonl"))
+        const meta = name.endsWith(".meta.json");
+        if (!name.endsWith(".jsonl") && !meta)
             continue;
         try {
             const s = statSync(join(dir, name));
+            if (meta) {
+                newest = Math.max(newest, s.mtimeMs);
+                continue;
+            }
             if (s.size === 0)
                 continue;
             count += 1;
@@ -38,13 +44,15 @@ function printOf(dir) {
 export class History {
     #home;
     #live;
+    #marksOf;
     #reads = new Map();
     #queue = [];
     #worker = null;
     #inflight = null;
-    constructor(home, live) {
+    constructor(home, live, marksOf = () => ({})) {
         this.#home = home;
         this.#live = live;
+        this.#marksOf = marksOf;
     }
     /** `fresh` names a folder whose listing is read again now, whatever its age. */
     async snapshot(current, fresh) {
@@ -69,6 +77,9 @@ export class History {
             const key = basename(folder.dir);
             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),
                     id: meta.id,
                     key,
                     folder: basename(folder.workspace),
@@ -103,18 +114,21 @@ export class History {
         this.#inflight = dir;
         const print = printOf(dir);
         const worker = (this.#worker ??= new Worker(new URL("./history-worker.js", import.meta.url)));
+        // both listeners go when either answers: one read, one pair (the worker lives across reads, so a kept listener piles up)
         const done = (message) => {
             worker.off("message", done);
+            worker.off("error", failed);
             // an unreadable folder is remembered empty: it is tried again when its files change
             this.#reads.set(dir, { print, metas: message.metas ?? [], at: Date.now() });
             this.#inflight = null;
             this.#pump();
         };
-        worker.on("message", done);
-        worker.once("error", (error) => {
+        const failed = (error) => {
             this.#worker = null;
             done({ dir, error: error.message });
-        });
+        };
+        worker.on("message", done);
+        worker.on("error", failed);
         worker.postMessage({ dir });
     }
     close() {

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");
@@ -28,6 +29,17 @@ export async function startHost(options) {
         sanitizer: options.sanitizer ?? "web",
         ...(options.keepaliveMs !== undefined ? { keepaliveMs: options.keepaliveMs } : {}),
         ...(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);
@@ -47,11 +59,16 @@ 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) => {
+        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);
@@ -59,7 +76,9 @@ export async function startHost(options) {
     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/names.js

@@ -0,0 +1,15 @@
+import { readSessionName, writeSessionName } from "@vincemakes/kiso-runtime/internal";
+/** A Work's name: the runtime's own session-name store, the one the terminal's rename writes (a file beside the log, never the log).
+ *  The runtime's titles read it (the listing re-reads a folder whose name file changed); empty clears it; at most 120 characters. */
+export function rename(dir, sessionId, name) {
+    const clean = name.replace(/\s+/g, " ").trim().slice(0, 120);
+    writeSessionName(dir, sessionId, clean === "" ? null : clean);
+    return clean === "" ? null : clean;
+}
+/** Whether a Work has a name: the person's, or a title written before. */
+export const named = (dir, sessionId) => readSessionName(dir, sessionId) !== null;
+/** A title made from the Work's first message, kept only while the Work is still unnamed: the person's name wins. */
+export function titleIfUnnamed(dir, sessionId, title) {
+    if (title !== "" && !named(dir, sessionId))
+        writeSessionName(dir, sessionId, title);
+}

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,9 +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 { 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._-]+$/;
+/** 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;
@@ -63,9 +68,12 @@ export class Settings {
         applyEffortDeclarations(merged);
         return merged;
     }
-    /** The profile in use: the person's pick if it still exists, else the configuration's own default. */
-    #chosen(config) {
+    /** The profile in use: the Work's own pick, else the person's pick for new Works, if it still exists, else the configuration's own default. */
+    #chosen(config, session) {
         const models = config.models ?? {};
+        const own = session === undefined ? undefined : this.#read().works?.[session]?.profile;
+        if (own !== undefined && models[own] !== undefined)
+            return own;
         const picked = this.#read().profile;
         if (picked !== undefined && models[picked] !== undefined)
             return picked;
@@ -78,12 +86,12 @@ export class Settings {
         if (this.#demo !== null)
             return this.#demo(ctx === undefined ? 0 : fauxSkip(ctx.sessionsDir, ctx.sessionId));
         const config = this.#config();
-        const name = this.#chosen(config);
+        const name = this.#chosen(config, ctx?.sessionId);
         if (name === null)
             throw new Error("no model is configured: add a profile to ~/.kiso/config.json (see the terminal's docs) and choose it in Settings");
         const profile = config.models[name];
         const auth = authForProfile(name, profile);
-        const effort = startingEffort(profile, preferences().effort?.[name]);
+        const effort = startingEffort(profile, this.#effortOf(name, ctx?.sessionId));
         return {
             kind: "profile",
             name,
@@ -93,6 +101,57 @@ export class Settings {
             ...(effort !== null ? { reasoning: { thinking: "default", effort } } : {}),
         };
     }
+    /** The effort a Work asked for (when it is one of the profile's levels), else the terminal's remembered one for the profile. */
+    #effortOf(name, session) {
+        const own = session === undefined ? undefined : this.#read().works?.[session]?.effort;
+        return own ?? preferences().effort?.[name];
+    }
+    /** A Work's own model choice (to put back when its rebuild is refused). */
+    workOf(session) {
+        return this.#read().works?.[session];
+    }
+    /** A fork starts with its parent's own tier, model and effort, and remembers where it came from. */
+    forked(parent, child, fork) {
+        const own = this.#read();
+        const tier = own.tiers?.[parent];
+        const work = own.works?.[parent];
+        this.write({
+            ...(tier !== undefined ? { tiers: { ...own.tiers, [child]: tier } } : {}),
+            ...(work !== undefined ? { works: { ...own.works, [child]: work } } : {}),
+            forks: { ...own.forks, [child]: fork },
+        });
+    }
+    forkOf(session) {
+        return this.#read().forks?.[session];
+    }
+    /** 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 });
+    }
+    /** 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;
+        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), unread: (own.unread ?? []).filter((id) => id !== session), prs: drop(own.prs) });
+    }
+    restoreWork(session, work) {
+        const { [session]: _, ...rest } = this.#read().works ?? {};
+        this.write({ works: work === undefined ? rest : { ...rest, [session]: work } });
+    }
     /** The person's own test-runner commands (`checks` in the configuration), for the compaction phase rule. */
     checks() {
         return Object.values(this.#config().checks ?? {});
@@ -122,21 +181,35 @@ export class Settings {
     snapshot(session) {
         const config = this.#config();
         const models = config.models ?? {};
-        const name = this.#chosen(config);
+        const name = this.#chosen(config, session);
         const profile = name === null ? undefined : models[name];
         const levels = profile === undefined ? null : effortOptions(profile);
         return {
-            profiles: Object.entries(models).map(([n, p]) => ({ name: n, model: p.model, available: profileAvailable(p) })),
+            profiles: Object.entries(models).map(([n, p]) => ({ name: n, model: p.model, available: profileAvailable(p), images: readsImages(p) })),
             profile: name,
-            effort: levels === null || name === null ? null : { ...levels, current: startingEffort(profile, preferences().effort?.[name]) },
+            effort: levels === null || name === null ? null : { ...levels, current: startingEffort(profile, this.#effortOf(name, session)) },
             mode: this.tierOf(session),
             setup: this.#setup(config, name),
             modes: OFFERED_MODES.map((value) => ({ value, label: MODE_LABEL[value] })),
             signIn: name === null ? { ok: false, text: "No model is configured." } : signInOf(name, profile),
         };
     }
+    /** Apply a patch; returns the Work whose model binding it changed (the host rebuilds that Work), else null. */
     apply(patch) {
         const config = this.#config();
+        const session = patch.session !== undefined && SAFE_SESSION.test(patch.session) ? patch.session : undefined;
+        if (session !== undefined && (patch.profile !== undefined || patch.effort !== undefined)) {
+            // one Work's model: its own profile and effort, the new-Work default untouched
+            const was = this.workOf(session) ?? {};
+            const profileName = patch.profile !== undefined && config.models?.[patch.profile] !== undefined ? patch.profile : (was.profile ?? this.#chosen(config, session) ?? undefined);
+            const profile = profileName === undefined ? undefined : config.models?.[profileName];
+            const effort = patch.effort !== undefined && profile !== undefined && effortOptions(profile)?.levels.includes(patch.effort) === true ? patch.effort : patch.profile !== undefined ? undefined : was.effort;
+            const next = { ...(profileName !== undefined ? { profile: profileName } : {}), ...(effort !== undefined ? { effort } : {}) };
+            if (next.profile === was.profile && next.effort === was.effort)
+                return null;
+            this.write({ works: { ...this.#read().works, [session]: next } });
+            return session;
+        }
         if (patch.profile !== undefined && config.models?.[patch.profile] !== undefined) {
             this.write({ profile: patch.profile });
             // choosing a profile that can run ends the tour
@@ -152,9 +225,10 @@ export class Settings {
                 this.#default = patch.mode;
                 this.write({ mode: patch.mode });
             }
-            else if (/^[A-Za-z0-9._-]+$/.test(patch.session))
+            else if (SAFE_SESSION.test(patch.session))
                 this.write({ tiers: { ...this.#read().tiers, [patch.session]: patch.mode } });
         }
+        return null;
     }
 }
 /** Where a profile's sign-in comes from, in words; the secret is never part of it. */