parawatch 0.3.15 → 0.3.17

package/README.md

@@ -46,6 +46,8 @@ parawatch sync setup ~/agent-sync/parawatch --device pc  --adapter syncthing
 
 Cards, answers and the list of running sessions then show on every machine, each marked with where it came from. Agent logs stay on the machine that wrote them. The details are in [More than one machine](docs/sync.md).
 
+Or run a [relay](docs/relay.md) of your own, a small server that carries the folder sealed end to end, so the server cannot read your cards or sessions: `parawatch relay setup <url> <folder>` on the first machine, `parawatch relay join <code> <folder>` on the others. With a relay, a phone can answer cards too: [On a phone](docs/phone.md).
+
 ## How an answer gets back
 
 <picture>
@@ -133,6 +135,8 @@ This writes a short block that tells the agents in that project to say what they
 | [Pull requests](docs/pull-requests.md) | What is read from GitHub, and its settings |
 | [Observed agents](docs/observed-agents.md) | Which logs are read, run states, adding a runtime |
 | [More than one machine](docs/sync.md) | Cards and answers across machines through a synced folder |
+| [The relay](docs/relay.md) | Your own server that carries the shared folder, sealed end to end |
+| [The shared folder](docs/protocol.md) | The files machines exchange, for anyone writing a client |
 | [Storage](docs/storage.md) | Where everything is kept, notifications |
 | [Installing, updating, removing](docs/install.md) | The three parts in detail, updates, `parawatch doctor`, uninstalling |
 | [Building on it](docs/integrations.md) | `status --json`, `watch`, the panel package |

package/dist/adapters/claudeCode.js

@@ -239,7 +239,17 @@ export function readClaudeTail(recs, kind) {
             // the human wrote (a pasted block, a command's output): whatever the last wrap-up asked is answered
             wrapUp = undefined;
         }
+        if (str(r.permissionMode))
+            out.permissionMode = str(r.permissionMode);
         if (r.type === "assistant") {
+            const msg = isObj(r.message) ? r.message : {};
+            const model = str(msg.model);
+            // a message Claude Code makes up itself (an interrupt, an error) names no real model
+            if (model && !model.startsWith("<")) {
+                out.model = model;
+                out.effort = str(r.effort);
+                out.fast = isObj(msg.usage) && msg.usage.speed === "fast" ? true : undefined;
+            }
             const w = blocks(r).find((b) => b.type === "tool_use" && WRAP_UP.test(String(b.name)));
             if (w)
                 wrapUp = { ...(w.input ?? {}), at: ts };
@@ -427,6 +437,12 @@ export const claudeCode = {
         return runs;
     },
 };
+const PERMISSION_MODES = { acceptEdits: "accepts edits", plan: "plan mode", bypassPermissions: "bypasses permissions", dontAsk: "never asks", auto: "auto mode" };
+/** The model, effort and options a Claude Code run's last answer ran with. */
+function claudeSettings(t) {
+    const options = [t.fast ? "fast" : undefined, t.permissionMode ? PERMISSION_MODES[t.permissionMode] : undefined].filter((x) => !!x);
+    return { model: t.model, effort: t.effort, options: options.length ? options : undefined };
+}
 function readSession(file, now) {
     const id = path.basename(file, ".jsonl");
     const base = { id, runtime: "claude-code", kind: "session", title: id.slice(0, 8), state: "unknown", source: file };
@@ -451,6 +467,7 @@ function readSession(file, now) {
             prompt: head.prompt ? oneLine(head.prompt, 400) : undefined,
             activity: logActivity(file, now),
             pendingTool: tail.pendingTool,
+            ...claudeSettings(tail),
         };
         applyStall(run, tail.pendingTimeoutMs, now, newestMtime(tail.pendingOutputs));
         // in the log a permission prompt and a long command look the same; the hook can tell them apart
@@ -477,7 +494,8 @@ function readSubagent(file, now) {
             touched: work.touched.length ? work.touched : undefined,
             createdPrs: work.createdPrs.length ? work.createdPrs : undefined,
             title: str(meta.description) || (head.prompt ? oneLine(head.prompt, 60) : base.title),
-            model: str(meta.model),
+            ...claudeSettings(tail),
+            model: tail.model ?? str(meta.model),
             cwd: tail.cwd || head.cwd,
             startedAt: head.startedAt,
             lastActivity: tail.lastActivity,

package/dist/adapters/codex.js

@@ -69,6 +69,22 @@ export function promptFromRaw(raw) {
     }
     return undefined;
 }
+const SANDBOXES = { "read-only": "read-only", "workspace-write": "writes in its folders", "danger-full-access": "full access" };
+const APPROVALS = { never: "never asks", "on-request": "asks when it wants to", "on-failure": "asks on failure", untrusted: "asks before most commands" };
+/** The model, effort and options of the last turn, from Codex's `turn_context` lines. */
+export function codexSettings(lines) {
+    let tc;
+    for (const r of lines)
+        if (isObj(r) && r.type === "turn_context" && isObj(r.payload))
+            tc = r.payload;
+    if (!tc)
+        return {};
+    const sp = tc.sandbox_policy;
+    const sandbox = typeof sp === "string" ? sp : isObj(sp) ? str(sp.type) : undefined;
+    const approval = str(tc.approval_policy);
+    const options = [sandbox ? (SANDBOXES[sandbox] ?? sandbox) : undefined, approval ? (APPROVALS[approval] ?? approval) : undefined].filter((x) => !!x);
+    return { model: str(tc.model), effort: str(tc.effort) ?? str(tc.reasoning_effort) ?? (isObj(tc.collaboration_mode) && isObj(tc.collaboration_mode.settings) ? str(tc.collaboration_mode.settings.reasoning_effort) : undefined), options: options.length ? options : undefined };
+}
 export function readCodexLog(head, tail, rawHead) {
     const meta = head.map(payload).find((p, i) => p && isObj(head[i]) && head[i].type === "session_meta");
     const id = str(meta?.id) ?? str(meta?.session_id) ?? "unknown";
@@ -98,6 +114,8 @@ export function readCodexLog(head, tail, rawHead) {
         startedAt: str(meta?.timestamp) ?? (isObj(head[0]) ? str(head[0].timestamp) : undefined),
         state: "working",
         prompt: prompt ? oneLine(prompt, 400) : undefined,
+        // the last turn's settings: a later turn may change them (`codex exec resume -m ...`)
+        ...codexSettings([...head, ...tail]),
     };
     let lastStart = -1;
     let lastDone = -1;

package/dist/bin/cli.js

@@ -2,15 +2,17 @@
 import { execFileSync } from "node:child_process";
 import fs from "node:fs";
 import { Command } from "commander";
-import { UserError, addProject, answerCard, beatRun, claimSession, closeCard, dismissCard, endedSessions, handCard, handPr, leadOf, makeLead, commentCard, inboxScope, editCard, endRun, hideRun, unhideRun, linkPr, listeners, listenersFor, noteRun, openCard, prEvent, findCard, readInbox, readState, removeProject, startListening, startRun, unlinkPr, waitInbox, } from "../core/ops.js";
+import { UserError, addProject, answerCard, beatRun, claimSession, closeCard, dismissCard, endedSessions, handCard, handPr, leadOf, makeLead, commentCard, inboxScope, editCard, endRun, hideRun, unhideRun, linkPr, listeners, listenersFor, noteRun, openCard, prEvent, findCard, readInbox, readState, sameSession, removeProject, startListening, startRun, unlinkPr, waitInbox, } from "../core/ops.js";
 import { githubConfig, readCache, resolvePrRef, syncGithub, prViews } from "../core/github.js";
 import { recordPrompt } from "../core/prompts.js";
 import { callingSubagent } from "../adapters/claudeCode.js";
 import { digest, digestText, localDate } from "../core/digest.js";
-import { everywhere, readEvents } from "../core/store.js";
+import { everywhere, readConfig, readEvents, sharedDir, writeConfig } from "../core/store.js";
 import { followEvents } from "../core/follow.js";
 import { adapterNames, setRoot, setupSync, syncAdapter, syncStatus, touchDevice } from "../core/sync.js";
 import { syncText } from "../core/format.js";
+import { RelayClient, RelayMirror, joinCode, newKey, readJoinCode, relayConfig, takeMirrorLock } from "../core/relay.js";
+import { createRelayServer } from "../relay/server.js";
 import { collectRuns, shareRunsDue } from "../core/runs.js";
 import { askRows, cardDetail, cardLine, cardRows, inboxLine, prRows, runsTree, view } from "../core/format.js";
 import { hookContext, notify, removeInstructions, writeInstructions } from "../core/integrate.js";
@@ -372,10 +374,17 @@ program
         id = callingSubagent(id, /\bparawatch\b.*\bclaim\b/) ?? id;
     if (o.kind !== undefined && o.kind !== "scheduled")
         throw new UserError("--kind can only be 'scheduled'");
+    // a lead that says done stops leading: say so, since it may only have finished one task
+    const before = o.done?.trim() ? readState() : undefined;
+    const ledBefore = before ? leadOf(before, endedSessions(before))(o.project?.trim() || before.claims.find((x) => sameSession(x.session, id))?.project) : undefined;
     const c = claimSession({ session: id, project: o.project, task: o.task, role: o.role, title: o.title, kind: o.kind, done: o.done });
     // a new lead: earlier leads of the project step down, and it takes what no session got
     const handed = o.role === "lead" && !c.done ? makeLead(c.project, id).handed : [];
     process.stdout.write(`${id.slice(0, 8)} → ${c.project}${c.task ? ` / ${c.task}` : ""}${c.role ? ` (${c.role})` : ""}${c.done ? " · done" : ""}${handed.length ? `; handed ${handed.join(", ")}` : ""}\n`);
+    if (c.done && ledBefore && sameSession(ledBefore, id)) {
+        process.stdout.write(`This session no longer leads ${c.project}: what no session owns there now waits in parawatch until a session claims --role lead.\n` +
+            `If it goes on working, claim its next work instead of --done: parawatch claim -p ${c.project} -t <task> --role lead\n`);
+    }
 });
 // ------------------------------------------------------------------ pull requests
 const pr = program.command("pr").description("pull requests and what they wait on (reads GitHub through gh)");
@@ -648,6 +657,103 @@ sync
     const d = setRoot(name, folder, VERSION);
     process.stdout.write(Object.entries(d.roots ?? {}).map(([k, v]) => `${k}  ${v}`).join("\n") + (d.roots ? "\n" : "No named folders.\n"));
 });
+// ------------------------------------------------------------------ the relay
+const relay = program.command("relay").description("keep the shared folder in step through a parawatch relay server instead of a sync tool");
+/** Point this machine's shared folder at a relay, keeping what config.json already has. */
+function useRelay(folder, device, c) {
+    const r = setupSync({ dir: folder, device, adapter: "relay", version: VERSION });
+    const cfg = readConfig();
+    writeConfig({ ...cfg, sync: { ...(cfg.sync ?? {}), adapter: "relay", relay: c } });
+    return r;
+}
+relay
+    .command("setup <url> <folder>")
+    .description("make a space on a relay and share this machine's folder through it; prints the code for your other machines")
+    .option("-d, --device <name>", "this machine's name in the folder (a-z, 0-9, -); defaults to the host name")
+    .option("--invite <invite>", "the relay's invite (or set PARAWATCH_RELAY_INVITE)")
+    .action(async (url, folder, o) => {
+    const invite = o.invite ?? process.env.PARAWATCH_RELAY_INVITE;
+    if (!invite)
+        throw new UserError("the relay needs its invite to make a space: pass --invite or set PARAWATCH_RELAY_INVITE");
+    const base = url.replace(/\/+$/, "");
+    const made = await RelayClient.createSpace(base, invite);
+    const c = { url: base, space: made.space, token: made.token, key: newKey() };
+    const r = useRelay(folder, o.device, c);
+    process.stdout.write([
+        `This machine shares ${r.dir} as "${r.device}" through ${base}.`,
+        "On each of your other machines, run:",
+        "",
+        `  parawatch relay join <code> <folder> --device <its name>`,
+        "",
+        "with this code. It opens your space and its key: keep it to your own machines.",
+        "",
+        joinCode(c),
+        "",
+        "The folder is kept in step while the app runs, or while `parawatch relay run` does.",
+    ].join("\n") + "\n");
+});
+relay
+    .command("join <code> <folder>")
+    .description("share this machine's folder through the relay another machine set up")
+    .option("-d, --device <name>", "this machine's name in the folder (a-z, 0-9, -); defaults to the host name")
+    .action(async (code, folder, o) => {
+    const c = readJoinCode(code);
+    await new RelayClient(c).changes(0);
+    const r = useRelay(folder, o.device, c);
+    process.stdout.write(`This machine shares ${r.dir} as "${r.device}" through ${c.url}. The folder is kept in step while the app runs, or while \`parawatch relay run\` does.\n`);
+});
+relay
+    .command("code")
+    .description("print the code that lets another of your machines join (it holds the space key)")
+    .action(() => {
+    const c = relayConfig();
+    if (!c)
+        throw new UserError("this machine does not use a relay");
+    process.stdout.write(joinCode(c) + "\n");
+});
+relay
+    .command("run")
+    .description("keep the shared folder in step with the relay until stopped (the app does this while it runs)")
+    .option("--once", "bring it up to date once and stop")
+    .action(async (o) => {
+    const c = relayConfig();
+    const dir = sharedDir();
+    if (!c || !dir)
+        throw new UserError("this machine does not use a relay: run `parawatch relay setup` or `parawatch relay join` first");
+    const unlock = takeMirrorLock();
+    if (!unlock)
+        throw new UserError("another parawatch (the app, or another `relay run`) already keeps this folder in step");
+    const m = new RelayMirror({ dir, config: c, log: (l) => process.stderr.write(l + "\n") });
+    try {
+        if (o.once) {
+            const r = await m.once();
+            process.stdout.write(`brought down ${r.pulled}, sent up ${r.pushed}\n`);
+            return;
+        }
+        const stop = () => m.stop();
+        process.once("SIGINT", stop);
+        process.once("SIGTERM", stop);
+        process.stderr.write(`keeping ${dir} in step with ${c.url}; stop with Ctrl-C\n`);
+        await m.run();
+    }
+    finally {
+        unlock();
+    }
+});
+relay
+    .command("serve")
+    .description("run a relay server (for your own server; machines reach it over HTTPS through a proxy in front)")
+    .option("--port <n>", "port to listen on", "8787")
+    .option("--host <host>", "address to listen on", "127.0.0.1")
+    .option("--data <folder>", "where spaces are kept", "~/.parawatch-relay")
+    .action((o) => {
+    const invite = process.env.PARAWATCH_RELAY_INVITE;
+    const data = o.data.startsWith("~") ? o.data.replace(/^~/, process.env.HOME ?? process.env.USERPROFILE ?? "") : o.data;
+    const server = createRelayServer({ dataDir: data, invite, log: (l) => process.stdout.write(`${new Date().toISOString()} ${l}\n`) });
+    server.listen(Number(o.port), o.host, () => {
+        process.stdout.write(`relay on http://${o.host}:${o.port}, spaces in ${data}${invite ? "" : " (no PARAWATCH_RELAY_INVITE: no new spaces can be made)"}\n`);
+    });
+});
 program
     .command("hook <runtime>")
     .description("hook entry point; 'claude-code' reads the hook JSON on stdin")

package/dist/core/codexChat.js

@@ -132,6 +132,7 @@ export function readChatLines(head, tail, file = "") {
     const items = new Map();
     let started = -1;
     let ended = -1;
+    let turnAt;
     let structured = false;
     const fallback = [];
     tail.forEach((r, i) => {
@@ -148,8 +149,10 @@ export function readChatLines(head, tail, file = "") {
             return;
         }
         if (r.type === "event_msg") {
-            if (p.type === "task_started")
+            if (p.type === "task_started") {
                 started = i;
+                turnAt = at;
+            }
             else if (p.type === "task_complete")
                 ended = i;
             else if (p.type === "turn_aborted") {
@@ -186,6 +189,7 @@ export function readChatLines(head, tail, file = "") {
         ...(firstUser ? { title: firstUser.text.split("\n")[0].slice(0, 80) } : {}),
         settings,
         working: started > ended,
+        ...(started > ended && turnAt ? { turnStarted: turnAt } : {}),
         items: all.slice(-MAX_ITEMS),
         earlier: Math.max(0, all.length - MAX_ITEMS),
     };
@@ -230,7 +234,7 @@ export function findCodex(env = process.env, platform = process.platform) {
     const dirs = [
         ...(env.PATH ?? "").split(path.delimiter),
         ...(platform === "win32"
-            ? [env.APPDATA && path.join(env.APPDATA, "npm"), env.LOCALAPPDATA && path.join(env.LOCALAPPDATA, "Programs", "codex")]
+            ? [env.APPDATA && path.join(env.APPDATA, "npm"), env.LOCALAPPDATA && path.join(env.LOCALAPPDATA, "Programs", "OpenAI", "Codex", "bin"), env.LOCALAPPDATA && path.join(env.LOCALAPPDATA, "Programs", "codex")]
             : ["/opt/homebrew/bin", "/usr/local/bin", path.join(home, ".local", "bin"), path.join(home, ".npm-global", "bin"), path.join(home, ".volta", "bin"), path.join(home, ".bun", "bin")]),
     ].filter((d) => !!d);
     for (const d of dirs) {

package/dist/core/format.js

@@ -1,3 +1,4 @@
+import { settingsLine } from "./model.js";
 export function ago(iso, now = Date.now()) {
     if (!iso)
         return "?";
@@ -374,7 +375,7 @@ export function runsTree(runs, v = PLAIN, now = Date.now(), indent = "") {
             const age = paint(v, ago(r.lastActivity, now).padStart(4), "dim");
             const dev = devW ? "  " + paint(v, pad(fit(r.device ?? "", devW), devW), "cyan") : "";
             const src = (r.projectSource && SOURCE_NOTE[r.projectSource]) || "";
-            const wide = v.wide ? "  " + paint(v, pad(fit(`${r.kind === "subagent" ? r.model ?? "subagent" : r.runtime} ${r.id.slice(0, 8)}${src ? " " + src : ""}`, wideW - 2), wideW - 2), "dim") : "";
+            const wide = v.wide ? "  " + paint(v, pad(fit(`${r.runtime} ${r.id.slice(0, 8)}${settingsLine(r) ? " " + settingsLine(r) : ""}${src ? " " + src : ""}`, wideW - 2), wideW - 2), "dim") : "";
             const restW = v.width - nameW - 2 - 4 - devCol - wideW - 2;
             const whatPaint = r.error || r.state === "stalled" || r.state === "failed" || r.asks?.blocked ? ["red"] : r.asks ? ["yellow"] : ended ? ["dim"] : [];
             const what = restW >= 8 ? "  " + paint(v, fit(whatText(r), restW), ...whatPaint) : "";

package/dist/core/github.js

@@ -320,6 +320,11 @@ export function waitingOn(p) {
         return { what: "no reviewer", who: author };
     return { what: "merge", who: author };
 }
+/** A reading of a PR from before anything happened to it: open, CI running, its reviews and comments as now. */
+function unseen(p) {
+    // a PR already finished reports only that, not the CI it had
+    return { ...p, state: "open", ci: p.state === "open" ? "PENDING" : p.ci, mergeable: p.state === "open" ? undefined : p.mergeable, queue: p.queue };
+}
 const REVIEW_CHANGE = { APPROVED: "approved", CHANGES_REQUESTED: "changes_requested", COMMENTED: "review", DISMISSED: "review" };
 /** The events between two readings of the same PR. */
 export function changesBetween(old, now) {
@@ -348,13 +353,18 @@ export function changesBetween(old, now) {
         out.push({ change: "closed" });
     return out;
 }
-/** Next cache and the events it implies, given the previous cache and a fresh reading. */
-export function nextCache(prev, fresh, hosts, at) {
+/**
+ * Next cache and the events it implies, given the previous cache and a fresh reading. `newlyLinked`
+ * names PRs a session linked since the previous reading: one first seen with its CI already done,
+ * or already merged or closed, reports that, since no earlier reading can show it changing (a CI
+ * of a minute ends before the first reading).
+ */
+export function nextCache(prev, fresh, hosts, at, newlyLinked = new Set()) {
     const old = new Map(prev.prs.map((p) => [p.key, p]));
     const events = [];
     const since = {};
     for (const p of fresh) {
-        const was = old.get(p.key);
+        const was = old.get(p.key) ?? (newlyLinked.has(p.key) ? unseen(p) : undefined);
         if (was) {
             for (const c of changesBetween(was, p)) {
                 events.push({ type: "pr.change", pr: prRef(p.host, p.repo, p.number, p.url), change: c.change, title: p.title, by: c.by, source: "github" });
@@ -460,10 +470,14 @@ export async function syncGithub(opts) {
             });
         }
         failedHere = 0;
-        // PRs linked to sessions, and ones seen before, are read by number so merges and closes show
+        // PRs linked to sessions, and ones seen before, are read by number so merges and closes show.
+        // The newest links first, leaving out the ones already seen finished: the number read is capped.
         const extra = new Map();
-        for (const l of opts.state.prLinks.values())
-            extra.set(l.pr.key, l.pr);
+        const finished = new Set(prev.finished ?? []);
+        const links = [...opts.state.prLinks.values()].reverse().sort((a, b) => b.at.localeCompare(a.at));
+        for (const l of links)
+            if (!finished.has(l.pr.key))
+                extra.set(l.pr.key, l.pr);
         const cutoff = new Date(Date.now() - cfg.maxAgeDays * 86_400_000).toISOString();
         for (const p of prev.prs)
             if (p.state === "open" && p.updatedAt >= cutoff)
@@ -489,7 +503,11 @@ export async function syncGithub(opts) {
             const latest = readCache();
             if (latest.fetchedAt && latest.fetchedAt > started)
                 return latest; // someone else was faster
-            const { cache, events } = nextCache(latest, fresh, hosts, started);
+            // a first reading of everything reports nothing; after that, links made since the last reading are new
+            const newly = new Set(latest.fetchedAt ? links.filter((l) => l.at > latest.fetchedAt).map((l) => l.pr.key) : []);
+            const { cache, events } = nextCache(latest, fresh, hosts, started, newly);
+            const done = new Set([...(latest.finished ?? []), ...fresh.filter((p) => p.state !== "open").map((p) => p.key)]);
+            cache.finished = [...done].filter((k) => opts.state.prLinks.has(k));
             if (errors.length)
                 cache.error = errors.join("; ");
             appendLocked((log) => dropReported(events, log, latest.fetchedAt));

package/dist/core/log.js

@@ -0,0 +1,69 @@
+/** Merge per-device logs, each already in its own order, into one. */
+export function mergeLogs(lists) {
+    const at = lists.map(() => 0);
+    const out = [];
+    for (;;) {
+        let pick = -1;
+        for (let i = 0; i < lists.length; i++) {
+            const ev = lists[i][at[i]];
+            if (!ev)
+                continue;
+            if (pick < 0) {
+                pick = i;
+                continue;
+            }
+            const best = lists[pick][at[pick]];
+            if (ev.ts < best.ts || (ev.ts === best.ts && (ev.dev ?? "") < (best.dev ?? "")))
+                pick = i;
+        }
+        if (pick < 0)
+            return out;
+        out.push(lists[pick][at[pick]++]);
+    }
+}
+export function parseEventLines(text, device) {
+    const out = [];
+    for (const line of text.split("\n")) {
+        if (!line.trim())
+            continue;
+        try {
+            const ev = JSON.parse(line);
+            if (typeof ev.seq !== "number" || typeof ev.type !== "string")
+                continue;
+            if (device)
+                ev.dev = device;
+            out.push(ev);
+        }
+        catch {
+            // a torn or hand-edited line; keep going
+        }
+    }
+    return out;
+}
+/** The card an event is about, if any. */
+function cardOf(e) {
+    if (e.type === "card.open")
+        return e.card.id;
+    const c = e.card;
+    return typeof c === "string" ? c : undefined;
+}
+/**
+ * When a writer may stamp its next event: now, but never before its own last event (each log
+ * stays in order) and, for an event about a card, after everything already said about that card.
+ * Logs merge by time and then by machine name, so an answer stamped in the same millisecond as the
+ * card on another machine, or by a clock running behind, would sort before the card and be lost.
+ */
+export function stampFor(events, own, card, now) {
+    let t = now;
+    for (const e of events) {
+        const at = Date.parse(e.ts);
+        if (!Number.isFinite(at))
+            continue;
+        if (own(e) && at > t)
+            t = at;
+        if (typeof card === "string" && cardOf(e) === card && at >= t)
+            t = at + 1;
+    }
+    return t;
+}
+//# sourceMappingURL=log.js.map

package/dist/core/model.js

@@ -0,0 +1,18 @@
+const CLAUDE = /^claude-([a-z]+)-(\d+)-(\d+)(?:-\d{8})?(\[1m\])?$/;
+export function shortModel(model) {
+    const m = CLAUDE.exec(model);
+    if (m)
+        return `${m[1]} ${m[2]}.${m[3]}${m[4] ? " 1M" : ""}`;
+    return model.replace(/-\d{8}$/, "");
+}
+/** The model and effort in a few words, `opus 5.5 high`; fast mode too, as it changes the speed. */
+export function settingsLine(r) {
+    const parts = [r.model ? shortModel(r.model) : undefined, r.effort, r.options?.includes("fast") ? "fast" : undefined].filter(Boolean);
+    return parts.length ? parts.join(" ") : undefined;
+}
+/** Everything it runs with, for a tooltip or a detail line: `claude-opus-5-5 · effort high · bypasses permissions`. */
+export function settingsFull(r) {
+    const parts = [r.model, r.effort ? `effort ${r.effort}` : undefined, ...(r.options ?? [])].filter(Boolean);
+    return parts.length ? parts.join(" · ") : undefined;
+}
+//# sourceMappingURL=model.js.map