toolroll 0.9.104 → 0.9.105

package/dist/subagent-tools.js

@@ -1,41 +1,18 @@
-/**
- * The tools a subagent may use (v94), and its rule for each of their actions.
- *
- * A subagent never calls a tool itself. On its turn it may ask for one call
- * ("use_tool": which action, with what input, and why), and Toolroll
- * checks the rule its manager set for that action:
- *
- * - do it: the call is made and its answer goes back to the subagent, whose
- *   turn goes on;
- * - ask first: the exact call goes to the zone's person, in their chat app
- *   and on the card. Approve makes exactly that call; Deny doesn't; words
- *   tell the subagent what to do instead;
- * - never: the action isn't offered at all.
- *
- * "Do it" can ask first above a number in the input ("refunds up to $50"),
- * so a limit holds in code, not only in the soul file's words. Every call,
- * made or not, is a receipt on the card and on the subagent's page.
- */
 import { redactSecretLines, scanForSecrets } from "./evidence.js";
 import { scrubSecrets } from "./flow-secrets.js";
 import { toolRefusal } from "./policy.js";
 import { callProjectTool, listProjectToolActions, projectToolsOf, readToolSecrets, toolServerFor } from "./project-tools.js";
 import { ALL_CREDENTIAL_ENV } from "./provider.js";
-/** Actions whose names say they only read start as "do it"; everything else asks first until its manager says otherwise. */
 export const READ_VERB = /^(get|list|search|find|read|fetch|lookup|look_up|query|show|describe|count|check|view|retrieve)([_.-]|$)/i;
 export const defaultRule = (action) => ({ use: action.readOnly || READ_VERB.test(action.name) ? "free" : "ask" });
-/** How long a tool's listing is trusted before a turn lists it again. */
 const LISTING_MS = 6 * 60 * 60_000;
 const RESULT_CHARS = 6000;
-/** How a turn names an action: "shop.refund_order". */
 export const callName = (tool, action) => `${tool}.${action}`;
-/** A fresh listing merged into a grant: rules already set are kept, new actions get the default, and gone ones drop out. */
 export function withActions(rules, actions) {
     return { actions: [...actions], rules: Object.fromEntries(actions.map(one => [one.name, rules[one.name] ?? defaultRule(one)])) };
 }
 const numberOf = (value) => typeof value === "number" && Number.isFinite(value) ? value
     : typeof value === "string" && /^\s*-?\$?\d+(\.\d+)?\s*$/.test(value) ? Number(value.replace(/[$\s]/g, "")) : null;
-/** The rule that applies to one call with this input, and why, in words. */
 export function ruleFor(grant, action, input) {
     const info = grant.actions.find(one => one.name === action);
     const rule = grant.rules[action] ?? (info === undefined ? { use: "never" } : defaultRule(info));
@@ -52,7 +29,6 @@ export function ruleFor(grant, action, input) {
     }
     return { use: "free", why: "" };
 }
-/** A rule in words, for the subagent's turn and its page. */
 export function ruleWords(rule) {
     if (rule.use === "never")
         return "never";
@@ -60,12 +36,10 @@ export function ruleWords(rule) {
         return "a person approves each call first";
     return rule.limit === undefined ? "use freely" : `use freely up to ${rule.limit.field} ${rule.limit.over}; above that, a person approves first`;
 }
-/** Number fields an action's input declares: what a limit can be set on. */
 export function numberFields(action) {
     const properties = (action.input?.["properties"] ?? {});
     return Object.entries(properties).filter(([, one]) => one !== null && typeof one === "object" && (one.type === "number" || one.type === "integer")).map(([name]) => name).slice(0, 20);
 }
-/** What's wrong with an input, by what the action declares: its required fields and their simple types. */
 export function inputProblem(action, input) {
     const schema = action.input;
     if (schema === null)
@@ -85,16 +59,13 @@ export function inputProblem(action, input) {
     }
     return null;
 }
-/** A call in a few words: "shop → refund_order · order 1044 · amount 400". */
 export function callWords(tool, action, input, cap = 300) {
     const parts = Object.entries(input).map(([key, value]) => `${key} ${typeof value === "string" ? value.replace(/\s+/g, " ") : JSON.stringify(value)}`);
     const line = `${tool} → ${action}${parts.length === 0 ? "" : ` · ${parts.join(" · ")}`}`;
     return line.length <= cap ? line : `${line.slice(0, cap - 1)}…`;
 }
-/** What a subagent may use now: its grants' actions on tools the project still has, "never" left out. */
 export function offeredTools(store, mate) {
     const present = new Set(projectToolsOf(store, mate.repo).map(one => one.name));
-    // Sprint 8: a tool the organisation policy doesn't allow isn't offered.
     const policy = store.orgPolicy();
     return store.subagentGrants(mate.id).filter(grant => present.has(grant.tool) && toolRefusal(policy, grant.tool) === null).flatMap(grant => grant.actions.flatMap(action => {
         const rule = grant.rules[action.name] ?? defaultRule(action);
@@ -104,7 +75,6 @@ export function offeredTools(store, mate) {
         return [{ name: callName(grant.tool, action.name), about: action.about, input: input.length > 1500 ? `${input.slice(0, 1499)}…` : input, rule: ruleWords(rule) }];
     })).slice(0, 40);
 }
-/** Before a turn: re-list tools whose listing is old (or never happened), so the turn sees what they offer today. A tool that can't be reached keeps its last listing. */
 export async function refreshGrants(store, mate, now, io) {
     const tools = projectToolsOf(store, mate.repo);
     for (const grant of store.subagentGrants(mate.id)) {
@@ -116,8 +86,6 @@ export async function refreshGrants(store, mate, now, io) {
         const listed = await listed_(store, tool, mate.repo, io);
         if (!listed.ok)
             continue;
-        // The grant as it is now, after the listing's wait, in one transaction with the save: one taken away meanwhile stays
-        // gone, and only the tool's list of actions is new (rules changed meanwhile, tightened ones included, stand).
         store.transact(() => {
             const current = store.subagentGrant(mate.id, grant.tool);
             if (current === null)
@@ -127,16 +95,9 @@ export async function refreshGrants(store, mate, now, io) {
     }
 }
 const listed_ = (store, tool, repo, io) => (io.listTools ?? ((spec, values) => listProjectToolActions(spec, values, { timeoutMs: 60_000, omitEnv: ALL_CREDENTIAL_ENV, server: serverOf(store, repo, io) })))(tool.spec, readToolSecrets(repo, tool.name, io.toolHome));
-/** Where a subagent's tool server starts: in the server fence (project-tools.ts toolServerFor), never bare. */
 const serverOf = (store, repo, io) => toolServerFor(store, repo, { ...(io.toolHome === undefined ? {} : { home: io.toolHome }), ...(io.fenceAvailable === undefined ? {} : { available: io.fenceAvailable }) });
-/** Names only, from the tool's last test: what a grant starts with when it can't be listed right now. */
 const namesOnly = (tool) => (tool.lastTest?.tools ?? []).map(name => ({ name, about: "", input: null, readOnly: false }));
-/** Let a subagent use one of the project's tools. Its actions start at their defaults: reading is free, everything else asks first.
- * A grant widens what it does unasked, so it takes the person's proof (a password, or a session under Passwordless):
- * `widening: "proved"` (chat-management.md §0a.3). */
-export async function grantTool(store, mate, tool, by, now, io = {}, 
-/** `stillProved`: the proof re-checked after the listing's wait, in the same synchronous step as the save. */
-options = {}) {
+export async function grantTool(store, mate, tool, by, now, io = {}, options = {}) {
     if (options.widening !== "proved")
         return grantRefused(tool);
     const found = projectToolsOf(store, mate.repo).find(one => one.name === tool);
@@ -150,8 +111,6 @@ options = {}) {
     return grantListed(store, mate, found, listed.ok ? listed.actions : null, by, now, { widening: "proved" });
 }
 const grantRefused = (tool) => ({ ok: false, said: `Letting it use ${tool} takes your password. Do it on its page in Toolroll.` });
-/** A grant from what the tool offers (or, not reachable now, the names its last test found). Every road to a grant
- * comes here: it takes the person's proof, and a tool it already uses keeps its rules (a grant never resets them). */
 export function grantListed(store, mate, tool, actions, by, now, options = {}) {
     if (options.widening !== "proved")
         return grantRefused(tool.name);
@@ -173,14 +132,12 @@ export function revokeTool(store, mate, tool, by, now = new Date()) {
     }
     return store.dropSubagentGrant(mate.id, tool, by, now) ? { ok: true, said: `It can't use ${tool} any more.` } : { ok: true, said: `It wasn't using ${tool}.` };
 }
-/** Check one rule: an action the tool offers, a known use, and a limit on one of its number fields. */
 export function checkRule(grant, action, rule) {
     const info = grant.actions.find(one => one.name === action);
     if (info === undefined)
         return { ok: false, said: `${grant.tool} has no action called ${action}. Its actions: ${grant.actions.map(one => one.name).join(", ")}.` };
     if (rule.use !== "free" && rule.use !== "ask" && rule.use !== "never")
         return { ok: false, said: "Choose do it, ask first or never." };
-    // v97: the action that undoes this one, when a person presses Undo on its receipt.
     const undo = typeof rule.undo === "string" && rule.undo !== "" ? rule.undo : null;
     if (undo !== null && (undo === action || !grant.actions.some(one => one.name === undo)))
         return { ok: false, said: `${grant.tool} has no other action called ${undo} to undo ${action} with.` };
@@ -197,18 +154,13 @@ export function checkRule(grant, action, rule) {
         return { ok: false, said: "A limit is a number, 0 or more." };
     return withUndo({ use: "free", limit: { field, over } });
 }
-/** How much a rule lets a subagent do unasked: never, ask first, on its own up to a limit, on its own. */
 const ruleRank = (rule) => rule.use === "never" ? 0 : rule.use === "ask" ? 1 : rule.limit !== undefined ? 2 : 3;
-/** Whether `next` lets the subagent do more unasked than `before` (chat-management.md §0a.3): a higher rank, or a limit
- * on another number or a higher one. The undo action is never authority. */
 export function ruleLoosens(before, next) {
     const was = ruleRank(before), now = ruleRank(next);
     if (now !== was)
         return now > was;
     return now === 2 && (next.limit.field !== before.limit.field || next.limit.over > before.limit.over);
 }
-/** Set the rules for some of a granted tool's actions; the others keep theirs. Loosening any of them takes the
- * person's proof (a password, or a session under Passwordless): `widening: "proved"`; tightening never does. */
 export function setToolRules(store, mate, tool, changes, by, now, options = {}) {
     const grant = store.subagentGrant(mate.id, tool);
     if (grant === null)
@@ -228,20 +180,12 @@ export function setToolRules(store, mate, tool, changes, by, now, options = {})
     return { ok: true, said: "Saved. Its next turn uses these rules." };
 }
 const blank = (text) => redactSecretLines(text, scanForSecrets(text));
-/**
- * Make one call now: a free one, or one a person approved (exactly as they
- * saw it). What the tool said is kept on the receipt, secrets scrubbed; a
- * tool that says it failed is an answer the subagent reads, not trouble.
- */
 export async function makeCall(store, call, repo, io, now, options = {}) {
-    // Its rules are read again at the moment of the call: a tool taken away, or an action set to never, since it was approved stops it.
-    // (A person's own undo (v97) needs the tool still granted, not the subagent's rule for that action.)
     const grant = store.subagentGrant(call.subagent, call.tool);
     if (grant === null || (options.byPerson !== true && ruleFor(grant, call.action, call.input).use === "never")) {
         store.moveSubagentCall(call.id, ["approved", "running"], { state: "refused", result: "Its rules changed before the call was made." }, now);
         return store.subagentCall(call.id);
     }
-    // Sprint 8: nor does a call to a tool the organisation policy doesn't allow (a person's undo included).
     const disallowed = toolRefusal(store.orgPolicy(), call.tool);
     if (disallowed !== null) {
         store.moveSubagentCall(call.id, ["approved", "running"], { state: "refused", result: disallowed }, now);
@@ -267,7 +211,6 @@ export async function makeCall(store, call, repo, io, now, options = {}) {
     store.moveSubagentCall(call.id, ["running"], { state: answer.ok && !answer.isError ? "done" : "failed", result: kept || (answer.ok ? "(no answer)" : "It couldn't be reached.") }, now);
     return store.subagentCall(call.id);
 }
-/** A receipt in words: what happened to the call. */
 export function callOutcome(call) {
     switch (call.state) {
         case "asked": return "waiting for approval";
@@ -279,7 +222,6 @@ export function callOutcome(call) {
         default: return "not made";
     }
 }
-/** A receipt as a person reads it on the card: what happened, and who decided. */
 export function receiptWords(store, call) {
     switch (call.state) {
         case "asked": {
@@ -297,7 +239,6 @@ export function receiptWords(store, call) {
         default: return `Not made: ${call.result ?? "outside its rules"}`;
     }
 }
-/** The Tools section's form, read into rule changes: every action the grant knows. */
 export function rulesFromForm(grant, field) {
     return Object.fromEntries(grant.actions.flatMap(action => {
         const use = field(`use.${action.name}`);

package/dist/subagent-week.js

@@ -1,23 +1,8 @@
-/**
- * A subagent's week (v97): what it did, what it cost, what its people
- * overrode, and its receipts — on its page, and each Monday morning to its
- * manager in their chat app.
- *
- * Cost is what the Claude CLI reports for each turn (at API prices; a Claude
- * plan covers subscription turns). Overrides are the calls its people turned
- * down and the cards someone moved by hand right after it moved them.
- *
- * Undo, where the tool can: a manager names, per action, another action of
- * the same tool that undoes it (remove_label for add_label, say). Undo makes
- * that call with the same input, as the person who pressed it, and both calls
- * keep their receipts.
- */
 import { flowCardHref } from "./flow-engine.js";
 import { labelOf, nameOf } from "./subagent-admin.js";
 import { callWords, makeCall } from "./subagent-tools.js";
 const WEEK_MS = 7 * 86_400_000;
 const money = (usd) => usd < 0.01 ? "under 1¢" : usd < 10 ? `$${usd.toFixed(2)}` : `$${Math.round(usd)}`;
-/** The undo action a call's rule names, when there is one and the call can still be undone. */
 export function undoFor(store, call) {
     if (call.state !== "done" || call.undoneBy !== null || call.undoOf !== null)
         return null;
@@ -25,7 +10,6 @@ export function undoFor(store, call) {
     const undo = grant?.rules[call.action]?.undo;
     return undo !== undefined && grant.actions.some(one => one.name === undo) ? undo : null;
 }
-/** The last seven days (or since a time) for one subagent. */
 export function weekOf(store, mate, now, since = new Date(now.getTime() - WEEK_MS).toISOString()) {
     const turns = store.subagentTurns(mate.id, since);
     const costs = turns.map(one => one.costUsd).filter((one) => one !== null);
@@ -49,7 +33,6 @@ export function weekOf(store, mate, now, since = new Date(now.getTime() - WEEK_M
         undoable: calls.flatMap(one => { const undo = undoFor(store, one); return undo === null ? [] : [{ call: one.id, words: callWords(one.tool, one.action, one.input, 200), undo, at: one.createdAt, href: hrefOf(one.card) }]; }).reverse().slice(0, 20),
     };
 }
-/** The week in words its manager reads at a glance. */
 export function weekWords(mate, week) {
     const name = nameOf(mate);
     const quiet = week.turns === 0 && week.decided + week.handled + week.handed + week.asked + week.calls.made === 0;
@@ -63,14 +46,12 @@ export function weekWords(mate, week) {
     ];
     return lines.join("\n");
 }
-/** Each Monday from 9:00 (this computer's time), the week's report to each active subagent's manager, once; or now, for one. */
 export function sendSubagentWeeklies(store, repo, now, only = null) {
     const monday = new Date(now);
     monday.setHours(9, 0, 0, 0);
     monday.setDate(monday.getDate() - ((monday.getDay() + 6) % 7));
     let sent = 0;
     for (const mate of store.subagents([repo])) {
-        // One a week, from Monday 9:00; a subagent that joined since then has its first next Monday.
         if (only !== null ? mate.id !== only : mate.state !== "active" || now < monday || (mate.weeklyAt ?? mate.createdAt) >= monday.toISOString())
             continue;
         store.updateSubagent(mate.id, { weeklyAt: now.toISOString() }, "weekly", now);
@@ -83,12 +64,6 @@ export function sendSubagentWeeklies(store, repo, now, only = null) {
     }
     return sent;
 }
-/**
- * A person asks to undo one of its tool calls with the action its manager
- * named: the undo call is recorded at once (the same input, as them), and
- * made by finishUndo — right away on the page, or by the worker's next pass
- * when it was asked for in chat. Both calls keep their receipts.
- */
 export function requestUndo(store, mate, id, by, now) {
     const call = store.subagentCall(id);
     if (call === null || call.subagent !== mate.id)
@@ -104,7 +79,6 @@ export function requestUndo(store, mate, id, by, now) {
         return { ok: true, call: made, said: `Undoing it with ${undo}.` };
     });
 }
-/** Make a requested undo call; if the tool says it failed, the original call stands (and can be undone again). */
 export async function finishUndo(store, id, io, now) {
     const pending = store.subagentCall(id);
     const mate = pending === null ? null : store.getSubagent(pending.subagent);
@@ -116,7 +90,6 @@ export async function finishUndo(store, id, io, now) {
     store.clearSubagentCallUndone(pending.undoOf, now);
     return { ok: false, said: `The undo call failed: ${made.result ?? "no answer"}. The original call stands.` };
 }
-/** The worker's pass: undo calls asked for in chat, made now. */
 export async function runRequestedUndos(store, io, now) {
     let made = 0;
     for (const call of store.pendingSubagentUndos()) {
@@ -125,7 +98,6 @@ export async function runRequestedUndos(store, io, now) {
     }
     return made;
 }
-/** Undo, on the page: asked for and made at once. */
 export async function undoCall(store, mate, id, by, io, now) {
     const asked = requestUndo(store, mate, id, by, now);
     return asked.ok ? finishUndo(store, asked.call, io, now) : asked;

package/dist/subagent-work.js

@@ -8,22 +8,16 @@ import { callName, callOutcome, callWords, inputProblem, makeCall, offeredTools,
 import { ACCEPT, answerSuggestion, considerSuggestion, memoriesFor, remember } from "./subagent-memory.js";
 import { replyToAsker } from "./subagent-desk.js";
 import { claudeMachineBilling } from "./spend.js";
-/** A question waits for its answer this long before the step is due again on its own: never, in practice. */
 export const ASKED = "9999-12-31T00:00:00.000Z";
-/** What "handle" zones with no answers of their own offer: going on to the next zone. */
 const CARRY_ON = "Carry on";
-/** v94: tool calls one visit of a card may make, and turns one step run may take, before it must decide with what it has. */
 export const CALLS_PER_VISIT = 12;
 const TURNS_PER_RUN = 8;
-/** The two answers an ask-first call offers; words instead tell the subagent what to do. */
 export const APPROVE = "approve", DENY = "deny";
 const startOfDay = (now) => { const day = new Date(now); day.setHours(0, 0, 0, 0); return day.toISOString(); };
-/** The Claude model a subagent's turns run on: its own, or the lead chat's Claude model, or Claude's default. */
 export function subagentModel(store, mate) {
     const config = store.getChatConfig();
     return mate.model ?? (config?.provider === "claude-subscription" ? config.model : "default");
 }
-/** Whether a subagent can take a turn now: active, readable, and under its daily limit. */
 export function subagentReady(store, mate, now) {
     if (mate === null)
         return { ok: false, why: "gone" };
@@ -33,21 +27,17 @@ export function subagentReady(store, mate, now) {
         return { ok: false, why: "its soul file can't be read" };
     if (store.subagentTurnsSince(mate.id, startOfDay(now)) >= mate.dailyTurns)
         return { ok: false, why: `it reached today's limit of ${mate.dailyTurns} turns` };
-    // v105: its turns bill as this computer's Claude does with no key from us; billed to a key, a budget holds them.
     const held = store.budgetGate(now)({ project: mate.repo, person: null, subagent: mate.id, agents: [{ provider: "claude", billing: claudeMachineBilling(store.handle) }] });
     if (held.over !== null)
         return { ok: false, why: held.why === "used-up" ? "a monthly budget its work counts toward is used up" : "a monthly budget can't price its work yet" };
-    // Sprint 8: its turns run on Claude, with its own model or the lead chat's: the organisation policy has to allow them.
     const disallowed = store.agentPolicyRefusal("claude", subagentModel(store, mate));
     if (disallowed !== null)
         return { ok: false, why: disallowed };
     return { ok: true };
 }
-/** The answers a "Subagent handles it" zone offers, each with the zone it leads to. */
 export function handleAnswers(stage) {
     return stage.routes !== undefined && stage.routes.length > 0 ? stage.routes : [{ answer: CARRY_ON, to: stage.next }];
 }
-/** Everything the turn is told. */
 function contextOf(store, flow, definition, stage, card, mate, tools = [], spent = false) {
     const soul = parseSoul(mate.soul);
     if (!soul.ok)
@@ -55,7 +45,6 @@ function contextOf(store, flow, definition, stage, card, mate, tools = [], spent
     const title = (id) => definition.stages.find(one => one.id === id)?.title ?? id;
     const draft = stage.kind === "approval" ? draftFor(definition, stage) : null;
     const question = store.subagentQuestionFor(card.id, card.entry);
-    // v95: what its people told it lately, and what it kept that fits this card.
     const memory = memoriesFor(store, mate, `${card.title}\n${card.description ?? ""}`, new Date());
     return {
         soul: mate.soul, name: soul.soul.name, role: soul.soul.role, flow: flow.name, zone: stage.title, kind: stage.kind === "approval" ? "decide" : "handle",
@@ -79,25 +68,17 @@ function contextOf(store, flow, definition, stage, card, mate, tools = [], spent
         }),
     };
 }
-/**
- * Run one subagent turn on a card and carry out what it decided. With tools
- * (v94) a turn is a short loop: each tool call it asks for is made (or put to
- * its person, and the turn waits), and it decides again with the answer —
- * until it decides, or it has used its tools as much as a visit allows.
- */
 export async function subagentTurn(store, flow, definition, stage, card, mate, now, io) {
     const model = subagentModel(store, mate);
     if (store.subagentGrants(mate.id).length > 0) {
         try {
             await refreshGrants(store, mate, now, io);
         }
-        catch { /* the last listing stands */ }
-        // Calls a person approved since the last turn are made first, exactly as they approved them.
+        catch { }
         for (const call of store.subagentCallsOn(card.id, card.entry).filter(one => one.state === "approved" && one.undoOf === null))
             await makeCall(store, call, flow.repo, io, now);
     }
     const log = [];
-    /** The one shorten turn this run allows: an answer over a limit is asked once, then kept whole. */
     let shorten;
     let shortened = false;
     for (let turn = 1;; turn++) {
@@ -107,7 +88,6 @@ export async function subagentTurn(store, flow, definition, stage, card, mate, n
         const context = { ...contextOf(store, flow, definition, stage, card, mate, tools, spent && made > 0), ...(shorten === undefined ? {} : { shorten }) };
         const asked = Date.now();
         const reply = await (io.turn ?? claudeTurnRunner())({ model, prompt: turnPrompt(context), timeoutMs: TURN_TIMEOUT_MS });
-        // v97: every turn is kept with what it cost, for its weekly report.
         store.addSubagentTurn({ subagent: mate.id, card: card.id, model, ok: reply.ok, ms: reply.ok ? reply.ms : Date.now() - asked, costUsd: reply.costUsd ?? null, tokensIn: reply.tokensIn ?? null, tokensOut: reply.tokensOut ?? null }, now);
         if (!reply.ok)
             return { state: "retry", said: reply.said, ...(log.length === 0 ? {} : { log: log.join("\n\n") }) };
@@ -137,11 +117,6 @@ export async function subagentTurn(store, flow, definition, stage, card, mate, n
             return { ...waiting, log: log.join("\n\n") };
     }
 }
-/**
- * One tool call a turn asked for, checked against its rules: made now (the
- * turn goes on: null), refused with the reason (the turn goes on and reads
- * it), or put to its person — the turn waits for the answer.
- */
 async function useTool(store, flow, stage, card, mate, context, answer, io, now) {
     const split = answer.tool.indexOf(".");
     const tool = split < 0 ? answer.tool : answer.tool.slice(0, split), action = split < 0 ? "" : answer.tool.slice(split + 1);
@@ -172,7 +147,6 @@ async function useTool(store, flow, stage, card, mate, context, answer, io, now)
         await makeCall(store, store.subagentCall(id), flow.repo, io, now);
         return null;
     }
-    // Ask first: its person approves this exact call, in their chat app or on the card.
     const soul = { name: context.name, role: context.role };
     const id = store.addSubagentCall({ ...receipt, input, rule: "ask", state: "asked", result: rule.why }, now);
     const words = callWords(tool, action, input, 480);
@@ -186,8 +160,6 @@ async function useTool(store, flow, stage, card, mate, context, answer, io, now)
         store.updateFlowCard(card.id, { waiting: `${context.name} asked ${context.person} to approve: ${words}`.slice(0, 300) }, now);
     return { state: "waiting", said: `Asked ${context.person} to approve ${action}`, nextAt: ASKED };
 }
-/** Text still over its limit after the one shorten turn: attached whole to the card's discussion, and what is passed on
- * (a note, or what the next zones read) is a link to it. Never cut. */
 function keptWhole(store, flow, card, author, text, limit, holds, what, now) {
     const kept = passOn(text, limit, { label: "the card's discussion", href: flowCardHref(flow.id, card.id) }, holds);
     if (kept.kept)
@@ -218,7 +190,6 @@ function carryOut(store, flow, definition, stage, card, mate, context, answer, n
     }
     if (answer.action === "hand_off") {
         event("handed", `Handed “${card.title}” to ${context.person}${answer.note === "" ? "" : `: ${answer.note}`}`);
-        // The engine sees the hand-off (a passed turn in the same visit) and asks the person, with this note.
         return { state: "passed", said: `Handed to ${context.person}`, log, decisionJson };
     }
     if (answer.action === "ask") {
@@ -235,7 +206,6 @@ function carryOut(store, flow, definition, stage, card, mate, context, answer, n
     }
     if (answer.action === "cant") {
         event("handled", `Couldn't handle “${card.title}”: ${answer.note}`);
-        // A zone that answers whoever asked tells them it couldn't, in its own words when it gave some: they always hear back.
         if (stage.reply === true)
             replyToAsker(store, flow, card, mate, answer.note || (answer.reason === "" ? `${context.name} couldn't handle this.` : `${context.name} couldn't handle this: ${answer.reason}`), now);
         if (stage.onFail !== null)
@@ -244,9 +214,7 @@ function carryOut(store, flow, definition, stage, card, mate, context, answer, n
             store.updateFlowCard(card.id, { waiting: `${context.name} couldn't handle it: ${answer.note}`.slice(0, 300) }, now);
         return { state: "failed", said: answer.note || "It couldn't handle this card.", log, decisionJson };
     }
-    // route: the answer names where the card goes; its text is what the next zones use.
     const picked = handleAnswers(stage).find(one => one.answer.toLowerCase() === answer.answer.toLowerCase());
-    // What the next zones read: whole up to what a step passes on; longer is attached whole to the card, and they read a link to it.
     if (answer.text !== "") {
         const whole = wholeDraft(answer.text);
         const text = keptWhole(store, flow, card, actor, whole, TEXT_LIMITS.stageOutput, "a step passes on", `What ${label} wrote for the next zones`, now);
@@ -254,7 +222,6 @@ function carryOut(store, flow, definition, stage, card, mate, context, answer, n
     }
     const said = `Sent “${card.title}” to ${titleOf(picked.to)}${picked.answer === CARRY_ON ? "" : ` (${picked.answer})`}${answer.reason === "" ? "" : `: ${answer.reason}`}`;
     event("handled", said);
-    // v96: a zone that answers whoever asked sends what it wrote back to them, under its name.
     if (stage.reply === true && answer.text !== "")
         replyToAsker(store, flow, card, mate, answer.text, now);
     if (picked.to === null)
@@ -263,7 +230,6 @@ function carryOut(store, flow, definition, stage, card, mate, context, answer, n
         store.moveFlowCard(card.id, { to: picked.to, outcome: "ok", actor, historyNote: `${actor}: ${picked.answer === CARRY_ON ? "" : `${picked.answer}. `}${answer.reason}`.trim(), expectEntry: card.entry }, now);
     return { state: "passed", said, log, decisionJson };
 }
-/** A person answers a subagent's question: once, by the person it was asked of; the card's turn is due again. */
 export function answerSubagentQuestion(store, id, answer, now) {
     return store.transact(() => {
         const question = store.subagentQuestion(id);
@@ -276,9 +242,7 @@ export function answerSubagentQuestion(store, id, answer, now) {
         if (choice === null && text === null)
             return { ok: false, said: "Pick an answer or write one." };
         const card = store.getFlowCard(question.card);
-        // v95: a rule change it suggested to its manager. Nothing about the card waits on it.
         if (question.suggestion !== null) {
-            // A suggestion loosens a rule: accepted only with the person's proof, on its page (chat-management.md §0a.3).
             if (choice?.id === ACCEPT && answer.widening !== "proved")
                 return { ok: false, said: "Changing this rule takes your password. Answer it on the subagent's page in Toolroll." };
             const mate = store.getSubagent(question.subagent);
@@ -287,7 +251,6 @@ export function answerSubagentQuestion(store, id, answer, now) {
             store.addSubagentEvent({ subagent: question.subagent, card: question.card, entry: question.entry, kind: "answered", said: `${answer.by}: ${[choice?.label, text].filter(Boolean).join(" — ")}`, by: answer.by }, now);
             return decided;
         }
-        // v94: an ask-first tool call. Approve makes exactly that call (on the card's next turn); Deny, or words alone, don't.
         if (question.toolCall !== null) {
             if (card === null || card.state !== "active" || card.entry !== question.entry) {
                 store.moveSubagentCall(question.toolCall, ["asked"], { state: "refused", result: "The card moved on before anyone approved it." }, now);
@@ -296,7 +259,6 @@ export function answerSubagentQuestion(store, id, answer, now) {
             }
             if (!store.moveSubagentCall(question.toolCall, ["asked"], { state: choice?.id === APPROVE ? "approved" : "denied", decidedBy: answer.by }, now))
                 return { ok: false, said: "That call was already decided." };
-            // v95: approving the same action again and again teaches it to suggest a looser rule.
             const mate = store.getSubagent(question.subagent), call = store.subagentCall(question.toolCall);
             if (choice?.id === APPROVE && mate !== null && call !== null)
                 considerSuggestion(store, mate, call, now);

package/dist/subagents-ui.js

@@ -7,10 +7,8 @@ import { deskOf, localZone, routinesOf } from "./subagent-desk.js";
 import { weekOf, weekWords } from "./subagent-week.js";
 import { describeSchedule, parseSchedule } from "./flow-schedule.js";
 import { html, joinHtml, postForm, reauth } from "./html.js";
-/** v94: the Tools section's rule rows; a limit's fields show only while "Up to a limit" is chosen. */
 export const SUBAGENT_CSS = `.subagent-tools .tool-grant{border-top:1px solid var(--so-line);padding-top:12px;margin-top:12px}.subagent-tools .tool-grant:first-of-type{border-top:0;margin-top:0;padding-top:0}.subagent-tools h3{font-size:1rem;margin:0 0 4px}.subagent-tools .tool-rule{display:grid;gap:6px;padding:10px 0;border-bottom:1px solid var(--so-line)}.subagent-tools .tool-rule:last-of-type{border-bottom:0}.subagent-tools .tool-rule .meta{display:block}.subagent-tools select,.subagent-tools input{max-width:100%;box-sizing:border-box}.subagent-tools .tool-limit{display:none;flex-wrap:wrap;align-items:center;gap:6px}.subagent-tools .tool-rule:has(option[value="limit"]:checked) .tool-limit{display:flex}.subagent-tools .tool-rule>select{width:auto;min-width:16em}.subagent-tools .tool-limit select{width:auto}.subagent-tools .tool-limit input{width:7em}.subagent-tools .tool-buttons{display:flex;flex-wrap:wrap;gap:8px;margin-top:8px}.subagent-tools button{min-height:44px}.subagent-activity li{overflow-wrap:anywhere}.subagent-memory .memory-tell,.subagent-memory .memory-search{display:flex;flex-wrap:wrap;gap:8px;align-items:flex-end;margin:0 0 12px}.subagent-memory .memory-tell textarea{flex:1 1 280px}.subagent-memory .memory-search input{flex:1 1 220px}.subagent-memory button{min-height:44px}.subagent-memories{list-style:none;padding:0;margin:0}.subagent-memories li{padding:10px 0;border-top:1px solid var(--so-line);overflow-wrap:anywhere}.subagent-memories li:first-child{border-top:0}.subagent-memories .meta{display:block;font-size:.85rem}.subagent-memories details.memory-edit{border:0;padding:0;margin:2px 0 0;background:transparent;box-shadow:none}.memory-edit summary{cursor:pointer;min-height:32px;display:inline-flex;align-items:center;font-size:.85rem;font-weight:400;color:var(--so-muted)}.tool-undo{border:0;padding:0;margin:8px 0;background:transparent;box-shadow:none}.tool-undo summary{cursor:pointer;min-height:36px;display:inline-flex;align-items:center;font-size:.9rem}.tool-undo-row{display:flex;flex-wrap:wrap;gap:6px;align-items:center;margin:6px 0}.tool-undo-row select{width:auto}.subagent-overrides,.subagent-undo{padding-left:18px}.subagent-undo li{margin:6px 0}.subagent-undo form{display:inline}.subagent-week h3{font-size:1rem;margin:14px 0 4px}.subagent-week button{min-height:44px}.subagent-routines{list-style:none;padding:0;margin:8px 0}.subagent-routines li{display:grid;gap:4px;padding:10px 0;border-top:1px solid var(--so-line)}.subagent-routines li:first-child{border-top:0}.routine-buttons{display:flex;flex-wrap:wrap;gap:8px}.routine-buttons button,.routine-add button{min-height:44px}.routine-add{display:flex;flex-wrap:wrap;gap:8px;align-items:flex-end;margin:8px 0}.routine-add label{display:grid;gap:4px;flex:1 1 200px}.routine-add label:first-of-type{flex:0 1 180px}.subagent-actions,.question-options{display:flex;flex-wrap:wrap;gap:8px;margin:8px 0}.subagent-actions form,.question-options form{margin:0}.memory-edit form{display:grid;gap:8px;margin-top:6px}.memory-buttons{display:flex;flex-wrap:wrap;gap:8px}@media(max-width:600px){.subagent-tools select,.subagent-tools input{font-size:16px}}`;
 const USES = [["free", "Do it"], ["limit", "Do it, up to a limit"], ["ask", "Ask first"], ["never", "Never"]];
-/** v94: which project tools it may use, and its rule for each action. */
 function toolsSection(store, mate, canManage) {
     const name = nameOf(mate);
     const tools = projectToolsOf(store, mate.repo);
@@ -31,7 +29,6 @@ function toolsSection(store, mate, canManage) {
             return html `<div class="tool-rule" data-tool-action="${action.name}"><label for="use-${field}"><strong>${action.name}</strong>${about}</label><select id="use-${field}" name="use.${action.name}">${USES.filter(([value]) => value !== "limit" || numbers.length > 0).map(([value, label]) => html `<option value="${value}"${value === use && html ` selected`}>${label}</option>`)}</select>${limit}</div>`;
         });
         const head = html `<h3>${grant.tool}</h3>${gone && html `<p class="problem">This project doesn't have ${grant.tool} any more, so ${name} can't use it.</p>`}`;
-        // v97: which action undoes which, for the Undo button on its receipts. Optional, so it's folded away.
         const undoing = grant.actions.filter(one => !one.readOnly).map(action => {
             const chosen = grant.rules[action.name]?.undo ?? "";
             return html `<label class="tool-undo-row">${action.name} is undone by<select name="undo.${action.name}"><option value="">nothing</option>${grant.actions.filter(other => other.name !== action.name).map(other => html `<option value="${other.name}"${other.name === chosen && html ` selected`}>${other.name}</option>`)}</select></label>`;
@@ -50,9 +47,7 @@ function toolsSection(store, mate, canManage) {
 }
 const when = (at) => new Date(at).toLocaleString("en", { month: "short", day: "numeric", hour: "numeric", minute: "2-digit" });
 const startOfDay = () => { const day = new Date(); day.setHours(0, 0, 0, 0); return day.toISOString(); };
-/** Text whose line breaks show as breaks. */
 const lines = (text) => joinHtml(text.split("\n"), html `<br>`);
-/** A blank soul file: the sections a subagent reads, to fill in. */
 export const BLANK_SOUL = `---\nname: \nrole: \n---\n\n## Who you are\n\n\n## How you write\n\n\n## What you know\n\n\n## Decide on your own\n- \n\n## Ask first\n- \n\n## Never\n- \n`;
 export function subagentsListHtml(store, mates, projects, projectName, canCreate, notice) {
     const rows = mates.map(mate => {
@@ -66,7 +61,6 @@ export function subagentsListHtml(store, mates, projects, projectName, canCreate
     const intro = html `<p class="meta">Your lead's helpers. Each works within rules you write and asks you when they say to. The quickest start is a <a href="/kits">starter kit</a>.</p>`;
     return html `<section class="subagents">${notice.problem && html `<p class="problem" role="alert">${notice.problem}</p>`}${notice.said && html `<p class="said" role="status">${notice.said}</p>`}${intro}${rows.length > 0 ? rows : html `<p class="meta">No subagents yet.</p>`}${create}</section>`;
 }
-/** v97: its week: what it did and cost, what people overrode, and calls that can be undone. */
 function weekSection(store, mate, canManage) {
     const week = weekOf(store, mate, new Date());
     const overrides = week.overrides.length > 0 && html `<h3>What you overrode</h3><ul class="subagent-overrides">${week.overrides.map(one => html `<li>${one.said}${one.href !== null && html ` · <a href="${one.href}">open</a>`} <span class="meta">${when(one.at)}</span></li>`)}</ul>`;
@@ -74,7 +68,6 @@ function weekSection(store, mate, canManage) {
     const send = canManage && postForm(`/settings/lead/subagents/${mate.id}/week`, html `<button name="op" value="send" class="secondary">Send the week's report</button>`);
     return html `<details class="card subagent-week" id="week" open><summary>This week</summary><p class="subagent-week-said">${lines(weekWords(mate, week))}</p>${overrides}${undo}${send}</details>`;
 }
-/** v96: its desk — where messages to it by name and its routines land — and its routines. */
 function deskSection(store, mate, canManage) {
     const name = nameOf(mate);
     const desk = deskOf(store, mate);
@@ -84,9 +77,7 @@ function deskSection(store, mate, canManage) {
     const add = canManage && postForm(`/settings/lead/subagents/${mate.id}/routines`, html `<label>When<input type="text" name="schedule" maxlength="80" placeholder="weekdays 09:00" required></label><label>What to do<input type="text" name="text" maxlength="200" placeholder="Look up yesterday's refunds and tell me the total." required></label><button>Add routine</button>`, { attrs: { class: "routine-add" }, hidden: { op: "add" } });
     return html `<section class="card subagent-desk" id="desk"><h2>Desk and routines</h2>${intro}${list}${add}${canManage && html `<p class="meta">A routine puts a card on its desk on that schedule (“weekdays 09:00”, “daily 17:00”, “monday 09:00”, “every 2 hours”; times are this computer's, ${localZone()}, unless you name one); the answer goes to ${mate.manager}.</p>`}</section>`;
 }
-/** A schedule's stored form ("weekdays:09:00@Europe/London") in words. */
 const scheduleWords = (text) => { const parsed = parseSchedule(text); return parsed === null ? text : describeSchedule(parsed); };
-/** v95: what it remembers — what its people told it, and what it kept from cards — to search, edit and forget. */
 function memorySection(store, mate, canManage, query) {
     const name = nameOf(mate);
     const all = store.subagentMemories(mate.id, { limit: 500 });
@@ -110,16 +101,13 @@ export function subagentPageHtml(store, mate, viewer, projectName, canManage, ap
         const flow = card === null ? null : store.getFlow(card.flow);
         const mine = question.askedOf === viewer;
         const cardLink = card === null || flow === null ? "a card" : html `<a href="/flows/${flow.id}?card=${card.id}">${card.title}</a>`;
-        const answer = mine && html `<div class="question-options">${question.options.map(one => postForm(`/settings/lead/subagents/questions/${question.id}/answer`, 
-        // Accepting a looser rule it suggested takes the password (chat-management.md §0a.3).
-        question.suggestion !== null && one.id === "accept" ? html `${reauth(html `<input type="password" name="password" autocomplete="current-password" aria-label="Your password" placeholder="Your password">`)}<button>${one.label}</button>` : html `<button>${one.label}</button>`, { hidden: { choice: one.id } }))}</div>${postForm(`/settings/lead/subagents/questions/${question.id}/answer`, html `<label>Or answer in your words<textarea name="text" rows="2" maxlength="2000"></textarea></label><button>Answer</button>`, { attrs: { class: "question-reply" } })}`;
+        const answer = mine && html `<div class="question-options">${question.options.map(one => postForm(`/settings/lead/subagents/questions/${question.id}/answer`, question.suggestion !== null && one.id === "accept" ? html `${reauth(html `<input type="password" name="password" autocomplete="current-password" aria-label="Your password" placeholder="Your password">`)}<button>${one.label}</button>` : html `<button>${one.label}</button>`, { hidden: { choice: one.id } }))}</div>${postForm(`/settings/lead/subagents/questions/${question.id}/answer`, html `<label>Or answer in your words<textarea name="text" rows="2" maxlength="2000"></textarea></label><button>Answer</button>`, { attrs: { class: "question-reply" } })}`;
         return html `<article class="card subagent-question" data-question="${question.id}"${question.suggestion !== null && html ` data-suggestion`}><p class="meta">${question.suggestion === null ? html `About ${cardLink}` : "Suggests a rule change"} · ${when(question.createdAt)}${!mine && ` · for ${question.askedOf}`}</p><p><strong>${question.question}</strong></p>${answer}</article>`;
     });
     const zones = zonesOf(store, mate);
     const where = zones.length === 0
         ? html `<p class="meta">Not on any zone yet. In a flow, choose ${name} under “Who decides” on a “Person decides” zone, or add a “Subagent handles it” zone.</p>`
         : html `<ul>${zones.map(one => html `<li><a href="/flows/${one.flow}">${one.flowName}</a> · ${one.kind === "decides" ? "decides" : "handles"} ${one.title}</li>`)}</ul>`;
-    // What it did and why, with every tool call it made or asked to make (v94), newest first.
     const events = [
         ...store.subagentEvents(mate.id, 40).filter(one => one.kind !== "note").map(one => ({ kind: one.kind, said: one.said, card: one.card, at: one.at })),
         ...store.subagentCallsOf(mate.id, 40).map(one => ({ kind: "call", said: `Used ${callWords(one.tool, one.action, one.input, 200)} · ${receiptWords(store, one)}`, card: one.card, at: one.createdAt })),