toolroll 0.9.84 → 0.9.85

package/dist/browser-workspace.d.ts

@@ -624,6 +624,10 @@ export type BrowserProjectRow = {
 };
 export type BrowserProjectsView = {
     kind: 'projects';
+    activity?: {
+        project: string;
+        report: import('./project-outcomes.js').ProjectOutcomes | null;
+    };
     /** Arrived from New task: choosing where the task belongs. */
     choosing: boolean;
     problem: string | null;
@@ -711,6 +715,7 @@ export type BrowserCheckItem = {
         src: string;
         href: string;
         caption: string;
+        image?: import("./result-review.js").FeedbackImage;
     }[];
 };
 /** The result's one decision: what Accept is called, why it isn't plain

package/dist/chat-channel.d.ts

@@ -1,3 +1,4 @@
+import { type FeedbackImage } from "./result-review.js";
 import type { DoorOutcome } from "./lead-doors.js";
 import { type VerifiedApprover } from "./principal.js";
 import type { ChatConfig, LeadProposal, LeadSession, LeadThread, Store, SubscriptionChatProviderId } from "./store.js";
@@ -40,7 +41,7 @@ export declare function tooLongText(length: number): string;
 /** A reply to a message about several tasks is never guessed: it names them and says how to choose. */
 export declare function whichTaskText(titles: readonly string[]): string;
 /** The server-authored context a reply to a result message carries into the turn — the exact execution and run, never a guess. */
-export declare function replyContextFor(taskId: string, run: number | null): string;
+export declare function replyContextFor(taskId: string, run: number | null, image?: FeedbackImage): string;
 /** The context a chosen task (/tasks, /task <name>) carries into each turn from that chat. */
 export declare function focusContextFor(taskId: string): string;
 /** No trusted https origin is configured: one honest line, no localhost, no promise. */
@@ -69,6 +70,14 @@ export declare function armedCardText(proposal: LeadProposal, previewText: strin
 /** The "yes" button's label for an armed card. */
 export declare function armedYesLabel(proposal: LeadProposal): string;
 export declare function proposalLink(store: Store, proposal: LeadProposal, repos: readonly string[], channel?: ChatChannelName | null): PhoneLink | null;
+/** The personal Telegram card: the shared preview, or a handoff to the lead conversation when it cannot be shown in full. */
+export declare function phoneProposalPreview(store: Store, proposal: LeadProposal, repos: readonly string[]): {
+    text: string;
+    buttons: boolean;
+    closed?: true;
+};
+/** The personal Telegram card's link: the lead conversation holding a card too long to show, else the shared link. */
+export declare function phoneProposalLink(store: Store, proposal: LeadProposal, repos: readonly string[], channel?: ChatChannelName | null): PhoneLink | null;
 /**
  * The link a CONFIRMED card carries: the exact recorded task the outcome
  * names, where its remaining step lives — the approval control while the

package/dist/chat-channel.js

@@ -1,6 +1,7 @@
+import { parseFeedbackImage } from "./result-review.js";
 /** Shared membership-chat identity, proposal previews and result links. Transport adapters never grant authority. */
 import { FLOW_HREF } from "./flow-engine.js";
-import { closedQuestionWords } from "./decision.js";
+import { closedQuestionWords, LIMITS } from "./decision.js";
 import { createHash } from "node:crypto";
 import { sharedActionPayload, sharedActionNeedsReview, sharedActionReviewPath, sharedActionAllowsChallenge, CHAT_ACTIONS, } from "./chat-actions.js";
 import { isDirectChatProvider, subscriptionCredentialKey } from "./converse.js";
@@ -132,12 +133,13 @@ export function whichTaskText(titles) {
     ].join("\n");
 }
 /** The server-authored context a reply to a result message carries into the turn — the exact execution and run, never a guess. */
-export function replyContextFor(taskId, run) {
+export function replyContextFor(taskId, run, image) {
     return [
         `Current task: ${taskId}. Read it with get_task before answering or proposing changes. Read its currentExecution next and bind new actions to that exact execution. Never replace the target of a prior proposal with a newer revision. Keep this turn about that task unless the operator explicitly asks to broaden it.`,
         run === null
             ? `The operator is replying to a message about execution ${taskId}.`
             : `The operator is replying to result #${run} from execution ${taskId}. Use get_result for that exact execution and run when responding to feedback; do not substitute another result. If the operator asks for changes, use propose_review revise; use note only when they explicitly ask to save feedback without starting work.`,
+        ...(image === undefined ? [] : [`The reply targets screenshot ${image.artifact} on result #${image.run}. Retain image: ${image.artifact} in propose_review so the exact screenshot stays with new feedback; pass image: null only when the feedback is not about it. Read get_result_images for this result first.`]),
     ].join(" ");
 }
 /** The context a chosen task (/tasks, /task <name>) carries into each turn from that chat. */
@@ -146,6 +148,10 @@ export function focusContextFor(taskId) {
 }
 /** A step the phone cannot take itself: said once; the button (or its absence) says where. */
 const HANDOFF = "This step finishes in Toolroll.";
+/** One Telegram message; a card that cannot fit is never confirmed from a shortened copy. */
+const TELEGRAM_TEXT_MAX = 4_096;
+const PHONE_TOO_LONG = "This is too long to show in full here. It is waiting in your Toolroll chat to review and confirm.";
+const LEAD_CHAT_LINK = { label: "Open chat", path: "/chat" };
 /** No trusted https origin is configured: one honest line, no localhost, no promise. */
 export const NO_PHONE_LINK = "Phone access isn't configured. Open Toolroll on your computer.";
 /** An origin exists but the card's task is not one this phone may reach now: said as that, never as missing setup. */
@@ -229,6 +235,23 @@ export function proposalLink(store, proposal, repos, channel = null) {
     }
     return null;
 }
+/** A personal Telegram card fits one message, or it waits, whole, in the person's lead conversation in Toolroll. */
+function fitsPhone(preview) {
+    return !preview.buttons || preview.text.length <= TELEGRAM_TEXT_MAX;
+}
+/** The personal Telegram card: the shared preview, or a handoff to the lead conversation when it cannot be shown in full. */
+export function phoneProposalPreview(store, proposal, repos) {
+    const preview = proposalPreview(store, proposal, repos, "telegram");
+    return fitsPhone(preview)
+        ? preview
+        : { text: [preview.text.split("\n")[0], PHONE_TOO_LONG, "", HANDOFF].join("\n"), buttons: false };
+}
+/** The personal Telegram card's link: the lead conversation holding a card too long to show, else the shared link. */
+export function phoneProposalLink(store, proposal, repos, channel = null) {
+    return fitsPhone(proposalPreview(store, proposal, repos, "telegram"))
+        ? proposalLink(store, proposal, repos, channel)
+        : LEAD_CHAT_LINK;
+}
 /**
  * The link a CONFIRMED card carries: the exact recorded task the outcome
  * names, where its remaining step lives — the approval control while the
@@ -410,20 +433,22 @@ export function proposalPreview(store, proposal, repos, channel = null) {
                 ? payload["notes"]
                 : [];
             const saved = (snapshot?.notes ?? []).filter((one) => selected.includes(one.id));
-            const note = t("note", 1_000);
+            const note = t("note", LIMITS.note);
+            const image = parseFeedbackImage(payload["image"]);
             const path = t("path", 300);
             return card(`${revise ? "Request changes to" : "Save feedback on"} result #${String(payload["run"] ?? "?")} of ${taskName}`, [
                 ...(note === ""
                     ? []
                     : [
                         `Your feedback${path === "" ? "" : ` (${path}${typeof payload["line"] === "number" ? `:${payload["line"]}` : ""})`}:`,
-                        ...lines(note, 1_000),
+                        ...(image ? [`Screenshot ${image.artifact} · result #${image.run}`] : []),
+                        ...lines(note, LIMITS.note),
                     ]),
                 ...(saved.length === 0
                     ? []
                     : [
                         "Saved notes included:",
-                        ...saved.map((one) => `• ${one.path === null ? "" : `${phoneText(one.path, 120)}${one.line === null ? "" : `:${one.line}`}: `}${phoneText(one.note, 300)}`),
+                        ...saved.map((one) => `• ${one.image ? `Screenshot ${one.image.artifact} · result #${one.image.run}: ` : ""}${one.path === null ? "" : `${phoneText(one.path, 120)}${one.line === null ? "" : `:${one.line}`}: `}${phoneText(one.note, LIMITS.note)}`),
                     ]),
             ], revise
                 ? "Creates a revision of the same task. Its approval follows your settings."
@@ -484,6 +509,11 @@ export const CHAT_ACTION_PARITY = {
         how: "Reads current tasks, decisions, results and project knowledge from the local database through the shared engine, within the enrolled projects.",
         gap: "Dedicated Telegram and Slack journeys for this tool and live channel rendering remain unverified.",
     },
+    get_project_activity: {
+        support: "direct",
+        how: "Reads the project's Ready backlog, finished-to-decision elapsed time, explicit revisions and recorded cost for completed families in an accessible enrolled project through the shared engine.",
+        gap: "Dedicated Telegram and Slack journeys for this tool and live channel rendering remain unverified.",
+    },
     get_project_context: {
         support: "direct",
         how: "Reads bounded source excerpts or advisory import impact in an accessible enrolled project through the shared engine, with source-search fallback when its index is unavailable.",

package/dist/chat-decide.d.ts

@@ -4,6 +4,8 @@ import { type VerifiedApprover } from "./principal.js";
 import type { Scope } from "./scope.js";
 import { type ReleaseCard } from "./release-card.js";
 import type { Store } from "./store.js";
+import { permissionPlainWords } from "./chat-terms.js";
+export { permissionPlainWords };
 /** The tokens live in chat_decide_action and the open "What should change?" in chat_decide_prompt (store.ts). */
 export type DecideAct = (typeof DECIDE_ACTS)[number];
 export type DecideTarget = {
@@ -20,6 +22,11 @@ export type DecideTarget = {
     kind: "merge";
     taskId: string;
     run: number;
+}
+/** The tasks one youiyoux pass filed (youiyoux-intake.ts), named by any one of them. */
+ | {
+    kind: "requests";
+    taskId: string;
 };
 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. */
@@ -56,11 +63,13 @@ export declare const DECIDE_LABELS: {
     readonly cancel: "Cancel";
 };
 export declare const WHAT_SHOULD_CHANGE = "What should change?";
+/** `taskId`: the task the button acts on, when it isn't the card's own (a youiyoux card's one-task Approve). */
 type ActSpec = {
     act: DecideAct;
     run: number | null;
     digest: string;
     label?: string;
+    taskId?: string;
 };
 /** What a card offers: an optional replacement text (the plan card) and rows of acts and links; a release card also
  * sends its full terms as a file with it (`file`), where the chat app can. */
@@ -85,11 +94,11 @@ export declare function chatApproveMode(store: Store, repo: string | null, appro
     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, channel: DecideChannel, root?: string): {
+export declare function planInChat(store: Store, taskId: string, approver: string, now: Date, channel: DecideChannel, root?: string, 
+/** A youiyoux card asking (requestsOffer): its own words are checked there, every one shown. */
+from?: "requests"): {
     ok: true;
     modeDigest: string;
     source: "setting" | "mode";
@@ -109,6 +118,10 @@ export declare function mergeInChat(store: Store, taskId: string, run: number, a
     ok: false;
     why: string;
 };
+/** Whether a card's words arrive as one message that shows each of them as written: within Telegram's part, Slack's and
+ * (after its escapes) Discord's limits, with room for the question a tap adds. Teams draws card text as Markdown, where
+ * a link's label hides its address, and Slack turns `:name:` into an emoji: there such words never approve. */
+export declare function shownWhole(text: string, channel: DecideChannel): boolean;
 /** The plan card: title, goal in two lines, what changes, done when, and what the yes allows. On Telegram the yes's
  * terms come second, under the title, and the steps are fewer: the full plan is behind Edit. */
 export declare function planCardText(store: Store, taskId: string, scope: Scope, root?: string, channel?: DecideChannel): string;
@@ -260,4 +273,3 @@ export declare function decideTargetOf(row: {
     taskId: string | null;
     run: number | null;
 }): DecideTarget | null;
-export {};

package/dist/chat-decide.js

@@ -7,7 +7,8 @@
  * Approving a plan or merging needs the password, which never goes in chat, so they act in chat only where the owner
  * turned approving from chat on (their lasting setting, chat-approval.ts, or a signed mode's chatApprove term), for
  * their own chat; otherwise, and for a plan that widens permissions, exceeds the limit or touches protected paths, the
- * card keeps its link.
+ * card keeps its link. The change requests one youiyoux pass filed come as one card that shows every word of each
+ * task's terms, with Approve all and each one's own Approve (the requests card, below).
  *
  * The same in every chat app: Telegram's bridge and the shared engine Slack, Discord and Teams run on (chat-delivery.ts)
  * offer, mint and answer these through the same tokens (the `channel` column). Every act runs through the door the
@@ -20,7 +21,7 @@ import { acceptAndCompleteAsOperator, assignmentOf, owedAcceptance } from "./ass
 import { chatControlHref, chatResultHref } from "./chat-controls.js";
 import { applyChatTaskAction, chatTaskStamp } from "./chat-task-actions.js";
 import { chatTitle } from "./chat-voice.js";
-import { readVerifiedArtifact } from "./evidence.js";
+import { readVerifiedArtifact, scanForSecrets } from "./evidence.js";
 import { effectiveChatApproval } from "./chat-approval.js";
 import { chatApproveChatsOf, chatNames, modeTermsFromJson } from "./modes.js";
 import { parseExecutionPlanDocument } from "./plan.js";
@@ -31,7 +32,13 @@ import { revisionSourceOf } from "./result-review.js";
 import { APPROVAL_PROOF, approvalOf, approvalProofDetail, deployGateScope, quarantinedAuthor } from "./scope.js";
 import { releaseCardOf } from "./release-card.js";
 import { releaseCiHoldOf, releaseCiHoldWords } from "./release-ci-hold.js";
-import { phoneText } from "./telegram-status.js";
+import { phoneText, projectLabel } from "./telegram-status.js";
+import { permissionPlainWords, scopeTermsText, shownTermsDigest } from "./chat-terms.js";
+import { YOUIYOUX_CARD_KIND, YOUIYOUX_FILED_VIA, YOUIYOUX_HOME_PATH } from "./contracts/youiyoux-request.js";
+import { FILED_PER_PASS, requestKindWord, requestPassOf } from "./youiyoux-intake.js";
+import { discordPlain } from "./reply-shape.js";
+import { PLATFORM_LIMITS } from "./text-limits.js";
+export { permissionPlainWords };
 /** The words, said once. */
 export const DECIDE_LABELS = {
     accept: "Accept and finish",
@@ -75,22 +82,6 @@ export function chatApproveMode(store, repo, approver, now, channel) {
         return { ok: false, why: `Your mode approves from ${chatNames(chats)} only. Sign it again to approve from ${chatNames([channel])}.` };
     return { ok: true, digest: mode.digest, limits: { fullAccess: terms.permissionDefault === "escalated", capMicrousd: terms.perAttemptBudgetMicrousd }, source: "mode" };
 }
-/** What a plan's yes allows an agent to do, in a few plain words (the approval sheet's "You're allowing"). */
-export function permissionPlainWords(profile) {
-    if (profile === null || profile === undefined)
-        return null;
-    const full = "full access, nothing asks first";
-    if (profile.provider === "claude") {
-        return profile.permissionArgv === "bypassPermissions" ? full
-            : profile.permissionArgv === "auto" ? "file edits and routine commands; anything risky stops"
-                : "file edits only; commands are refused";
-    }
-    if (profile.provider === "gemini")
-        return profile.approvalArgv === "yolo" ? full : "file edits only; other tools are refused";
-    if (isAcpProfile(profile))
-        return "full access inside the OS fence, nothing asks first";
-    return profile.sandboxMode === "danger-full-access" ? full : "file edits and commands inside the project only";
-}
 function fullAccess(profile) {
     if (profile === null || profile === undefined)
         return false;
@@ -100,7 +91,12 @@ function fullAccess(profile) {
 const money = (micro) => `$${(micro / 1_000_000).toFixed(2)}`;
 /** 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 function planInChat(store, taskId, approver, now, channel, root) {
+export function planInChat(store, taskId, approver, now, channel, root, 
+/** A youiyoux card asking (requestsOffer): its own words are checked there, every one shown. */
+from) {
+    // A change request's terms are outside text: they approve in chat only on its own card, which shows every word.
+    if (from !== "requests" && store.filedViaOf(taskId) === YOUIYOUX_FILED_VIA)
+        return { ok: false, why: OUTSIDE_TERMS };
     const ref = store.lookupRef(taskId);
     const scope = store.getScope(taskId);
     if (ref === null || ref.repo === null || scope === null)
@@ -184,6 +180,194 @@ export function mergeInChat(store, taskId, run, approver, now, channel) {
         return mode;
     return { ok: true, modeDigest: mode.digest, source: mode.source, head: publication.headSha };
 }
+// ---- a youiyoux pass's card -----------------------------------------------------------------
+/**
+ * What one youiyoux pass filed (youiyoux-intake.ts), as one card: every task still waiting on this person, Approve all,
+ * and each one's own Approve and Open. Its terms are outside text (anyone who can write the project's folder wrote
+ * them), so a task is approved here only when this card shows every word of its terms (chat-terms.ts), the whole card
+ * arrives as one message every chat app shows as written, and every plan rule holds (planInChat). Its button carries
+ * each task with the digest of the words shown; the seal recomputes that digest from the live scope (store.ts). A task
+ * that can't be shown whole, or may not be approved here, is named with its link to Toolroll instead.
+ */
+const REQUESTS_DIGEST = "youiyoux:";
+const OPEN_IN_TOOLROLL = "Open in Toolroll";
+const OUTSIDE_TERMS = "A youiyoux request is approved from its own youiyoux card, which shows every word, or in Toolroll.";
+const TOO_LONG = "its full terms don't fit in one chat message";
+/** Room left under each app's limit for the question a tap adds ("Approve 10 tasks?") and the names it leaves out. */
+const ROOM = 400;
+const listedDigest = (list) => `${REQUESTS_DIGEST}${list.map(one => `${one.taskId}=${one.digest}`).join(",")}`;
+const LISTABLE_ID = /^[A-Za-z0-9._-]{1,64}$/;
+function listedOf(digest) {
+    if (!digest.startsWith(REQUESTS_DIGEST))
+        return null;
+    const list = [];
+    for (const one of digest.slice(REQUESTS_DIGEST.length).split(",")) {
+        const match = /^([A-Za-z0-9._-]{1,64})=([0-9a-f]{64})$/.exec(one);
+        if (match === null)
+            return null;
+        list.push({ taskId: match[1], digest: match[2] });
+    }
+    return list.length === 0 || list.length > FILED_PER_PASS ? null : list;
+}
+/** Whether a card's words arrive as one message that shows each of them as written: within Telegram's part, Slack's and
+ * (after its escapes) Discord's limits, with room for the question a tap adds. Teams draws card text as Markdown, where
+ * a link's label hides its address, and Slack turns `:name:` into an emoji: there such words never approve. */
+export function shownWhole(text, channel) {
+    switch (channel) {
+        case "telegram": return text.length + ROOM <= 3_900;
+        case "slack": return text.length + ROOM <= PLATFORM_LIMITS.slack && !/:[a-z0-9_+'-]+:/i.test(text);
+        case "discord": return discordPlain(text).length + ROOM <= PLATFORM_LIMITS.discord;
+        case "teams": return false;
+    }
+}
+/** Words a chat message never carries (chat-display.ts hides them elsewhere): a key, or an absolute folder on this
+ * computer (a home folder, a drive). A project's own relative paths and a page's route are fine. */
+function privateWords(text) {
+    return scanForSecrets(text).length > 0 || /\b\d{5,}:[A-Za-z0-9_-]{20,}\b/.test(text) || /(?:^|[\s"'`(<[=:,])(?:\/Users\/|\/home\/|\/root\/|~\/)|(?:[A-Za-z]:[\\/]|\\\\)/.test(text);
+}
+/** Still waiting on a person's yes: not finished, and no approval on its current terms. */
+function waitsForApproval(store, taskId) {
+    const state = store.getTask(taskId)?.state;
+    const scope = store.getScope(taskId);
+    return state !== undefined && state !== "done" && state !== "cancelled" && scope !== null && !(scope.approvedDigest != null && scope.approvedDigest === scope.digest);
+}
+/** The card for the pass `taskId` was filed in, as it stands for this person now; null when nothing waits on them. */
+function requestsOffer(store, taskId, who, now, channel, root, said) {
+    const waiting = requestPassOf(store, taskId).filter(id => {
+        const ref = store.lookupRef(id);
+        return ref !== null && ref.repo !== null && who.repos.includes(ref.repo) && store.filedViaOf(id) === YOUIYOUX_FILED_VIA && waitsForApproval(store, id);
+    });
+    if (waiting.length === 0)
+        return null;
+    const repo = store.lookupRef(waiting[0]).repo;
+    const what = requestKindWord(store, waiting);
+    const head = `${waiting.length === 1 ? `A youiyoux ${what} waits` : `${waiting.length} youiyoux ${what}s wait`} for you · ${projectLabel(repo)}`;
+    const mode = chatApproveMode(store, repo, who.name, now, channel);
+    const items = waiting.map((id, index) => ({ n: index + 1, taskId: id, name: title(store, id), listed: null, why: null }));
+    const block = (item) => `${item.n}. ${item.name}\n${scopeTermsText(store.getScope(item.taskId))}`;
+    const compose = () => {
+        const shown = items.filter(one => one.listed !== null);
+        const open = items.filter(one => one.listed === null);
+        return [...(said === undefined ? [] : [said]), head,
+            ...shown.map(block),
+            ...(open.length === 0 ? [] : [[...(shown.length === 0 ? [] : ["Open in Toolroll to approve:"]), ...open.map(one => `${one.n}. ${one.name}${one.why === null ? "" : `: ${one.why}`}`)].join("\n")])].join("\n\n");
+    };
+    if (!mode.ok) {
+        // Nothing approves here: each task's title, files and goal in short, and its link.
+        const summary = items.map(one => {
+            const scope = store.getScope(one.taskId);
+            // The request's own goal, without the line the intake puts first (which request, on which route).
+            const goal = scope.goal.startsWith("From youiyoux request ") && scope.goal.includes("\n\n") ? scope.goal.slice(scope.goal.indexOf("\n\n") + 2) : scope.goal;
+            return [`${one.n}. ${one.name}`, `Files: ${scope.touches.length === 0 ? "any file (no file list)" : phoneText(scope.touches.join(", "), 160)}`, phoneText(goal, 200)].join("\n");
+        });
+        return { text: [head, `${mode.why} Open each to approve it in Toolroll.`, ...summary].join("\n\n"),
+            rows: items.map(one => [{ label: waiting.length === 1 ? OPEN_IN_TOOLROLL : `Open ${one.n}`, path: chatControlHref("approval", one.taskId) }]) };
+    }
+    for (const item of items) {
+        const plan = planInChat(store, item.taskId, who.name, now, channel, root, "requests");
+        if (!plan.ok) {
+            item.why = plan.why;
+            continue;
+        }
+        if (passwordOnlySeal(plan.scope) || deployGateScope(plan.scope) || !LISTABLE_ID.test(item.taskId)) {
+            item.why = "it needs your password in Toolroll";
+            continue;
+        }
+        // Shown whole means shown raw: words chat text otherwise hides (a key, a folder on this computer) stay in Toolroll.
+        if (privateWords(scopeTermsText(plan.scope))) {
+            item.why = "its terms name a key or a folder on this computer";
+            continue;
+        }
+        // In order, each whole or not at all: one that doesn't fit beside the ones before it is named instead.
+        item.listed = { taskId: item.taskId, digest: shownTermsDigest(plan.scope) };
+        if (!shownWhole(compose(), channel)) {
+            item.listed = null;
+            item.why = TOO_LONG;
+        }
+    }
+    const shown = items.filter(one => one.listed !== null);
+    const rows = [];
+    if (shown.length > 0)
+        rows.push([{ act: "approve", run: null, digest: listedDigest(shown.map(one => one.listed)), taskId: shown[0].taskId,
+                label: shown.length > 1 ? `Approve all (${shown.length})` : items.length === 1 ? DECIDE_LABELS.approve : `Approve ${shown[0].n}` }]);
+    for (const item of items) {
+        rows.push([...(item.listed !== null && shown.length > 1 ? [{ act: "approve", run: null, digest: listedDigest([item.listed]), taskId: item.taskId, label: `Approve ${item.n}` }] : []),
+            { label: waiting.length === 1 ? OPEN_IN_TOOLROLL : `Open ${item.n}`, path: chatControlHref("approval", item.taskId) }]);
+    }
+    return { text: compose(), rows };
+}
+/** The tasks a youiyoux card's button names, as they stand now: each still waiting, within every rule, on exactly the
+ * words the card showed (ready), or named with why not (skipped). */
+function requestsNow(store, tokenTask, digest, who, now, channel, root) {
+    const listed = listedOf(digest);
+    const repo = store.lookupRef(tokenTask)?.repo ?? null;
+    if (listed === null || repo === null)
+        return { ok: false, why: "That button can't be read." };
+    const mode = chatApproveMode(store, repo, who.name, now, channel);
+    if (!mode.ok)
+        return mode;
+    const ready = [];
+    const skipped = [];
+    for (const one of listed) {
+        const ref = store.lookupRef(one.taskId);
+        const name = title(store, one.taskId);
+        if (ref === null || ref.repo !== repo || !who.repos.includes(repo) || store.filedViaOf(one.taskId) !== YOUIYOUX_FILED_VIA) {
+            skipped.push({ name, why: "it isn't available here now" });
+            continue;
+        }
+        const plan = planInChat(store, one.taskId, who.name, now, channel, root, "requests");
+        if (!plan.ok) {
+            skipped.push({ name, why: plan.why });
+            continue;
+        }
+        if (passwordOnlySeal(plan.scope) || deployGateScope(plan.scope)) {
+            skipped.push({ name, why: "it needs your password in Toolroll" });
+            continue;
+        }
+        if (shownTermsDigest(plan.scope) !== one.digest) {
+            skipped.push({ name, why: "its terms changed since this card was sent" });
+            continue;
+        }
+        ready.push({ taskId: one.taskId, name, digest: one.digest, plan });
+    }
+    return { ok: true, ready, skipped };
+}
+/** The owner's own yes from chat, sealed as theirs ("chat"), never as a mode's: it stands like the console's after the
+ * mode or setting ends. `terms`: the digest of every word a youiyoux card showed, which the seal checks. */
+function sealPlanInChat(store, who, seat, repo, taskId, plan, now, terms) {
+    if (!store.sealScopeApproval(taskId, who.name, now, {}, { kind: "chat", modeDigest: plan.modeDigest, ...(terms === undefined ? {} : { card: "terms", cardDigest: terms }) }))
+        return false;
+    // The person's proof beside the seal, bound to these exact words (approval policy §1.2): a paired-chat tap, never a
+    // password. Release, deploy and the protected counters read it as a person's.
+    const sealedDigest = store.getScope(taskId)?.approvedDigest ?? "";
+    store.recordAction({ at: now.toISOString(), actor: who.name, repo, taskId, runId: null, action: APPROVAL_PROOF, outcome: "chat",
+        source: "request", detail: approvalProofDetail(now.getTime(), store.accountOf(who.name)?.generation ?? 0, sealedDigest) });
+    store.recordAction({ at: now.toISOString(), actor: who.name, repo, taskId, runId: null, action: "plan approved in chat", outcome: "approved",
+        source: "request", detail: `via ${seat.channel} · chat binding #${seat.binding} · ${plan.source} ${plan.modeDigest}${terms === undefined ? "" : ` · youiyoux card, terms ${terms}`}` });
+    return true;
+}
+/** A youiyoux card's yes: each task it names that still stands as shown is sealed, each with its own proof; the rest are
+ * named, never approved. The card then offers what still waits, so one can be approved after another. */
+function approveRequests(store, seat, who, tokenTask, digest, target, body, message, root, now) {
+    const read = requestsNow(store, tokenTask, digest, who, now, seat.channel, root);
+    if (!read.ok)
+        return { ack: "Not done.", edit: { text: `${body}\n\n✗ Not done: ${read.why}`, rows: linksFor(target), tokens: [] } };
+    const approved = [];
+    const skipped = [...read.skipped];
+    for (const one of read.ready) {
+        if (sealPlanInChat(store, who, seat, store.lookupRef(one.taskId).repo, one.taskId, one.plan, now, one.digest))
+            approved.push(one.name);
+        else
+            skipped.push({ name: one.name, why: "it couldn't be approved from chat. Open it in Toolroll." });
+    }
+    const said = [...(approved.length === 0 ? [] : [`✓ Approved ${approved.map(name => `"${name}"`).join(", ")}. Work starts when a worker is free.`]),
+        ...skipped.map(one => `✗ Not approved: "${one.name}": ${one.why}`)].join("\n");
+    const ack = approved.length === 0 ? "Not done." : "Approved.";
+    const again = requestsOffer(store, tokenTask, who, now, seat.channel, root, said);
+    if (again === null)
+        return { ack, edit: { text: `${body}\n\n${said}`, rows: skipped.length === 0 ? [] : linksFor(target), tokens: [] } };
+    return { ack, edit: { text: again.text ?? said, ...mintDecideButtons(store, seat, target, again, now, message) } };
+}
 /** The plan card: title, goal in two lines, what changes, done when, and what the yes allows. On Telegram the yes's
  * terms come second, under the title, and the steps are fewer: the full plan is behind Edit. */
 export function planCardText(store, taskId, scope, root, channel) {
@@ -292,6 +476,7 @@ export function decideOffer(store, target, who, now, channel, root) {
             return { text: planCardText(store, target.taskId, plan.scope, root, channel),
                 rows: [[{ act: "approve", run: null, digest: plan.digest }], [{ label: DECIDE_LABELS.edit, path: chatControlHref("approval", target.taskId) }, { act: "not-now", run: null, digest: plan.digest }]] };
         }
+        case "requests": return requestsOffer(store, target.taskId, who, now, channel, root);
         case "merge": {
             const merge = mergeInChat(store, target.taskId, target.run, who.name, now, channel);
             if (!merge.ok)
@@ -345,7 +530,7 @@ export function mintDecideButtons(store, seat, target, offer, now, message = nul
     const rows = offer.rows.map(row => row.map((one) => {
         if (!isAct(one))
             return { label: one.label, link: one };
-        const token = mint(store, seat, message, one, target.taskId, "offer", now);
+        const token = mint(store, seat, message, one, one.taskId ?? target.taskId, "offer", now);
         tokens.push(token);
         return { label: one.label ?? DECIDE_LABELS[one.act], token };
     }));
@@ -444,6 +629,8 @@ const QUESTIONS = {
     merge: name => `Merge "${name}"?`,
 };
 function targetOf(row) {
+    if (row.digest.startsWith(REQUESTS_DIGEST))
+        return { kind: "requests", taskId: row.taskId };
     switch (row.act) {
         case "accept":
         case "changes": return { kind: "result", taskId: row.taskId, run: row.run ?? 0 };
@@ -496,6 +683,14 @@ function staleWhy(store, row, who, now, channel, root) {
                     return release.why;
                 return releaseDigest(release.card) === row.digest ? null : "This release changed while you were reading.";
             }
+            if (row.digest.startsWith(REQUESTS_DIGEST)) {
+                const read = requestsNow(store, row.taskId, row.digest, who, now, channel, root);
+                if (!read.ok)
+                    return read.why;
+                if (read.ready.length > 0)
+                    return null;
+                return read.skipped.length === 1 ? `"${read.skipped[0].name}": ${read.skipped[0].why}` : "None of these wait for your approval as this card showed them.";
+            }
             const plan = planInChat(store, row.taskId, who.name, now, channel, root);
             if (!plan.ok)
                 return plan.why;
@@ -521,6 +716,7 @@ export function linksFor(target) {
         case "merge": return [[{ label: "Open task", link: { label: "Open task", path: chatControlHref("task", target.taskId) } }]];
         case "plan": return [[{ label: "Review & start", link: { label: "Review & start", path: chatControlHref("approval", target.taskId) } }]];
         case "failed": return [[{ label: "Open task", link: { label: "Open task", path: chatControlHref("task", target.taskId) } }]];
+        case "requests": return [[{ label: OPEN_IN_TOOLROLL, link: { label: OPEN_IN_TOOLROLL, path: YOUIYOUX_HOME_PATH } }]];
     }
 }
 /** Where a plan card's task is now, for a card whose buttons no longer act: the family's current version, named only
@@ -548,7 +744,7 @@ const QUESTION_STARTS = ["Accept and finish \"", "Retry \"", "Approve and start
 /** The card's words without a question this module appended. */
 function cardBody(shown) {
     const at = shown.lastIndexOf("\n\n");
-    return at >= 0 && QUESTION_STARTS.some(start => shown.startsWith(start, at + 2)) ? shown.slice(0, at) : shown;
+    return at >= 0 && (QUESTION_STARTS.some(start => shown.startsWith(start, at + 2)) || /^Approve \d+ tasks\?/.test(shown.slice(at + 2))) ? shown.slice(0, at) : shown;
 }
 /**
  * One tap on a decide button, inside the caller's transaction. Null: not this module's token. The seat must be the
@@ -637,6 +833,20 @@ export function applyDecideTap(store, seat, input) {
             spend();
             return releaseContinue(store, seat, input.message, row.taskId, name, release.card, now, "Read the terms, then approve.", null);
         }
+        // A youiyoux card's Approve: how many still stand as the card showed them, and which don't (named, never approved).
+        if (row.act === "approve" && row.digest.startsWith(REQUESTS_DIGEST)) {
+            const read = requestsNow(store, row.taskId, row.digest, who, now, seat.channel, input.root);
+            if (!read.ok)
+                return stale(read.why);
+            spend();
+            const spec = { act: row.act, run: row.run, digest: row.digest };
+            const yes = mint(store, seat, input.message, spec, row.taskId, "yes", now);
+            const cancel = mint(store, seat, input.message, spec, row.taskId, "cancel", now);
+            const asked = [read.ready.length === 1 ? QUESTIONS.approve(read.ready[0].name) : `Approve ${read.ready.length} tasks?`,
+                ...read.skipped.map(one => `"${one.name}" isn't included: ${one.why}`)].join("\n");
+            return { ack: "Confirm below.", edit: { text: `${body}\n\n${asked}`,
+                    rows: [[{ label: DECIDE_LABELS.yes, token: yes }, { label: DECIDE_LABELS.cancel, token: cancel }]], tokens: [yes, cancel] } };
+        }
         // The first tap asks; only the yes acts, bound to exactly what this button was.
         spend();
         const spec = { act: row.act, run: row.run, digest: row.digest };
@@ -687,6 +897,8 @@ export function applyDecideTap(store, seat, input) {
                     link: chatControlHref("task", row.taskId), source: { taskRef: ref.id } }, now);
                 return done("✓ Release approved. It deploys when its check passes and someone runs the release.");
             }
+            if (row.digest.startsWith(REQUESTS_DIGEST))
+                return approveRequests(store, seat, who, row.taskId, row.digest, target, body, input.message, input.root, now);
             const plan = planInChat(store, row.taskId, who.name, now, seat.channel, input.root);
             if (!plan.ok)
                 return notDone(plan.why);
@@ -694,16 +906,8 @@ export function applyDecideTap(store, seat, input) {
                 return notDone("This is a release: approve it from its release card.");
             if (passwordOnlySeal(plan.scope))
                 return notDone(needsPassword(plan.scope));
-            // The owner's own yes, sealed as theirs ("chat"), never as a mode's: it stands like the console's after the mode or setting ends.
-            if (!store.sealScopeApproval(row.taskId, who.name, now, {}, { kind: "chat", modeDigest: plan.modeDigest }))
+            if (!sealPlanInChat(store, who, seat, ref.repo, row.taskId, plan, now))
                 return notDone("the plan couldn't be approved from chat. Open it in Toolroll.");
-            // The person's proof beside the seal, bound to these exact words (approval policy §1.2): a paired-chat tap, never a
-            // password. Release, deploy and the protected counters read it as a person's.
-            const sealedDigest = store.getScope(row.taskId)?.approvedDigest ?? "";
-            store.recordAction({ at: now.toISOString(), actor: who.name, repo: ref.repo, taskId: row.taskId, runId: null, action: APPROVAL_PROOF, outcome: "chat",
-                source: "request", detail: approvalProofDetail(now.getTime(), store.accountOf(who.name)?.generation ?? 0, sealedDigest) });
-            store.recordAction({ at: now.toISOString(), actor: who.name, repo: ref.repo, taskId: row.taskId, runId: null, action: "plan approved in chat", outcome: "approved",
-                source: "request", detail: `via ${seat.channel} · chat binding #${seat.binding} · ${plan.source} ${plan.modeDigest}` });
             return done("✓ Approved. Work starts when a worker is free.");
         }
         case "merge": {
@@ -781,6 +985,8 @@ export function applyDecideFeedback(store, seat, prompt, text, repos, root, now)
 }
 /** The link a card keeps when it can't act in chat: a plan's is Review & start, where the password step lives. */
 export function decideFallbackLink(target) {
+    if (target?.kind === "requests")
+        return { label: OPEN_IN_TOOLROLL, path: YOUIYOUX_HOME_PATH };
     return target?.kind === "plan" ? { label: "Review & start", path: chatControlHref("approval", target.taskId) } : null;
 }
 /** Which card a pushed notification is, from its recorded kind and task — never from its words. */
@@ -791,6 +997,8 @@ export function decideTargetOf(row) {
         return { kind: "result", taskId: row.taskId, run: row.run };
     if (row.kind === "plan-ready")
         return { kind: "plan", taskId: row.taskId };
+    if (row.kind === YOUIYOUX_CARD_KIND)
+        return { kind: "requests", taskId: row.taskId };
     if (row.kind === "pull-request-ready" && row.run !== null)
         return { kind: "merge", taskId: row.taskId, run: row.run };
     if (/fail|exhausted|stalled|fenced/.test(row.kind))

package/dist/chat-messages.d.ts

@@ -267,6 +267,11 @@ export declare class ChatMessages extends ChatCore {
         taskRef: number | null;
         run: number | null;
         project: string | null;
+        image?: {
+            run: number;
+            artifact: number;
+            sha256: string;
+        };
     }[];
     createProposalAction(action: {
         token: string;

package/dist/chat-messages.js

@@ -609,7 +609,7 @@ export class ChatMessages extends ChatCore {
         const images = parts.filter(one => one.part.kind === "image").map(({ part }) => {
             const taskId = part.taskId;
             const ref = this.store.lookupRef(taskId);
-            return { taskId, taskRef: ref?.id ?? null, run: part.run, project: ref?.repo ?? null };
+            return { taskId, taskRef: ref?.id ?? null, run: part.run, project: ref?.repo ?? null, ...(part.run === null || part.artifact === null || part.sha256 === null ? {} : { image: { run: part.run, artifact: part.artifact, sha256: part.sha256 } }) };
         });
         // The lead's own messages: a reply from a turn that was about one task,
         // and a card, which names its task (or, once it filed one, the new task).

package/dist/chat-quiet.js

@@ -13,6 +13,7 @@ import { phoneText, projectLabel } from "./telegram-status.js";
 import { isLifecycleNotification } from "./store.js";
 import { leadSubjectOf } from "./lead-voice.js";
 import { decideFallbackLink, decideTargetOf } from "./chat-decide.js";
+import { YOUIYOUX_CARD_KIND } from "./contracts/youiyoux-request.js";
 /** What always makes a new message, even in quiet mode: a question or approval waiting, a failure or other
  * attention fact, a result Ready for review, a security alert or release, and anything addressed to one person
  * (a sign-in or plan-limit pause, an evening digest). */
@@ -104,8 +105,8 @@ export function quietCardView(store, taskRefs, now, root, viewer) {
     return { text, entities: [{ type: "bold", offset: 0, length: heading.length }], link: { label: "Open tasks", path: "/work" } };
 }
 /** Facts that carry their own controls or must stand alone (a security alert, a decision, a flow card, a
- * screenshot, an acceptance packet) are never folded into a batch. */
-const OWN_MESSAGE_KINDS = new Set(["security-release", "secret-detected", "flow-decision", "flow-card", "acceptance-ready", "acceptance-evidence"]);
+ * screenshot, an acceptance packet, a youiyoux pass's card) are never folded into a batch. */
+const OWN_MESSAGE_KINDS = new Set(["security-release", "secret-detected", "flow-decision", "flow-card", "acceptance-ready", "acceptance-evidence", YOUIYOUX_CARD_KIND]);
 /** Whether this update for a person joins their two-minute batch: anything about one task that needs them,
  * except a fact that must stand alone. */
 export function joinsBatch(row) {