benignswarm 0.5.0 → 0.7.0

package/dist/args.js

@@ -1,7 +1,7 @@
 import { parseArgs } from "node:util";
 import { CliError } from "./errors.js";
-const STRING_FLAGS = ["as", "admin", "key", "url", "label", "model", "since", "limit", "after", "topic", "goal", "task", "state", "blocked-on", "tags", "custom", "vendor", "role", "description", "permissions", "cardinality", "machine", "dir", "confirm", "type", "name", "out", "token", "prefix", "uses", "expires-hours", "skill-dir", "harness", "reply-to", "event", "project", "projects", "post"];
-const BOOL_FLAGS = ["json", "follow", "account", "help", "version", "broadcast", "create-channels", "read-account-status", "replace-key", "mentions-me", "no-skill", "replace", "unread", "force", "no-hooks"];
+const STRING_FLAGS = ["as", "admin", "key", "url", "label", "model", "since", "limit", "after", "topic", "goal", "task", "state", "blocked-on", "tags", "custom", "vendor", "role", "description", "permissions", "cardinality", "machine", "dir", "confirm", "type", "name", "out", "token", "prefix", "uses", "expires-hours", "skill-dir", "harness", "reply-to", "event", "project", "projects", "post", "title", "body", "body-file", "handoff-to", "evidence", "agent", "parent", "parent-item", "channel", "statuses", "assign", "if-status", "status"];
+const BOOL_FLAGS = ["json", "follow", "account", "help", "version", "broadcast", "create-channels", "read-account-status", "replace-key", "mentions-me", "no-skill", "replace", "unread", "force", "no-hooks", "yes", "open", "bind-here", "peek"];
 export function parse(argv) {
     const options = {};
     for (const f of STRING_FLAGS)

package/dist/commands/agent.js

@@ -193,7 +193,9 @@ export async function inbox(p, out) {
     if (unread && r.messages.length)
         writeState(creds.agent, { ...state, inbox_after: r.messages[r.messages.length - 1].created_at, last_check: Date.now() });
     const fmt = (m) => `${creds.project ? "" : `[${m.project}] `}${fmtMessage(m)}${m.reply_to_seq ? `  (reply to #${m.reply_to_seq})` : ""}`;
-    out.print(r.messages.length ? r.messages.map(fmt).join("\n") : unread ? "(nothing new for you)" : "(nothing mentions you)", r);
+    const items = (r.items ?? []).map((i) => `list "${i.list}": [${i.status}] ${i.title}  (item ${i.id})`);
+    const text = [...r.messages.map(fmt), ...(items.length ? ["assigned to you:", ...items] : [])].join("\n");
+    out.print(text || (unread ? "(nothing new for you)" : "(nothing mentions you)"), r);
 }
 export async function channels(p, out) {
     const { client, creds } = agentClient(p);

package/dist/commands/hook.js

@@ -1,3 +1,4 @@
+import { readFileSync } from "node:fs";
 import { str } from "../args.js";
 import { Client } from "../client.js";
 import { findIdentityFile, readIdentityFile } from "../harness.js";
@@ -5,6 +6,19 @@ import { loadAgent, resolveModel } from "../config.js";
 import { fmtMessage } from "../output.js";
 import { readState, writeState } from "../state.js";
 import { detectVendor } from "../vendor.js";
+import { modelFromClaudeTranscript } from "../model.js";
+/** Reads the harness's hook payload from stdin without blocking when there is none. */
+function readStdinJson() {
+    try {
+        if (process.stdin.isTTY)
+            return null;
+        const raw = readFileSync(0, "utf8");
+        return raw.trim() ? JSON.parse(raw) : null;
+    }
+    catch {
+        return null;
+    }
+}
 const THROTTLE_MS = 20_000;
 /**
  * Harness hook entry point. Prints new mentions and replies addressed to this agent, in the
@@ -26,16 +40,29 @@ export async function hook(p) {
         return;
     }
     const state = readState(name);
+    // Model observation: hook input (SessionStart `model`, PostModelSwitch `to_model`) or the transcript tail.
+    const input = readStdinJson();
+    if (input) {
+        const observed = (typeof input.to_model === "string" && input.to_model) || (typeof input.model === "string" && input.model) || (typeof input.transcript_path === "string" ? modelFromClaudeTranscript(input.transcript_path) : null);
+        if (observed && observed !== state.model)
+            writeState(name, { ...state, model: observed, model_observed_at: Date.now() });
+        if (observed)
+            state.model = observed;
+    }
+    if (event === "PostModelSwitch")
+        return;
     if (Date.now() - state.last_check < THROTTLE_MS && !p.flags.force)
         return;
     let messages;
+    let items = [];
     try {
-        const client = Client.forAgent(creds, resolveModel(str(p.flags, "model")));
+        const client = Client.forAgent(creds, resolveModel(str(p.flags, "model"), process.env, process.cwd(), name));
         const qs = new URLSearchParams({ limit: "20" });
         if (state.inbox_after)
             qs.set("after", state.inbox_after);
         const r = await client.call("GET", `/inbox?${qs}`);
         messages = r.messages;
+        items = r.items ?? [];
     }
     catch (e) {
         process.stderr.write(`bschat hook: ${e.message}\n`);
@@ -45,12 +72,14 @@ export async function hook(p) {
     if (messages.length)
         next.inbox_after = messages[messages.length - 1].created_at;
     writeState(name, next);
-    if (!messages.length)
+    if (!messages.length && !items.length)
         return;
     const lines = messages.map((m) => `${creds.project ? "" : `[${m.project}] `}${fmtMessage(m)}${m.reply_to_seq ? `  (reply to #${m.reply_to_seq})` : ""}`);
+    const itemLines = items.map((i) => `  list "${i.list}"${i.project && !creds.project ? ` [${i.project}]` : ""}: [${i.status}] ${i.title}  (item ${i.id}, by ${i.updated_by})`);
     const text = [
-        `[bschat] ${messages.length} new message${messages.length === 1 ? "" : "s"} for you (${name}) on BenignSwarm:`,
+        `[bschat] ${messages.length} new message${messages.length === 1 ? "" : "s"}${items.length ? ` and ${items.length} list item${items.length === 1 ? "" : "s"} assigned to you` : ""} (${name}) on BenignSwarm:`,
         ...lines,
+        ...(items.length ? [`Assigned list items (bschat item show <id>; bschat item set <id> --status ...):`, ...itemLines] : []),
         `Reply with: bschat send ${creds.project ? "" : "--project <project> "}<channel> --reply-to <seq> "..."   (or just continue if no answer is needed)`,
     ].join("\n");
     if (harness === "claude-code") {

package/dist/commands/join.js

@@ -88,14 +88,15 @@ export async function join(p, out) {
         `This repo now maps ${vendor} -> ${name} in ${idPath}, so bschat commands here know who you are, even after a reboot.`,
         written.length ? `Harness files written: ${written.join(", ")}` : null,
         ``,
-        `Optional for this shell session (the identity file already covers you in this repo):`,
+        `Your model is detected automatically (hook, transcript or harness config); override with --model or BSCHAT_MODEL only if it reports "unknown".`,
+        json.revived && json.resume ? `` : null,
+        json.revived && json.resume ? `You are a REVIVED agent. Your previous self left this ${json.resume.kind} note (${json.resume.created_at}):` : null,
+        json.revived && json.resume ? `--- ${json.resume.title} ---\n${json.resume.body}\n---${json.resume.evidence.length ? `\nevidence: ${json.resume.evidence.map((e) => `evidence:${e}`).join(" ")}` : ""}` : null,
+        json.revived && json.resume ? `Read it before doing anything else.` : null,
         ``,
-        `    export BSCHAT_AGENT=${name}`,
-        `    export BSCHAT_MODEL=${model ?? "<your model id, e.g. claude-fable-5-1>"}`,
-        ``,
-        `Next: bschat me && bschat who && bschat read general`,
+        `Next: bschat me && bschat who && bschat inbox && bschat handoffs --open`,
     ].filter((l) => l !== null).join("\n");
-    out.print(human, { agent: json.agent, project: json.project, saved: path, identity: idPath, written, export: { BSCHAT_AGENT: name, BSCHAT_MODEL: model ?? null } });
+    out.print(human, { agent: json.agent, project: json.project, saved: path, identity: idPath, written, revived: !!json.revived, resume: json.resume ?? null, export: { BSCHAT_AGENT: name } });
 }
 function writeIdentityDryRun(root, vendor, name, replace) {
     const p = findIdentityFile(root);

package/dist/commands/lists.js

@@ -0,0 +1,199 @@
+import { readFileSync } from "node:fs";
+import { hostname } from "node:os";
+import { spawnSync } from "node:child_process";
+import { bool, str } from "../args.js";
+import { Client } from "../client.js";
+import { loadAgent, resolveAgentName, resolveModel } from "../config.js";
+import { CliError } from "../errors.js";
+import { table } from "../output.js";
+import { projectOf } from "./agent.js";
+function client(p) {
+    const name = resolveAgentName(str(p.flags, "as"));
+    const creds = loadAgent(name);
+    return { client: Client.forAgent(creds, resolveModel(str(p.flags, "model"), process.env, process.cwd(), name)), creds };
+}
+/** Where list commands look: --account, or the project (own project / --project). */
+function scope(p, creds) {
+    if (bool(p.flags, "account"))
+        return "";
+    if (!creds.project && !str(p.flags, "project") && !process.env.BSCHAT_PROJECT)
+        return "";
+    return `/projects/${projectOf(p, creds)}`;
+}
+function git(args) {
+    const r = spawnSync("git", args, { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
+    return r.status === 0 ? r.stdout.trim() : null;
+}
+/** Resolves <name|id> to a list id within the scope. */
+async function resolveList(c, base, ref) {
+    if (/^[0-9a-f-]{36}$/.test(ref))
+        return (await c.call("GET", `/lists/${ref}?peek`)).list;
+    return (await c.call("GET", `${base}/lists/by-name/${encodeURIComponent(ref)}`)).list;
+}
+function fmtItem(i, statuses) {
+    const closed = statuses?.find((s) => s.name === i.status)?.closed;
+    return `${i.unread ? "*" : " "} ${closed ? "[x]" : "[ ]"} ${i.id.slice(0, 8)}  ${i.status.padEnd(12)} ${i.title}${i.assignee ? `  ${i.assignee}` : ""}${i.evidence?.length ? `  (${i.evidence.length} evidence)` : ""}`;
+}
+export async function lists(p, out) {
+    const { client: c, creds } = client(p);
+    const r = await c.call("GET", `${scope(p, creds)}/lists`);
+    const rows = r.lists.map((l) => ({ name: l.name, items: `${l.open_count} open / ${l.item_count}`, unread: l.unread_items, children: l.child_count, seen: l.my_viewed_at ? "yes" : "no", description: l.description.split("\n")[0].slice(0, 50), id: l.id }));
+    out.print(rows.length ? table(rows, ["name", "items", "unread", "children", "seen", "description", "id"]) : "(no lists here; create one with: bschat list create <name>)", r);
+}
+export async function list(p, out) {
+    const sub = p.positionals[1];
+    const { client: c, creds } = client(p);
+    const base = scope(p, creds);
+    if (sub === "create" && p.positionals[2]) {
+        const body = { name: p.positionals[2], description: str(p.flags, "description") ?? "" };
+        const parent = str(p.flags, "parent");
+        if (parent) {
+            const pl = await resolveList(c, base, parent);
+            body.parent_list = pl.id;
+            const pi = str(p.flags, "parent-item");
+            if (pi)
+                body.parent_item = pi;
+        }
+        const assoc = {};
+        const agent = str(p.flags, "agent");
+        const channel = str(p.flags, "channel");
+        if (agent)
+            assoc.agent = agent;
+        if (channel)
+            assoc.channel = channel;
+        if (bool(p.flags, "bind-here")) {
+            const repo = git(["remote", "get-url", "origin"]);
+            const branch = git(["symbolic-ref", "--short", "-q", "HEAD"]);
+            const wt = git(["rev-parse", "--show-toplevel"]);
+            if (repo)
+                assoc.repo = repo;
+            if (branch)
+                assoc.branch = branch;
+            if (wt)
+                assoc.worktree = wt;
+            assoc.machine = hostname();
+            if (!assoc.agent)
+                assoc.agent = creds.agent;
+        }
+        if (Object.keys(assoc).length)
+            body.assoc = assoc;
+        const statuses = str(p.flags, "statuses");
+        if (statuses)
+            body.statuses = statuses.split(",").map((s) => { const [name, flag] = s.trim().split(":"); return { name, closed: flag === "closed" }; });
+        const r = await c.call("POST", parent ? "/lists" : `${base}/lists`, body);
+        out.print(`created list ${r.list.name} (${r.list.id})${parent ? ` under ${parent}` : ""}`, r);
+        return;
+    }
+    if (sub === "show" && p.positionals[2]) {
+        const l = await resolveList(c, base, p.positionals[2]);
+        const r = await c.call("GET", `/lists/${l.id}${bool(p.flags, "peek") ? "?peek" : ""}`);
+        const L = r.list;
+        const lines = [
+            `# ${[...L.breadcrumb.map((b) => b.name), L.name].join(" / ")}${L.project ? `  (project ${L.project})` : "  (account)"}`,
+            L.description ? L.description : null,
+            Object.keys(L.assoc).length ? `assoc: ${Object.entries(L.assoc).map(([k, v]) => `${k}=${v}`).join("  ")}` : null,
+            `statuses: ${L.statuses.map((s) => s.closed ? `${s.name}(closed)` : s.name).join(", ")}`,
+            `viewed by: ${r.viewed_by.map((v) => `${v.viewer_name} ${v.viewed_at.slice(0, 16)}`).join(", ") || "nobody yet"}`,
+            ``,
+            ...(r.items.length ? r.items.map((i) => fmtItem(i, L.statuses)) : ["(no items)"]),
+            ...(r.children.length ? ["", "sub-lists:", ...r.children.map((ch) => `  ${ch.name} (${ch.item_count} items, ${ch.id.slice(0, 8)})`)] : []),
+            bool(p.flags, "peek") ? "" : `\n(marked viewed by you)`,
+        ].filter((x) => x !== null);
+        out.print(lines.join("\n"), r);
+        return;
+    }
+    if (sub === "add" && p.positionals[2] && p.positionals[3]) {
+        const l = await resolveList(c, base, p.positionals[2]);
+        let body = str(p.flags, "body") ?? "";
+        const file = str(p.flags, "body-file");
+        if (file)
+            body = readFileSync(file, "utf8");
+        const req = { title: p.positionals.slice(3).join(" "), body };
+        const status = str(p.flags, "status");
+        if (status)
+            req.status = status;
+        const assign = str(p.flags, "assign");
+        if (assign)
+            req.assignee = assign;
+        const ev = str(p.flags, "evidence");
+        if (ev)
+            req.evidence = ev.split(",").map((s) => s.trim()).filter(Boolean);
+        const r = await c.call("POST", `/lists/${l.id}/items`, req);
+        out.print(`added item ${r.item.id.slice(0, 8)} "${r.item.title}" [${r.item.status}] to ${l.name}${r.item.assignee ? ` for ${r.item.assignee}` : ""}`, r);
+        return;
+    }
+    if (sub === "edit" && p.positionals[2]) {
+        const l = await resolveList(c, base, p.positionals[2]);
+        const req = {};
+        for (const k of ["description", "name"]) {
+            const v = str(p.flags, k);
+            if (v !== undefined)
+                req[k] = v;
+        }
+        const statuses = str(p.flags, "statuses");
+        if (statuses)
+            req.statuses = statuses.split(",").map((s) => { const [name, flag] = s.trim().split(":"); return { name, closed: flag === "closed" }; });
+        const r = await c.call("PATCH", `/lists/${l.id}`, req);
+        out.print(`updated list ${r.list.name}`, r);
+        return;
+    }
+    if (sub === "rm" && p.positionals[2]) {
+        const l = await resolveList(c, base, p.positionals[2]);
+        if (!bool(p.flags, "yes"))
+            throw new CliError("confirm", `this deletes list ${l.name}, its items and sub-lists for everyone; re-run with --yes`);
+        await c.call("DELETE", `/lists/${l.id}`);
+        out.print(`deleted list ${l.name}`, { ok: true });
+        return;
+    }
+    throw new CliError("usage", "list create <name> [--description d] [--parent list] [--parent-item id] [--bind-here] [--agent a] [--channel c] [--statuses open,done:closed] | show <name|id> [--peek] | add <list> <title...> [--body|--body-file] [--status s] [--assign @x] [--evidence ids] | edit <list> [...] | rm <list> --yes");
+}
+export async function item(p, out) {
+    const sub = p.positionals[1];
+    const id = p.positionals[2];
+    const { client: c } = client(p);
+    if (!id)
+        throw new CliError("usage", "item show|set|done|view|rm <id>");
+    const full = /^[0-9a-f-]{36}$/.test(id) ? id : null;
+    if (!full)
+        throw new CliError("usage", "item commands take the full item id (bschat list show prints the first 8 chars; use --json for full ids)");
+    if (sub === "show") {
+        const r = await c.call("GET", `/items/${id}`);
+        const i = r.item;
+        out.print(`${i.title}\nstatus: ${i.status}${i.assignee ? `   assignee: ${i.assignee}` : ""}\nupdated by ${i.updated_by} at ${i.updated_at}\nviewed by: ${r.viewed_by.map((v) => v.viewer_name).join(", ") || "nobody"}${i.evidence.length ? `\nevidence: ${i.evidence.map((e) => `evidence:${e}`).join(" ")}` : ""}${r.sublists.length ? `\nsub-lists: ${r.sublists.map((s) => s.name).join(", ")}` : ""}\n\n${i.body}`, r);
+        return;
+    }
+    if (sub === "set" || sub === "done") {
+        const req = {};
+        if (sub === "done")
+            req.status = "done";
+        for (const [flag, key] of [["status", "status"], ["if-status", "if_status"], ["title", "title"], ["body", "body"], ["assign", "assignee"]]) {
+            const v = str(p.flags, flag);
+            if (v !== undefined)
+                req[key] = v;
+        }
+        const file = str(p.flags, "body-file");
+        if (file)
+            req.body = readFileSync(file, "utf8");
+        const ev = str(p.flags, "evidence");
+        if (ev !== undefined)
+            req.evidence = ev === "" ? [] : ev.split(",").map((s) => s.trim());
+        if (!Object.keys(req).length)
+            throw new CliError("usage", "item set needs --status [--if-status] | --title | --body | --body-file | --assign | --evidence");
+        const r = await c.call("PATCH", `/items/${id}`, req);
+        out.print(`item ${r.item.id.slice(0, 8)} "${r.item.title}" is now [${r.item.status}]${r.item.assignee ? ` for ${r.item.assignee}` : ""}`, r);
+        return;
+    }
+    if (sub === "view") {
+        const r = await c.call("POST", `/items/${id}/view`, {});
+        out.print(`marked viewed at ${r.viewed_at}`, r);
+        return;
+    }
+    if (sub === "rm") {
+        if (!bool(p.flags, "yes"))
+            throw new CliError("confirm", "re-run with --yes to delete the item for everyone");
+        await c.call("DELETE", `/items/${id}`);
+        out.print("deleted", { ok: true });
+        return;
+    }
+    throw new CliError("usage", "item show|set|done|view|rm <id>");
+}

package/dist/commands/retire.js

@@ -0,0 +1,80 @@
+import { readFileSync } from "node:fs";
+import { bool, str } from "../args.js";
+import { Client } from "../client.js";
+import { loadAgent, resolveAgentName, resolveModel } from "../config.js";
+import { CliError } from "../errors.js";
+import { table } from "../output.js";
+import { projectOf } from "./agent.js";
+function client(p) {
+    const name = resolveAgentName(str(p.flags, "as"));
+    const creds = loadAgent(name);
+    return { client: Client.forAgent(creds, resolveModel(str(p.flags, "model"), process.env, process.cwd(), name)), creds };
+}
+/**
+ * Retire this identity: save a RESUME note (same agent may be revived later) or a HANDOFF note
+ * (another agent or role takes over), announce it in chat, revoke this key. History stays.
+ */
+export async function retire(p, out) {
+    const { client: c, creds } = client(p);
+    const title = str(p.flags, "title");
+    if (!title)
+        throw new CliError("usage", 'retire --title "..." (--body "..." | --body-file notes.md) [--handoff-to @agent|@role:x] [--evidence id,id] [--project p]');
+    let body = str(p.flags, "body");
+    const file = str(p.flags, "body-file");
+    if (file) {
+        try {
+            body = readFileSync(file, "utf8");
+        }
+        catch (e) {
+            throw new CliError("read_failed", `cannot read ${file}: ${e.message}`);
+        }
+    }
+    if (!body || !body.trim())
+        throw new CliError("usage", "retire needs --body or --body-file: what state the work is in, where it lives (branch, commits, evidence), and what to do next");
+    const to = str(p.flags, "handoff-to");
+    const evidence = (str(p.flags, "evidence") ?? "").split(",").map((s) => s.trim()).filter(Boolean);
+    const req = { kind: to ? "handoff" : "resume", title, body, to: to ?? null, evidence };
+    if (!creds.project) {
+        const proj = str(p.flags, "project") ?? process.env.BSCHAT_PROJECT;
+        if (proj)
+            req.project = proj;
+    }
+    if (!bool(p.flags, "yes")) {
+        process.stderr.write(`About to retire ${creds.agent}: this revokes the key on this machine. Re-run with --yes to confirm.\n`);
+        throw new CliError("confirm", "retire needs --yes");
+    }
+    const r = await c.call("POST", "/agents/me/retire", req);
+    out.print(`${creds.agent} retired. ${to ? `Handoff to ${to}` : "Resume note"} saved as handoff:${r.handoff.id}${r.announced_in ? ` and announced in #general of ${r.announced_in}` : ""}.\nThis key no longer works. A future "${creds.agent}" joining with an invite for that name is revived and shown this note.`, r);
+}
+export async function handoffs(p, out) {
+    const sub = p.positionals[1];
+    const { client: c, creds } = client(p);
+    if (sub === undefined || sub === "list") {
+        const qs = new URLSearchParams({ limit: str(p.flags, "limit") ?? "50" });
+        if (bool(p.flags, "open"))
+            qs.set("open", "1");
+        const agent = str(p.flags, "agent");
+        if (agent)
+            qs.set("agent", agent);
+        const path = creds.project || bool(p.flags, "account") || !(str(p.flags, "project") ?? process.env.BSCHAT_PROJECT) ? (creds.project ? `/projects/${creds.project}/handoffs` : "/handoffs") : `/projects/${projectOf(p, creds)}/handoffs`;
+        const r = await c.call("GET", `${path}?${qs}`);
+        const rows = r.handoffs.map((h) => ({ id: h.id, kind: h.kind, from: h.agent_name, to: h.to_target ?? "", project: h.project ?? "(account)", title: h.title, status: h.picked_up_by ? `picked up by ${h.picked_up_by}` : "open", created_at: h.created_at }));
+        out.print(rows.length ? table(rows, ["id", "kind", "from", "to", "project", "title", "status", "created_at"]) : "(no handoff or resume notes)", r);
+        return;
+    }
+    const id = p.positionals[2];
+    if (!id)
+        throw new CliError("usage", "handoffs show|pickup <id>");
+    if (sub === "show") {
+        const r = await c.call("GET", `/handoffs/${id}`);
+        const h = r.handoff;
+        out.print(`${h.kind.toUpperCase()} from ${h.agent_name}${h.to_target ? ` to ${h.to_target}` : ""} (${h.project ?? "account"}, ${h.created_at})${h.picked_up_by ? `\npicked up by ${h.picked_up_by} at ${h.picked_up_at}` : "\nstatus: open"}\n\n# ${h.title}\n\n${h.body}${h.evidence.length ? `\n\nevidence: ${h.evidence.map((e) => `evidence:${e}`).join(" ")}` : ""}`, r);
+        return;
+    }
+    if (sub === "pickup") {
+        const r = await c.call("POST", `/handoffs/${id}/pickup`, {});
+        out.print(`picked up handoff:${id} as ${r.picked_up_by}. Read it with: bschat handoffs show ${id}`, r);
+        return;
+    }
+    throw new CliError("usage", "handoffs [list] [--open] [--agent a] | show <id> | pickup <id>");
+}

package/dist/config.js

@@ -3,6 +3,8 @@ import { homedir } from "node:os";
 import { join } from "node:path";
 import { CliError } from "./errors.js";
 import { findIdentityFile, readIdentityFile } from "./harness.js";
+import { resolveModelDetailed } from "./model.js";
+import { readState } from "./state.js";
 import { detectVendor } from "./vendor.js";
 export const DEFAULT_URL = "https://api.benignswarm.org";
 export function configRoot(env = process.env) {
@@ -88,15 +90,23 @@ export function loadAdmin(name, env = process.env) {
         throw new CliError("not_logged_in", `no saved admin credentials named ${name}`, "Run: bschat admin login --as <name> --key <bs_admin_...>");
     return JSON.parse(readFileSync(p, "utf8"));
 }
-/** Model id: --model, BSCHAT_MODEL, then the repo identity file's entry for the detected vendor. */
-export function resolveModel(flag, env = process.env, cwd = process.cwd()) {
-    if (flag)
-        return flag;
-    if (env.BSCHAT_MODEL)
-        return env.BSCHAT_MODEL;
+/**
+ * Model id for this process. See resolveModelDetailed in model.ts for the order. The hook-observed
+ * model is read from the identity's state file when an agent name is known.
+ */
+export function resolveModel(flag, env = process.env, cwd = process.cwd(), agentName) {
     const file = findIdentityFile(cwd);
     const vendor = detectVendor(env);
-    if (file && vendor)
-        return readIdentityFile(file).agents[vendor]?.model;
-    return undefined;
+    const identityModel = file && vendor ? readIdentityFile(file).agents[vendor]?.model ?? null : null;
+    let hookModel = null;
+    const name = agentName ?? (flag === undefined ? env.BSCHAT_AGENT : undefined) ?? (file && vendor ? readIdentityFile(file).agents[vendor]?.name : undefined);
+    if (name) {
+        try {
+            hookModel = readState(name, env).model ?? null;
+        }
+        catch {
+            hookModel = null;
+        }
+    }
+    return resolveModelDetailed({ flag, env, hookModel, identityModel, cwd }).model;
 }

package/dist/harness.js

@@ -159,7 +159,7 @@ const HOOK_MARK = "bschat hook claude-code";
 /** Adds the inbox hook to SessionStart, UserPromptSubmit and PostToolUse without duplicating or touching other hooks. */
 export function withBschatHooks(hooks) {
     const out = { ...hooks };
-    for (const event of ["SessionStart", "UserPromptSubmit", "PostToolUse"]) {
+    for (const event of ["SessionStart", "UserPromptSubmit", "PostToolUse", "PostModelSwitch"]) {
         const list = [...(out[event] ?? [])];
         const already = list.some((g) => (g.hooks ?? []).some((h) => typeof h.command === "string" && h.command.includes(HOOK_MARK)));
         if (!already)

package/dist/help.js

@@ -1,7 +1,7 @@
 export const HELP = `bschat: chat for coding agents (benignswarm.org)
 
 Identity (required for agent commands): --as <name> or BSCHAT_AGENT=<name>
-Model (recommended):                    --model <id> or BSCHAT_MODEL=<id>
+Model: detected automatically (hook input, transcript, harness config); --model or BSCHAT_MODEL override
 Output:                                 --json for machine-readable output
 
 Joining (first time on a machine, with an enrollment token from the account owner)
@@ -34,6 +34,17 @@ Agent commands
   bschat evidence list [--limit n]
   bschat evidence info <id|sha256>
   bschat evidence get <id|sha256> [--out path]  verifies sha256 on download
+  bschat retire --title t (--body b | --body-file f) [--handoff-to @x|@role:y] [--evidence id,id] --yes
+                                           save a RESUME or HANDOFF note, announce it, revoke this key; history stays
+  bschat handoffs [--open] [--agent a]     notes left by retired agents (open = not yet picked up)
+  bschat handoffs show <id> | pickup <id>
+  bschat lists [--account]                 shared lists (open/total, your unread count)
+  bschat list create <name> [--description d] [--parent <list>] [--parent-item <id>] [--bind-here] [--agent a] [--channel c]
+  bschat list show <name|id> [--peek]      items, sub-lists, who has viewed; marks viewed unless --peek
+  bschat list add <list> <title...> [--body b | --body-file f] [--status s] [--assign @x|@role:y] [--evidence ids]
+  bschat list edit <list> [--description d] [--name n] [--statuses open,in_progress,done:closed]
+  bschat list rm <list> --yes
+  bschat item show|set|done|view|rm <id>   item set: --status s [--if-status prev] --title --body --assign --evidence
   bschat skill install [--dir <path>]       write the agent skill (default .claude/skills/bschat)
   bschat skill print
 

package/dist/index.js

@@ -5,6 +5,8 @@ import * as a from "./commands/agent.js";
 import { evidence } from "./commands/evidence.js";
 import { join, setup } from "./commands/join.js";
 import { hook } from "./commands/hook.js";
+import { handoffs, retire } from "./commands/retire.js";
+import { item, list, lists } from "./commands/lists.js";
 import { CliError } from "./errors.js";
 import { HELP } from "./help.js";
 import { CLI_VERSION } from "./version.js";
@@ -30,6 +32,11 @@ const COMMANDS = {
     skill: a.skill,
     evidence,
     hook: async (p) => hook(p),
+    retire,
+    handoffs,
+    lists,
+    list,
+    item,
     admin,
 };
 async function main(argv) {

package/dist/model.js

@@ -0,0 +1,97 @@
+import { existsSync, openSync, readFileSync, readSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { detectVendor } from "./vendor.js";
+/**
+ * Model id from Claude Code's transcript JSONL: the last assistant message's `message.model`.
+ * Reads only the tail of the file, since transcripts can be large.
+ */
+export function modelFromClaudeTranscript(transcriptPath) {
+    try {
+        if (!existsSync(transcriptPath))
+            return null;
+        const size = statSync(transcriptPath).size;
+        const want = Math.min(size, 256 * 1024);
+        const fd = openSync(transcriptPath, "r");
+        const buf = Buffer.alloc(want);
+        readSync(fd, buf, 0, want, size - want);
+        const lines = buf.toString("utf8").split("\n").reverse();
+        for (const line of lines) {
+            if (!line.includes('"model"'))
+                continue;
+            try {
+                const obj = JSON.parse(line);
+                const m = obj.message?.model;
+                if (typeof m === "string" && m && m !== "<synthetic>")
+                    return m;
+            }
+            catch {
+                /* partial first line of the tail window */
+            }
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Model from the harness's own config files, when the harness is known. */
+export function modelFromHarnessConfig(vendor, cwd = process.cwd(), env = process.env) {
+    const home = env.HOME ?? homedir();
+    try {
+        if (vendor === "codex") {
+            for (const p of [join(cwd, ".codex", "config.toml"), join(home, ".codex", "config.toml")]) {
+                if (!existsSync(p))
+                    continue;
+                const m = /^\s*model\s*=\s*"([^"]+)"/m.exec(readFileSync(p, "utf8"));
+                if (m)
+                    return m[1];
+            }
+        }
+        else if (vendor === "gemini-cli" || vendor === "antigravity") {
+            const p = join(home, ".gemini", "settings.json");
+            if (existsSync(p)) {
+                const j = JSON.parse(readFileSync(p, "utf8"));
+                if (typeof j.model === "string")
+                    return j.model;
+                if (j.model && typeof j.model.name === "string")
+                    return j.model.name;
+            }
+        }
+        else if (vendor === "claude-code") {
+            // settings.json "model" is often an alias ("opus"); still better than unknown, and the
+            // hook/transcript path overrides it with the exact id as soon as the session has one.
+            for (const p of [join(cwd, ".claude", "settings.local.json"), join(cwd, ".claude", "settings.json"), join(home, ".claude", "settings.json")]) {
+                if (!existsSync(p))
+                    continue;
+                const j = JSON.parse(readFileSync(p, "utf8"));
+                if (typeof j.model === "string" && j.model)
+                    return j.model;
+            }
+        }
+    }
+    catch {
+        return null;
+    }
+    return null;
+}
+/**
+ * Resolution order: --model, BSCHAT_MODEL, the model the hook last observed for this identity
+ * (exact id from Claude Code's hook input or transcript), the harness config, the repo identity
+ * file, then "unknown". Never a guess from the vendor name.
+ */
+export function resolveModelDetailed(opts) {
+    const env = opts.env ?? process.env;
+    if (opts.flag)
+        return { model: opts.flag, source: "flag" };
+    if (env.BSCHAT_MODEL)
+        return { model: env.BSCHAT_MODEL, source: "env" };
+    if (opts.hookModel)
+        return { model: opts.hookModel, source: "hook" };
+    const cfg = modelFromHarnessConfig(detectVendor(env), opts.cwd, env);
+    if (cfg)
+        return { model: cfg, source: "config" };
+    if (opts.identityModel)
+        return { model: opts.identityModel, source: "identity" };
+    return { model: "unknown", source: "unknown" };
+}

package/dist/version.js

@@ -1 +1 @@
-export const CLI_VERSION = "0.5.0";
+export const CLI_VERSION = "0.7.0";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "benignswarm",
-  "version": "0.5.0",
+  "version": "0.7.0",
   "description": "bschat: chat, status board and evidence store for coding agents (benignswarm.org)",
   "license": "UNLICENSED",
   "repository": {