toolroll 0.9.16 → 0.9.18

package/dist/browser-workspace.d.ts

@@ -225,6 +225,8 @@ export type BrowserSettingsView = {
     chat?: {
         mode: 'quiet' | 'all';
         digestAt: string | null;
+        /** Whether a result's saved screenshots follow its chat message: off, the first one, or up to 4. */
+        screenshots?: 'off' | 'first' | 'all';
         /** Each project this person can see; a muted one sends no pings but stays in Tasks and the digest. */
         projects?: {
             repo: string;

package/dist/chat-actions.d.ts

@@ -196,6 +196,11 @@ export declare const CHAT_ACTIONS: {
         readonly protected: false;
         readonly password: false;
     };
+    readonly lead_about_you: {
+        readonly label: "Remember";
+        readonly protected: false;
+        readonly password: false;
+    };
     readonly scope_approve: {
         readonly label: "Approve work";
         readonly protected: true;
@@ -222,6 +227,8 @@ export type ChatAction = keyof typeof CHAT_ACTIONS;
  * yes/cancel challenge instead of the console's secure screen. Password
  * actions and long or redacted terms never qualify. */
 export declare const CHALLENGE_ACTIONS: ReadonlySet<ChatAction>;
+/** Actions about the person themselves, in no project: their card carries no project (repo ""). */
+export declare const OWNER_ACTIONS: ReadonlySet<ChatAction>;
 export declare function isChatAction(value: unknown): value is ChatAction;
 export type SharedAction = {
     operation: ChatAction;

package/dist/chat-actions.js

@@ -32,6 +32,7 @@ import { kitInstalled, kitOf, KITS, setUpKitNow } from "./kits.js";
 import { starterFlowOf, starterOf, startersFor, starterTerms, STARTER_FLOWS, switchOnStarter } from "./flow-starters.js";
 import { answerTeammateQuestion } from "./teammate-work.js";
 import { callWords, checkRule, defaultRule, grantListed, revokeTool, ruleWords, setToolRules } from "./teammate-tools.js";
+import { aboutYouOf, checkAboutYouLine, saveAboutYou, withAboutYouLine } from "./lead-about.js";
 /** A tool from the lead's card: a common tool by its id, or the operator's own program or address. */
 function toolSpecFromRequest(input) {
     if (input["catalog"] !== undefined) {
@@ -107,6 +108,8 @@ export const CHAT_ACTIONS = {
     kit_setup: { label: "Set up kit", protected: false, password: false },
     decision_record: { label: "Record decision", protected: false, password: false },
     decision_retire: { label: "Retire decision", protected: false, password: false },
+    // What the owner's own lead knows about them: theirs alone, in no project (lead-about.ts).
+    lead_about_you: { label: "Remember", protected: false, password: false },
     scope_approve: { label: "Approve work", protected: true, password: true },
     result_accept: { label: "Accept and finish", protected: true, password: false },
     task_cancel: { label: "Cancel task", protected: true, password: false },
@@ -116,6 +119,8 @@ export const CHAT_ACTIONS = {
  * yes/cancel challenge instead of the console's secure screen. Password
  * actions and long or redacted terms never qualify. */
 export const CHALLENGE_ACTIONS = new Set(["result_accept"]);
+/** Actions about the person themselves, in no project: their card carries no project (repo ""). */
+export const OWNER_ACTIONS = new Set(["lead_about_you"]);
 export function isChatAction(value) {
     return typeof value === "string" && Object.hasOwn(CHAT_ACTIONS, value);
 }
@@ -160,19 +165,21 @@ export const CHAT_ACTION_FIELDS = {
     kit_setup: ["repo", "kit"],
     decision_record: ["repo", "claim", "why", "supersedes", "source"],
     decision_retire: ["repo", "decision", "reason"],
+    lead_about_you: ["line", "replaces"],
     scope_approve: ["task"],
     result_accept: ["task", "run"],
     task_cancel: ["task"],
     task_resume: ["task", "run"],
 };
 const nonceHash = (value) => createHash("sha256").update(value).digest("hex");
-function requireActor(store, who, repo) {
+function requireActor(store, who, repo, operation) {
     if (!store.schemaCurrent())
         throw Error("The running build changed. Reload before proposing an action.");
+    // An action about the person themselves names no project; every other one names one they can reach.
+    const owned = repo === "" && operation !== undefined && OWNER_ACTIONS.has(operation);
     if (!isVerifiedApprover(who) ||
         !reproveApprover(store, who).ok ||
-        !who.repos.includes(repo) ||
-        !store.accountCanAccess(who.name, repo))
+        (!owned && (!who.repos.includes(repo) || !store.accountCanAccess(who.name, repo))))
         throw Error("This project is outside your current access.");
 }
 function text(input, key, cap, optional = false) {
@@ -267,6 +274,28 @@ export function prepareSharedAction(store, who, operation, input, root, now = ne
     const allowed = CHAT_ACTION_FIELDS[operation];
     if (Object.keys(input).some((key) => !allowed.includes(key)))
         throw Error("This action contains an unsupported field.");
+    if (operation === "lead_about_you") {
+        // The owner's own note: the card shows the line, and the line it replaces beside it.
+        const checked = checkAboutYouLine(input["line"]);
+        if (!checked.ok)
+            throw Error(checked.message);
+        const lines = aboutYouOf(store, who.name);
+        const replaces = input["replaces"] === undefined || input["replaces"] === 0 ? 0 : integer(input, "replaces");
+        const next = withAboutYouLine(lines, checked.line, replaces);
+        if (!next.ok)
+            throw Error(next.message);
+        requireActor(store, who, "", operation);
+        const request = { line: checked.line, ...(replaces === 0 ? {} : { replaces }) };
+        const terms = replaces === 0
+            ? [checked.line, "Your lead keeps this about you in every project. Change it in Settings → Lead."]
+            : [`Was: ${lines[replaces - 1]}`, `Now: ${checked.line}`, "Replaces that line in what your lead knows about you. Change it in Settings → Lead."];
+        // An added line goes on the end, so it holds whatever else changed; a replacing card holds only while the line
+        // it replaces is still that line.
+        const state = replaces === 0 ? {} : { was: lines[replaces - 1] };
+        const title = replaces === 0 ? "Remember about you" : "Update what your lead knows about you";
+        const stamp = hash({ operation, request, repo: "", state, terms, actor: who.name, generation: who.generation, ceiling: who.ceilingDigest });
+        return { operation, request, repo: "", title, terms, stamp, state };
+    }
     const task = operation.startsWith("skill_") || operation.startsWith("knowledge_") || operation.startsWith("decision_") || operation.startsWith("tool_") || operation.startsWith("flow_") || operation.startsWith("teammate_") || operation.startsWith("kit_")
         ? null
         : text(input, "task", 64);
@@ -954,7 +983,7 @@ function savedActionContext(store, who, id, state) {
         (!shared && turn?.session !== session.id) ||
         turn?.state !== "answered")
         throw Error("This conversation ended or its project access changed. Ask for a fresh proposal.");
-    requireActor(store, who, payload.repo);
+    requireActor(store, who, payload.repo, payload.operation);
     return payload;
 }
 export function mintSharedActionReview(store, who, id, root, now) {
@@ -1013,6 +1042,13 @@ export function executeSharedAction(store, who, id, payload, now, options) {
         return store.savepoint(() => {
             const task = typeof req["task"] === "string" ? req["task"] : null, repo = payload.repo, actor = who.name;
             let taskId = task;
+            if (payload.operation === "lead_about_you") {
+                const next = withAboutYouLine(aboutYouOf(store, actor), String(req["line"]), Number(req["replaces"] ?? 0));
+                if (!next.ok)
+                    throw Error(next.message);
+                saveAboutYou(store, actor, next.lines, now);
+                return { ok: true, taskId: null, said: req["replaces"] === undefined ? "Your lead will remember this." : "Updated what your lead knows about you.", href: "/settings/lead" };
+            }
             if (payload.operation === "skill_import")
                 importSkill(store, repo, actor, req["files"], "Chat import", now);
             else if (payload.operation === "skill_test")

package/dist/chat-ask.js

@@ -21,12 +21,21 @@ export function chatAskButtons(state, part, now) {
     })
         .filter((one) => one !== null);
 }
-/** Show the question again with what happened, and without its buttons. */
-function repaint(state, part, event, line) {
-    const row = state.prepare("SELECT payload FROM chat_part WHERE id=?").get(part);
-    const before = row === undefined ? { text: "" } : JSON.parse(String(row["payload"]));
+/** How old a part may be and still be sent: older ones are dropped undelivered (slack-chat.ts, discord-chat.ts,
+ * teams-chat.ts), so an edit to one would never land. */
+const EDIT_WINDOW_MS = 86_400_000;
+/** Show the question again with what happened, and without its buttons: one edit, under the part's own time. A question
+ * too old to edit gets the line once as a new message instead. */
+function repaint(state, part, event, line, now) {
+    const row = state.prepare("SELECT payload,created FROM chat_part WHERE id=?").get(part);
+    if (row === undefined || new Date(String(row["created"])).getTime() + EDIT_WINDOW_MS <= now.getTime()) {
+        state.plan(event.id, [{ text: line }], now);
+        return;
+    }
+    const before = JSON.parse(String(row["payload"]));
     const content = { text: `${before.text}\n\n${line}`.slice(0, 3400), edit: event.ts, ...(before.channel === undefined ? {} : { channel: before.channel }) };
     state.prepare("UPDATE chat_part SET payload=?,state='pending',next_at=NULL WHERE id=?").run(JSON.stringify(content), part);
+    state.finish(event.id);
 }
 /** A tapped ask button, inside the action's transaction; false when the token isn't one. */
 export function applyChatAskTap(options, event, binding, token, now) {
@@ -41,17 +50,23 @@ export function applyChatAskTap(options, event, binding, token, now) {
         return true;
     }
     const turn = Number(action["turn"]), part = Number(action["part"]);
-    const found = store.getMateTurn(turn)?.approver === binding.approver ? store.mateAskState(turn, now) : { state: "expired" };
+    // Only the person the lead asked answers it: anyone else's tap changes nothing and says nothing.
+    const asker = store.getMateTurn(turn)?.approver;
+    if (asker !== undefined && asker !== binding.approver) {
+        state.finish(event.id);
+        return true;
+    }
+    const found = asker === undefined ? { state: "expired" } : store.mateAskState(turn, now);
     const expired = found.state === "expired" || String(action["expires"]) <= now.toISOString();
-    if (action["consumed"] !== null || found.state !== "open" || expired) {
+    // A question already settled was shown so once (or is being): a later tap says nothing more.
+    if (action["consumed"] !== null) {
+        state.finish(event.id);
+        return true;
+    }
+    if (found.state !== "open" || expired) {
         state.prepare("UPDATE chat_ask_action SET consumed=? WHERE part=? AND consumed IS NULL").run(now.toISOString(), part);
-        if (found.state === "answered" || (action["consumed"] !== null && !expired)) {
-            repaint(state, part, event, "This question was already answered.");
-            state.finish(event.id);
-        }
-        // A question this old can no longer be edited in place: the answer to the tap is a new message.
-        else
-            say("This question expired. If it still matters, send your answer as a message.");
+        // The question is shown again without its buttons, so a later tap has nothing to press.
+        repaint(state, part, event, found.state === "answered" ? "This question was already answered." : "This question expired. If it still matters, send your answer as a message.", now);
         return true;
     }
     const ask = found.ask;
@@ -71,7 +86,6 @@ export function applyChatAskTap(options, event, binding, token, now) {
         channel: event.channel, member: event.member, ts: event.ts, thread: event.thread,
         payload: JSON.stringify({ text: option, originalLength: option.length }), created: now.toISOString(),
     });
-    repaint(state, part, event, `You chose: ${option}`);
-    state.finish(event.id);
+    repaint(state, part, event, `You chose: ${option}`, now);
     return true;
 }

package/dist/chat-channel.js

@@ -513,8 +513,10 @@ export const CHAT_ACTION_PARITY = {
     propose_flow: { support: "direct", how: "Creates or changes a flow, adds, moves, approves, sends back or cancels its cards, comments on them (@name pings that person), sets their owner, follows them, saves the project's scripts, and adds, pauses or removes its triggers, through the shared confirm door; a long drawing opens the secure review. Work a card files is an ordinary task under the usual approvals.", gap: "The flow canvas itself is on the console; the phone confirms cards but draws nothing. Webhook addresses and the Linear key are set on the console's Triggers panel." },
     commit_to: { support: "direct", how: "Records what the lead promised to follow up on (a task, attempt, check or time; 7 days at most). The follow pass says one line when it is met, in the shared conversation and on the chat the promise was made on.", gap: null },
     release_commitment: { support: "direct", how: "Stops following up on one of the person's open promises, with the reason.", gap: null },
-    remember: { support: "direct", how: "Proposes a correction or lasting preference as a decision or project instruction card, through the shared confirm door.", gap: null },
+    remember: { support: "direct", how: "Proposes a correction or lasting preference as a decision, project instruction or about-you card, through the shared confirm door; an about-you card shows the line it replaces.", gap: null },
+    get_person: { support: "direct", how: "Read during a turn: one person, AI teammate or team chat in full, with their open tasks.", gap: null },
     get_integrations: { support: "direct", how: "Read during a turn: which chat apps, email, GitHub, project tools and monitoring are Connected, Not set up or Broken, as Settings → Integrations shows them.", gap: null },
+    get_capabilities: { support: "direct", how: "Read during a turn: which agents are signed in, which workers are online, which tools and skills work, which integrations are connected and what checks the project runs, each with its next step and settings link.", gap: null },
     ask_owner: { support: "direct", how: "One question with 2-4 options and Something else, drawn as buttons under the reply; the tapped option is sent as the person's next message.", gap: null },
     search_project_memory: { support: "direct", how: "Read during a turn: one search over decisions, references, lessons and the conversations the person may read.", gap: null },
     list_tasks: { support: "direct", how: "Read during a turn.", gap: null },

package/dist/chat-decide.d.ts

@@ -0,0 +1,203 @@
+import { type ModeTerms } from "./modes.js";
+import { type VerifiedApprover } from "./principal.js";
+import type { Scope } from "./scope.js";
+import type { Store } from "./store.js";
+/** The tokens live in chat_decide_action and the open "What should change?" in chat_decide_prompt (store.ts). */
+export type DecideAct = "accept" | "changes" | "retry" | "approve" | "not-now" | "merge";
+export type DecideTarget = {
+    kind: "result";
+    taskId: string;
+    run: number;
+} | {
+    kind: "failed";
+    taskId: string;
+} | {
+    kind: "plan";
+    taskId: string;
+} | {
+    kind: "merge";
+    taskId: string;
+    run: number;
+};
+export type DecideChannel = "telegram" | "slack" | "discord" | "teams";
+/** Who is tapping, where: one paired person's binding on one channel, and the chat the card is in. */
+export type DecideSeat = {
+    channel: DecideChannel;
+    binding: number;
+    chat: string;
+    approver: string;
+    generation: number;
+};
+export type DecideLink = {
+    label: string;
+    path: string;
+};
+/** A button as a channel draws it: an act (its token) or a link to the console. */
+export type DecideButton = {
+    label: string;
+    token: string;
+} | {
+    label: string;
+    link: DecideLink;
+};
+/** The words, said once. */
+export declare const DECIDE_LABELS: {
+    readonly accept: "Accept and finish";
+    readonly changes: "Request changes";
+    readonly retry: "Retry";
+    readonly approve: "Approve & start";
+    readonly "not-now": "Not now";
+    readonly merge: "Merge";
+    readonly look: "Look first";
+    readonly edit: "Edit";
+    readonly yes: "Yes";
+    readonly cancel: "Cancel";
+};
+export declare const WHAT_SHOULD_CHANGE = "What should change?";
+type ActSpec = {
+    act: DecideAct;
+    run: number | null;
+    digest: string;
+};
+/** What a card offers: an optional replacement text (the plan card) and rows of acts and links. */
+export type DecideOffer = {
+    text: string | null;
+    rows: Array<Array<ActSpec | DecideLink>>;
+};
+/** The live mode on this repository, when it lets this person's chat approve: the term signed, by them. */
+export declare function chatApproveMode(store: Store, repo: string | null, approver: string, now: Date): {
+    ok: true;
+    digest: string;
+    terms: ModeTerms;
+} | {
+    ok: false;
+    why: string;
+};
+/** What a plan's yes allows an agent to do, in a few plain words (the approval sheet's "You're allowing"). */
+export declare function permissionPlainWords(profile: Scope["profile"] | null | undefined): string | null;
+/** A plan this person's chat may approve now: the term, the plan's exact bytes, and none of the reasons it must open
+ * Toolroll instead. `digest` binds the scope and the plan document the card shows. */
+export declare function planInChat(store: Store, taskId: string, approver: string, now: Date, root?: string): {
+    ok: true;
+    modeDigest: string;
+    digest: string;
+    scope: Scope;
+} | {
+    ok: false;
+    why: string;
+};
+/** A ready pull request this person's chat may merge now, bound to the exact commit. */
+export declare function mergeInChat(store: Store, taskId: string, run: number, approver: string, now: Date): {
+    ok: true;
+    modeDigest: string;
+    head: string;
+} | {
+    ok: false;
+    why: string;
+};
+/** The plan card: title, goal in two lines, what changes, done when, and what the yes allows. */
+export declare function planCardText(store: Store, taskId: string, scope: Scope, root?: string): string;
+/** The acts a card about this target can take in chat right now, or null when none can (the card keeps its own
+ * link). Reads only; nothing is minted. */
+export declare function decideOffer(store: Store, target: DecideTarget, who: VerifiedApprover, now: Date, root?: string): DecideOffer | null;
+/** One fingerprint of what the card offers, without its tokens: a repaint with the same offer keeps its buttons. */
+export declare function offerFingerprint(offer: DecideOffer): string;
+/** The card's buttons, minted now (message unknown until it is sent: `placeDecideTokens` puts them on it). */
+export declare function mintDecideButtons(store: Store, seat: DecideSeat, target: DecideTarget, offer: DecideOffer, now: Date, message?: string | null): {
+    rows: DecideButton[][];
+    tokens: string[];
+};
+/** Put freshly minted tokens on the message they ride: a tap on any other message proves itself stale. */
+export declare function placeDecideTokens(store: Store, tokens: readonly string[], message: string): void;
+/** Every live button on one message stops working: the card was repainted, or one of its acts was taken. */
+export declare function retireDecideTokens(store: Store, channel: DecideChannel, chat: string, message: string, now: Date): void;
+/** Buttons minted for a send or an edit that didn't land: they never act. */
+export declare function dropDecideTokens(store: Store, tokens: readonly string[], now: Date): void;
+/** Whether a message still carries a button that acts (an offer, or an armed Yes or Cancel): a card whose acts were
+ * all spent, as by Not now, needs fresh ones. */
+export declare function hasLiveDecideTokens(store: Store, channel: DecideChannel, chat: string, message: string, now: Date): boolean;
+export declare function isDecideToken(store: Store, token: string): boolean;
+export type DecideTapOutcome = {
+    ack: string;
+    /** The card repainted: its text and buttons now. */
+    edit?: {
+        text: string;
+        rows: DecideButton[][];
+        tokens: string[];
+    };
+    /** Ask "What should change?": the person's next message is the feedback. `id` names the prompt, so the channel can
+     * record the message it sent (a reply to anything else is not the feedback). */
+    prompt?: {
+        id: number;
+        text: string;
+    };
+    /** Merge after the transaction (GitHub is a network call); the card says "Merging…" until it lands, and
+     * `recordChatMerge` ledgers how it went. */
+    merge?: ChatMerge;
+    ignored?: boolean;
+};
+/** A merge approved in chat, waiting on GitHub: what its ledger line names once the answer is back. */
+export type ChatMerge = {
+    runId: number;
+    taskId: string;
+    by: string;
+    repo: string;
+    via: string;
+};
+/** The links a card keeps once its acts are spent or stale: where to look, never a token. */
+export declare function linksFor(target: DecideTarget): DecideButton[][];
+/**
+ * One tap on a decide button, inside the caller's transaction. Null: not this module's token. The seat must be the
+ * token's own (person, chat, message); a spent, expired or foreign button acts on nothing.
+ */
+export declare function applyDecideTap(store: Store, seat: DecideSeat, input: {
+    token: string;
+    message: string;
+    shown: string;
+    repos: readonly string[];
+    root?: string;
+    now: Date;
+}): DecideTapOutcome | null;
+/** A chat merge's second ledger line, after the GitHub call: merged, or failed and why (its approval is the first). */
+export declare function recordChatMerge(store: Store, merge: ChatMerge, result: {
+    ok: true;
+} | {
+    ok: false;
+    message: string;
+}, now: Date): void;
+/** What the card says once the merge came back. */
+export declare function mergedText(shown: string, result: {
+    ok: true;
+} | {
+    ok: false;
+    message: string;
+}): string;
+export type DecidePrompt = {
+    id: number;
+    taskId: string;
+    run: number;
+    digest: string;
+    message: string | null;
+};
+/** One open "What should change?" per person and chat: a newer one replaces it. */
+export declare function openDecidePrompt(store: Store, seat: DecideSeat, taskId: string, run: number, digest: string, now: Date): number;
+/** The message that asked "What should change?", once it was sent. */
+export declare function placeDecidePrompt(store: Store, id: number, message: string): void;
+export declare function openPromptFor(store: Store, seat: Pick<DecideSeat, "channel" | "binding" | "chat">, now: Date): DecidePrompt | null;
+/** Whether this message answers the prompt: the person's next message, unless it replies to some other message. */
+export declare function answersPrompt(prompt: DecidePrompt, replyTo: string | null): boolean;
+/** The person's message after "What should change?": a revision of the exact result, with these words as its
+ * feedback, through the result page's own service. Says what was sent, once. */
+export declare function applyDecideFeedback(store: Store, seat: DecideSeat, prompt: DecidePrompt, text: string, repos: readonly string[], root: string | undefined, now: Date): {
+    said: string;
+    link: DecideLink | null;
+};
+/** The link a card keeps when it can't act in chat: a plan's is Review & start, where the password step lives. */
+export declare function decideFallbackLink(target: DecideTarget | null): DecideLink | null;
+/** Which card a pushed notification is, from its recorded kind and task — never from its words. */
+export declare function decideTargetOf(row: {
+    kind: string;
+    taskId: string | null;
+    run: number | null;
+}): DecideTarget | null;
+export {};