toolroll 0.5.0

package/dist/chat-rooms.js

@@ -0,0 +1,216 @@
+import { TeamLeads } from "./team-leads.js";
+import { tooLongText } from "./chat-channel.js";
+import { MATE_MESSAGE_MAX_CHARS } from "./mate.js";
+import { phoneText } from "./telegram-status.js";
+/** `/team` lists, `/team <n>` chooses, `/team off` (or `private`) leaves.
+ * The bare word works too, because Slack and Discord keep unregistered
+ * slash text for themselves. Any other text is not ours. */
+export function roomCommand(text) {
+    const trimmed = text.trim();
+    if (/^\/?team(?:@\w+)?\s*$/i.test(trimmed))
+        return { kind: "list" };
+    const pick = /^\/?team(?:@\w+)?\s+([1-9][0-9]{0,2})\s*$/i.exec(trimmed);
+    if (pick !== null)
+        return { kind: "select", index: Number(pick[1]) };
+    if (/^\/?team(?:@\w+)?\s+(?:off|private)\s*$/i.test(trimmed))
+        return { kind: "off" };
+    return /^\/team(?:@\w+)?(?:\s|$)/i.test(trimmed) ? { kind: "list" } : null;
+}
+export const PAIR_FIRST = "Pair your account first: open Settings in Toolroll, choose this chat service, and send the code here in a private chat.";
+export function teamRequestId(channel, chatId, updateKey) {
+    return `${channel}:${chatId}:${updateKey}`;
+}
+function domainFor(store, projects) {
+    return new TeamLeads(store, () => projects ?? []);
+}
+export function conversationRow(store, id) {
+    const row = store.handle.prepare("SELECT c.id, c.title, c.thread, c.lead, c.visibility, l.name FROM team_conversation c JOIN team_lead l ON l.id = c.lead WHERE c.id = ?").get(id);
+    return row === undefined ? null : { conversation: String(row["id"]), title: String(row["title"]), thread: Number(row["thread"]), lead: String(row["lead"]), leadName: String(row["name"]), visibility: String(row["visibility"]) };
+}
+function conversationsFor(domain, actor) {
+    try {
+        const snapshot = domain.snapshot(actor);
+        return snapshot.conversations.map(conversation => ({ conversation, leadName: snapshot.leads.find(lead => lead.id === conversation.leadId)?.name ?? "lead" }));
+    }
+    catch {
+        return [];
+    }
+}
+function managerOf(domain, actor, conversationId) {
+    try {
+        return domain.access(actor, conversationId, "manager").role === "manager";
+    }
+    catch {
+        return false;
+    }
+}
+function privateListing(rows, current) {
+    if (rows.length === 0)
+        return "You are not in any team conversation yet. Join one in Toolroll under Chat → Team chat, then send /team again.";
+    const lines = ["Your conversations", ""];
+    rows.forEach((row, index) => {
+        lines.push(`${index + 1}. ${phoneText(row.conversation.title, 80)} — ${row.conversation.visibility === "team" ? "Team" : "Private"} · lead ${phoneText(row.leadName, 40)}${row.conversation.id === current ? " (current)" : ""}`);
+    });
+    lines.push("", current === null ? "This chat talks to your private assistant. Send /team <number> to talk in a conversation instead." : "Send /team <number> to switch, or /team off for your private assistant.");
+    return lines.join("\n");
+}
+function groupListing(rows, current) {
+    if (rows.length === 0)
+        return "No team conversation you manage is available to this room. Create one in Toolroll under Chat → Team chat, then send /team again.";
+    const lines = [current === null ? "Choose the conversation this room follows" : "This room follows a conversation", ""];
+    rows.forEach((row, index) => {
+        lines.push(`${index + 1}. ${phoneText(row.conversation.title, 80)} — lead ${phoneText(row.leadName, 40)}${row.conversation.id === current ? " (current)" : ""}`);
+    });
+    lines.push("", "Send /team <number> to follow it (managers only), or /team off to stop. Everyone in this room will read its replies.");
+    return lines.join("\n");
+}
+/**
+ * Handle one inbound message that belongs to the team layer. Returns true
+ * when it was consumed here (a `/team` command in any chat, any message in
+ * a followed room, or a private message while a conversation is selected);
+ * false hands the message to the transport's personal path untouched.
+ */
+export function applyRoomInbound(input) {
+    const { store, backend, chatId, isGroup, sender, now, report, say } = input;
+    const command = roomCommand(input.text);
+    const room = backend.room(chatId);
+    const domain = domainFor(store, input.projects);
+    const paired = sender !== null && store.accountOf(sender.approver)?.role === "approver";
+    const actor = sender === null ? null : { name: sender.approver, generation: sender.generation };
+    if (command !== null) {
+        report.statusReplies = (report.statusReplies ?? 0) + 1;
+        if (!paired || actor === null) {
+            say(PAIR_FIRST);
+            return true;
+        }
+        const rows = conversationsFor(domain, actor).filter(row => !isGroup || (row.conversation.visibility === "team" && managerOf(domain, actor, row.conversation.id)));
+        const current = room?.conversation ?? null;
+        if (command.kind === "list") {
+            say(isGroup ? groupListing(rows, current) : privateListing(rows, current));
+            return true;
+        }
+        if (command.kind === "off") {
+            const ended = room !== null && (!isGroup || managerOf(domain, actor, room.conversation) || room.boundBy === actor.name) && backend.unbind(chatId, actor.name);
+            say(ended ? (isGroup ? "This room no longer follows a conversation." : "Back to your private assistant.") : isGroup ? "This room follows nothing you can change." : "This chat already talks to your private assistant.");
+            return true;
+        }
+        const chosen = rows[command.index - 1];
+        if (chosen === undefined) {
+            say("Choose a number from the list: send /team to see it.");
+            return true;
+        }
+        const bound = backend.bind({ chatId, kind: isGroup ? "group" : "private", conversation: chosen.conversation.id, by: actor.name, binding: sender.binding });
+        if (!bound.ok) {
+            say("Another room already follows that conversation. Stop it there first, or choose a different conversation.");
+            return true;
+        }
+        say(isGroup
+            ? `This room now follows ${phoneText(chosen.conversation.title, 80)} (lead ${phoneText(chosen.leadName, 40)}). Paired members' messages go there; everyone here reads its replies. Send /team off to stop.`
+            : `This chat now talks in ${phoneText(chosen.conversation.title, 80)} (lead ${phoneText(chosen.leadName, 40)}). Send /team off for your private assistant.`);
+        return true;
+    }
+    if (room === null) {
+        // A room the bot merely sits in stays silent; a private chat falls through to the personal assistant.
+        if (isGroup)
+            report.ignored++;
+        return isGroup;
+    }
+    if (!paired || actor === null) {
+        // Unpaired members' chatter is nobody's message. A slash attempt gets the one hint.
+        if (input.text.trimStart().startsWith("/")) {
+            say(PAIR_FIRST);
+            report.statusReplies = (report.statusReplies ?? 0) + 1;
+        }
+        else
+            report.ignored++;
+        return true;
+    }
+    const trimmed = input.text.trim();
+    if (trimmed === "") {
+        report.ignored++;
+        return true;
+    }
+    if (trimmed.length > MATE_MESSAGE_MAX_CHARS) {
+        say(tooLongText(trimmed.length));
+        report.chatRefused = (report.chatRefused ?? 0) + 1;
+        return true;
+    }
+    const row = conversationRow(store, room.conversation);
+    if (row === null) {
+        backend.unbind(chatId, "system");
+        report.ignored++;
+        return true;
+    }
+    // A current sender must not queue into a destination whose sharing grant
+    // ended: it could run successfully while every reply is withheld.
+    if (!roomGrantAllowed(store, domain, backend, room)) {
+        say(isGroup ? "This room's connection ended. Ask a conversation manager to send /team and connect it again." : "This chat's connection ended. Send /team and choose the conversation again.");
+        report.chatRefused = (report.chatRefused ?? 0) + 1;
+        return true;
+    }
+    // Membership first, in the domain's own words: a removed person is told so.
+    try {
+        domain.access(actor, row.conversation, "contributor");
+    }
+    catch (error) {
+        say(phoneText(error instanceof Error ? error.message : "You cannot talk in this conversation.", 300));
+        report.chatRefused = (report.chatRefused ?? 0) + 1;
+        return true;
+    }
+    // Consent is the person's own, per conversation, and is checked before the
+    // message is saved: an unconsented message must not sit in the shared queue.
+    const session = store.teamMateSession(actor.name, row.thread);
+    if (session === null || session.approverGeneration !== actor.generation || session.endedAt !== null) {
+        say(`${phoneText(row.title, 80)}: enable chat for yourself in Toolroll first (it shows the provider and limits), then send again.`, { label: "Enable chat", path: `/chat?conversation=${encodeURIComponent(row.conversation)}` });
+        report.chatRefused = (report.chatRefused ?? 0) + 1;
+        return true;
+    }
+    const answer = domain.execute(actor, { operation: "send", args: { conversationId: row.conversation, requestId: teamRequestId(input.channel, chatId, input.updateKey), text: trimmed } }, now);
+    if (!answer.ok) {
+        say(phoneText(answer.message, 300));
+        report.chatRefused = (report.chatRefused ?? 0) + 1;
+        return true;
+    }
+    report.chatQueued = (report.chatQueued ?? 0) + 1;
+    return true;
+}
+/** Whether the pairing a room was granted from still holds: live, the same
+ * person, still a manager of a team conversation for a group (a viewer for a
+ * private selection). */
+export function roomGrantAllowed(store, domain, backend, room) {
+    const grant = backend.grant(room.binding);
+    if (grant === null || grant.approver !== room.boundBy || (room.kind === "private" && grant.chatId !== room.chatId))
+        return false;
+    try {
+        const access = domain.access({ name: grant.approver, generation: grant.generation }, room.conversation, room.kind === "group" ? "manager" : "viewer");
+        return room.kind !== "group" || access.conversation.visibility === "team";
+    }
+    catch {
+        return false;
+    }
+}
+export function teamDomain(store, projects) { return domainFor(store, projects); }
+/** The conversation messages a room has not received yet, oldest first. */
+export function roomMessagesAfter(store, thread, cursor, limit = 20) {
+    return store.handle.prepare(`SELECT m.id, m.role, m.text, m.turn, q.author, q.request_id, q.status FROM mate_message m
+    LEFT JOIN team_message q ON q.message = m.id WHERE m.thread = ? AND m.id > ? ORDER BY m.id LIMIT ?`).all(thread, cursor, limit)
+        .map(row => ({ id: Number(row["id"]), role: row["role"] === "assistant" ? "assistant" : "operator", text: String(row["text"]), turn: row["turn"] === null ? null : Number(row["turn"]),
+        author: row["author"] === null || row["author"] === undefined ? null : String(row["author"]), requestId: row["request_id"] === null || row["request_id"] === undefined ? null : String(row["request_id"]), status: row["status"] === null || row["status"] === undefined ? null : String(row["status"]) }));
+}
+/** What a room shows for one message: the lead's reply as is, a teammate's message with its author, this room's own messages and cancelled ones not at all. */
+export function roomMessageText(message, channel, chatId) {
+    if (message.role === "assistant")
+        return message.text;
+    const own = message.requestId !== null && message.requestId.startsWith(`${channel}:${chatId}:`);
+    if (own || message.status === "cancelled" || message.author === null || message.author.length === 0)
+        return null;
+    return `${phoneText(message.author, 40)}: ${message.text}`;
+}
+/** Whose binding a room card rides: the person the lead was answering, else any paired participant. */
+export function roomCardApprover(store, conversation, turn, paired) {
+    const author = store.handle.prepare("SELECT author FROM team_message WHERE turn_id = ?").get(turn);
+    if (author !== undefined && paired.includes(String(author["author"])))
+        return String(author["author"]);
+    const members = new Set(store.handle.prepare("SELECT account FROM team_participant WHERE conversation = ? AND active = 1").all(conversation).map(one => String(one["account"])));
+    return paired.find(one => members.has(one)) ?? null;
+}

package/dist/chat-task-actions.d.ts

@@ -0,0 +1,44 @@
+import { type Store } from "./store.js";
+import type { VerifiedApprover } from "./principal.js";
+import { type StopRequest } from "./task-control.js";
+export declare const CHAT_TASK_ACTIONS: {
+    readonly stop: {
+        readonly label: "Stop task";
+        readonly detail: "Pauses this task once the run acknowledges the stop. Saved work remains; other tasks continue.";
+    };
+    readonly resume: {
+        readonly label: "Review resume";
+        readonly detail: "Opens password confirmation to lift this stop’s hold and continue from saved work. Other holds and approval requirements still apply.";
+    };
+    readonly retry: {
+        readonly label: "Try again";
+        readonly detail: "Queues another attempt. Existing approvals and holds still apply.";
+    };
+    readonly plan: {
+        readonly label: "Plan first";
+        readonly detail: "Requests a plan. Building still requires approval.";
+    };
+    readonly wait_for: {
+        readonly label: "Add dependency";
+        readonly detail: "Waits for the selected task to finish.";
+    };
+    readonly stop_waiting: {
+        readonly label: "Remove dependency";
+        readonly detail: "Stops waiting for the selected task. Other requirements still apply.";
+    };
+};
+export declare function isChatTaskAction(value: unknown): value is keyof typeof CHAT_TASK_ACTIONS;
+/** Bind cards to a specific execution and its current state, not the family's moving pointer. */
+export declare function chatTaskStamp(store: Store, who: VerifiedApprover, task: string): string | null;
+/** Only current, eligible controls can become cards; retain the exact run the reader saw. */
+export declare function chatTaskRun(store: Store, task: string, operation: "stop" | "resume", now: Date): number | null;
+export declare function applyChatTaskAction(store: Store, who: VerifiedApprover, payload: Record<string, unknown>, now: Date, web: boolean, controls?: Pick<StopRequest, "held" | "deferSignal"> & {
+    via?: StopRequest["via"];
+}): {
+    ok: true;
+    taskId: string;
+    said: string;
+} | {
+    ok: false;
+    message: string;
+};

package/dist/chat-task-actions.js

@@ -0,0 +1,79 @@
+import { verifiedAuthor } from "./store.js";
+import { requestTaskStop, taskControlOf } from "./task-control.js";
+import { authorizePlanUnderMode } from "./plan-auto.js";
+export const CHAT_TASK_ACTIONS = {
+    // Build #1604 feedback: one short consequence that still says saved work
+    // remains, other tasks continue, and the pause waits for acknowledgement.
+    stop: { label: "Stop task", detail: "Pauses this task once the run acknowledges the stop. Saved work remains; other tasks continue." },
+    resume: { label: "Review resume", detail: "Opens password confirmation to lift this stop’s hold and continue from saved work. Other holds and approval requirements still apply." },
+    retry: { label: "Try again", detail: "Queues another attempt. Existing approvals and holds still apply." },
+    plan: { label: "Plan first", detail: "Requests a plan. Building still requires approval." },
+    wait_for: { label: "Add dependency", detail: "Waits for the selected task to finish." },
+    stop_waiting: { label: "Remove dependency", detail: "Stops waiting for the selected task. Other requirements still apply." },
+};
+export function isChatTaskAction(value) {
+    return typeof value === "string" && Object.hasOwn(CHAT_TASK_ACTIONS, value);
+}
+/** Bind cards to a specific execution and its current state, not the family's moving pointer. */
+export function chatTaskStamp(store, who, task) {
+    const ref = store.lookupRef(task), row = store.getTask(task);
+    if (!ref?.repo || !who.repos.includes(ref.repo) || row === null)
+        return null;
+    const family = store.taskFamilyOf(task, who.repos, false);
+    if (!family || family.problem || family.current.id !== task)
+        return null;
+    return JSON.stringify([task, row.state, row.updatedAt, store.getScope(task)?.digest ?? null,
+        ref.plan, store.runsFor(ref.id)[0]?.id ?? null, store.blockers(task).sort()]);
+}
+/** Only current, eligible controls can become cards; retain the exact run the reader saw. */
+export function chatTaskRun(store, task, operation, now) {
+    const ref = store.lookupRef(task);
+    if (ref === null)
+        return null;
+    const control = taskControlOf(store, ref.id, now);
+    return (operation === "stop" && control.kind === "stop") || (operation === "resume" && control.kind === "paused") ? control.run : null;
+}
+export function applyChatTaskAction(store, who, payload, now, web, controls = {}) {
+    const task = payload["task"], operation = payload["operation"];
+    if (typeof task !== "string" || !isChatTaskAction(operation))
+        return { ok: false, message: "This task action is incomplete." };
+    const stamp = chatTaskStamp(store, who, task);
+    if (stamp === null || stamp !== payload["stamp"])
+        return { ok: false, message: "This task changed. Review it again before confirming." };
+    const ref = store.lookupRef(task);
+    if (store.openContestFor(ref.id) !== null)
+        return { ok: false, message: "Wait for the agent comparison to finish." };
+    if (operation === "stop" || operation === "resume") {
+        if (store.isDemo())
+            return { ok: false, message: "The demo authorizes nothing." };
+        const run = chatTaskRun(store, task, operation, now);
+        if (run === null || run !== payload["run"])
+            return { ok: false, message: "This attempt changed. Review the current task before confirming." };
+        // Resume remains the existing nonce + password ceremony. A proposal only opens it.
+        if (operation === "resume")
+            return { ok: true, taskId: task, said: `Resume review requested for ${task}. Complete the password confirmation on the task to resume.` };
+        const { via, ...rest } = controls;
+        const result = requestTaskStop(store, { taskId: task, runId: run, by: verifiedAuthor(who.name), via: via ?? (web ? "web" : "cli"), ...rest }, now);
+        return result.ok ? { ok: true, taskId: task, said: `Stop requested for ${task}, run #${run}.` }
+            : { ok: false, message: result.detail };
+    }
+    if (operation === "retry") {
+        const result = store.requeueTask(task, who.name, now);
+        return result.ok ? { ok: true, taskId: task, said: "Task queued again." } : { ok: false, message: result.reason === "claimed" ? "This task is already running." : result.reason === "not-stalled" ? "This task does not need another attempt." : "That task is no longer available." };
+    }
+    if (operation === "plan") {
+        const result = store.requestPlan(ref.id, now);
+        if (!result.ok)
+            return { ok: false, message: `Could not request a plan: ${result.reason}.` };
+        if (web)
+            authorizePlanUnderMode(store, task, who.name, now);
+        return { ok: true, taskId: task, said: "Plan requested. Building still requires approval." };
+    }
+    const other = payload["dependency"];
+    const otherRef = typeof other === "string" ? store.lookupRef(other) : null;
+    if (!otherRef?.repo || !who.repos.includes(otherRef.repo))
+        return { ok: false, message: "That dependency is not in your projects." };
+    const result = operation === "wait_for" ? store.addEdge(task, other) : store.removeEdge(task, other);
+    return result.ok ? { ok: true, taskId: task, said: operation === "wait_for" ? "Dependency added." : "Dependency removed." }
+        : { ok: false, message: "The dependency could not be changed. Review the current task." };
+}

package/dist/check-progress.d.ts

@@ -0,0 +1,51 @@
+/** Live facts extracted from the approved check's ordinary output. */
+export declare const CHECK_SUITES: readonly ["unit", "flows", "app"];
+export type CheckSuiteName = (typeof CHECK_SUITES)[number];
+export type CheckSuiteState = "pending" | "running" | "passed" | "failed" | "unknown";
+export type CheckSuiteProgress = {
+    state: CheckSuiteState;
+    passed: number;
+    failed: number;
+    skipped: number;
+    total: number | null;
+    /** Only when the journeys run in parallel groups: how many groups have passed or failed, of how many. */
+    groups?: CheckGroupsProgress;
+};
+export type CheckGroupsProgress = {
+    passed: number;
+    failed: number;
+    total: number;
+};
+export type CheckProgressSnapshot = {
+    version: 1;
+    final: boolean;
+    line: string;
+    suites: Record<CheckSuiteName, CheckSuiteProgress>;
+};
+export declare function checkProgressLine(suites: Record<CheckSuiteName, CheckSuiteProgress>): string;
+/** A machine-only count line that is safe to send through a push provider. */
+export declare function isCheckProgressLine(value: string): boolean;
+export declare function parseCheckProgressSnapshot(raw: string): CheckProgressSnapshot | null;
+/**
+ * Incrementally reads stdout and stderr. Each stream keeps its own partial
+ * line so simultaneous journey output cannot splice two records together.
+ */
+export declare class CheckProgressTracker {
+    private readonly update;
+    private readonly suites;
+    private readonly buffers;
+    private readonly events;
+    private last;
+    private recognized;
+    private parallel;
+    constructor(update: (snapshot: CheckProgressSnapshot) => void);
+    feed(chunk: string, stream?: "stdout" | "stderr"): void;
+    finish(): CheckProgressSnapshot | null;
+    snapshot(final?: boolean): CheckProgressSnapshot;
+    private emit;
+    private read;
+    /** One group's journey line: count its events, and take its own totals line as that group's result. */
+    private readGroup;
+    /** The suite is the sum of its groups; its total is known once every group has reported one. */
+    private summarize;
+}