toolroll 0.9.84 → 0.9.86

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

@@ -10,9 +10,10 @@ import { telegramProgressCard } from "./telegram-progress.js";
 import { assignmentStatusFacts, headlineEmoji, taskStatusOf } from "./task-status.js";
 import { asksToFinish, batchLine, chatText, chatTitle, factLinkLabel, mentions, READY_ACTIONS } from "./chat-voice.js";
 import { phoneText, projectLabel } from "./telegram-status.js";
-import { isLifecycleNotification } from "./store.js";
+import { isLifecycleNotification, taskArchived } 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) {
@@ -198,7 +199,8 @@ export function eveningDigestText(store, account, now, root) {
     const visible = (row) => row.project !== null && store.accountCanAccess(account, row.project);
     const title = (taskId) => chatTitle(store, taskId);
     const finished = new Map(), failed = new Map(), waits = new Map();
-    const facts = store.taskFactsSince(recent).filter(visible);
+    // A put-away task (v145) is out of the digest too: nothing about it waits, finished or failed for anyone now.
+    const facts = store.taskFactsSince(recent).filter(visible).filter(row => row.taskId === null || !taskArchived(store, row.taskId));
     for (const row of facts) {
         if (row.createdAt < since || row.taskId === null)
             continue;

package/dist/chat-review.d.ts

@@ -1,5 +1,6 @@
 import type { Store } from "./store.js";
 import type { VerifiedApprover } from "./principal.js";
+import { type FeedbackImage } from "./result-review.js";
 export type ReviewSnapshot = {
     task: string;
     root: string;
@@ -9,11 +10,13 @@ export type ReviewSnapshot = {
     sha: string;
     source: string;
     title: string;
+    images?: FeedbackImage[];
     notes: {
         id: number;
         note: string;
         path: string | null;
         line: number | null;
+        image?: FeedbackImage | null;
     }[];
 };
 type Problem = {
@@ -32,6 +35,7 @@ export type ReviewRequest = {
     path: string | null;
     line: number | null;
     notes: number[];
+    image?: FeedbackImage | null;
 };
 export declare function reviewInputProblem(note: string | null, path: string | null, line: number | null): string | null;
 /** Chat and the result form write the same comments and call the same revision service.

package/dist/chat-review.js

@@ -1,7 +1,8 @@
+import { selectResultImages } from "./chat-evidence.js";
 import { readVerifiedArtifact } from "./evidence.js";
 import { hasForbiddenControls, validateNote } from "./decision.js";
-import { isRevisionFeedback, revisionSourceOf } from "./result-review.js";
-import { createResultRevision } from "./result-actions.js";
+import { parseFeedbackImage, isRevisionFeedback, revisionSourceOf } from "./result-review.js";
+import { createResultRevision, feedbackImageProblem } from "./result-actions.js";
 /** Read precisely the result named, never silently substitute a newer version. */
 export function readChatResult(store, who, evidenceRoot, task, run) {
     const ref = store.lookupRef(task);
@@ -21,11 +22,13 @@ export function readChatResult(store, who, evidenceRoot, task, run) {
     const proven = readVerifiedArtifact(evidenceRoot, artifact);
     if (!proven.ok)
         return { ok: false, message: "The saved changes could not be verified. Restore the result before adding feedback." };
+    const images = selectResultImages(store, who, evidenceRoot, task, found.id);
     return { ok: true, snapshot: {
             task, root: family.root.id, execution: family.current.id, run: found.id,
             artifact: artifact.id, sha: artifact.sha256, source: revisionSourceOf(store.getScope(task)?.digest ?? null),
             title: store.getTask(task)?.title ?? task,
-            notes: store.liveDiffComments(found.id).filter(isRevisionFeedback).map(one => ({ id: one.id, note: one.note, path: one.path, line: one.line })),
+            images: images.ok ? images.selection.images.map(one => ({ run: found.id, artifact: one.artifact, sha256: one.sha256 })) : [],
+            notes: store.liveDiffComments(found.id).filter(isRevisionFeedback).map(one => ({ id: one.id, note: one.note, path: one.path, line: one.line, image: one.image ?? null })),
         } };
 }
 export function reviewInputProblem(note, path, line) {
@@ -65,9 +68,15 @@ export function applyChatReview(store, who, evidenceRoot, request, now, allowMod
                 return fail("Some feedback changed or was already used. Review it again.");
             if (operation === "note" && (note === null || notes.length > 0))
                 return fail("A saved note needs feedback text and cannot consume other notes.");
+            const image = parseFeedbackImage(request.image);
+            if (image === false || (image !== null && note === null))
+                return fail("Choose a screenshot and write its feedback again.");
+            const imageProblem = feedbackImageProblem(store, evidenceRoot, live.run, image);
+            if (imageProblem !== null)
+                return fail(imageProblem);
             const batch = [...notes].sort((a, b) => a - b);
             if (note !== null) {
-                const id = store.addDiffComment({ artifactId: live.artifact, runId: live.run, path, line, note, author: who.name }, now);
+                const id = store.addDiffComment({ artifactId: live.artifact, runId: live.run, path, line, note, author: who.name, image }, now);
                 if (id === null)
                     return fail("The note could not be saved.");
                 batch.push(id);

package/dist/chat-terms.d.ts

@@ -0,0 +1,9 @@
+import type { Scope } from "./scope.js";
+/** 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;
+export type ShownScope = Pick<Scope, "goal" | "outOfScope" | "touches" | "acceptance" | "profile" | "budgetMicrousd">;
+/** Every word of the terms a yes agrees to, as the card shows them: the goal, what's excluded, the files (or plainly any
+ * file), each requirement with the evidence it needs, and what the agent may do and spend. Nothing is shortened. */
+export declare function scopeTermsText(scope: ShownScope): string;
+/** The digest of the terms shown, bound to the scope's own digest: a changed word, limit or route is another digest. */
+export declare function shownTermsDigest(scope: ShownScope & Pick<Scope, "digest">): string;

package/dist/chat-terms.js

@@ -0,0 +1,46 @@
+/**
+ * A scope's terms as a chat card shows them whole, and the digest of exactly those words. A task filed from outside
+ * text (a youiyoux change request) approves from chat only on a card that showed every word of its terms, nothing cut:
+ * the card binds that digest to its button, and the seal (store.ts, the outside-request quarantine) recomputes it from
+ * the live scope and refuses a tap that names anything else. A leaf: the store and the chat road both read it.
+ */
+import { createHash } from "node:crypto";
+import { isAcpProfile } from "./acp-agents.js";
+/** 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";
+}
+const money = (micro) => `$${(micro / 1_000_000).toFixed(2)}`;
+/** Every word of the terms a yes agrees to, as the card shows them: the goal, what's excluded, the files (or plainly any
+ * file), each requirement with the evidence it needs, and what the agent may do and spend. Nothing is shortened. */
+export function scopeTermsText(scope) {
+    const allows = [permissionPlainWords(scope.profile) ?? "agent permissions not known", scope.budgetMicrousd === null ? "no attempt limit" : `up to ${money(scope.budgetMicrousd)} per attempt`];
+    return [
+        "Goal:", scope.goal,
+        "",
+        "Not this:", scope.outOfScope ?? "Nothing excluded.",
+        "",
+        `Files: ${scope.touches.length === 0 ? "any file (no file list)" : scope.touches.join(", ")}`,
+        "",
+        "Done when:",
+        ...(scope.acceptance.length === 0 ? ["You decide when you review the result."] : scope.acceptance.map(one => `• ${one.statement} (${one.evidence.join(", ")})`)),
+        "",
+        `Starting allows: ${allows.join(" · ")}`,
+    ].join("\n");
+}
+/** The digest of the terms shown, bound to the scope's own digest: a changed word, limit or route is another digest. */
+export function shownTermsDigest(scope) {
+    return createHash("sha256").update(JSON.stringify({ v: 1, scope: scope.digest, shown: scopeTermsText(scope) })).digest("hex");
+}

package/dist/claim.d.ts

@@ -103,6 +103,9 @@ export type AcquireResult = {
  | {
     ok: false;
     reason: "coordinator-filed";
+} | {
+    ok: false;
+    reason: "archived";
 } | {
     ok: false;
     reason: "watch-custody";

package/dist/claim.js

@@ -31,7 +31,7 @@ import { randomUUID } from "node:crypto";
 import { authenticate, drainOf } from "./runner.js";
 import { pauseForAuth } from "./provider-auth.js";
 import { DEFAULT_MAX_OPEN_DECISIONS, missingCapability, scopeApprovedForDispatch, taskReadinessBlocker, } from "./dispatch.js";
-import { BUILT_IN, } from "./store.js";
+import { BUILT_IN, refArchived, } from "./store.js";
 import { digestOf } from "./scope.js";
 import { parseExecutionPlanDocument } from "./plan.js";
 import { sealUnchangedPlanUnderMode } from "./plan-auto.js";
@@ -109,6 +109,9 @@ function acquireLocked(store, taskRef, runner, options) {
         if (placedRef !== null && placedRef.coordinatorCid !== null && !store.scopeSealed(placedRef.externalId)) {
             return { ok: false, reason: "coordinator-filed" };
         }
+        // A PUT-AWAY TASK (v145, task-tidy.md) claims for nobody, on every road: restore it first.
+        if (refArchived(store, taskRef))
+            return { ok: false, reason: "archived" };
         // The reservation gate lives HERE, in the one primitive every
         // acquisition path shares (queue-columns review, finding 1): tick's
         // acquireIfReady and the raw CLI claim both

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

@@ -160,6 +160,13 @@ export declare const chatActionRequestSchemas: {
     readonly flow_trigger_remove: z.ZodObject<{
         trigger: z.ZodInt;
     }, z.core.$strict>;
+    /** Browser use in the flow's script zones (flow-browser.ts): allowing it takes the person's own password in the secure screen. */
+    readonly flow_browser: z.ZodObject<{
+        flow: z.ZodInt;
+    }, z.core.$strict>;
+    readonly flow_browser_off: z.ZodObject<{
+        flow: z.ZodInt;
+    }, z.core.$strict>;
     readonly subagent_create: z.ZodObject<{
         repo: z.ZodString;
         template: z.ZodOptional<z.ZodUnknown>;
@@ -282,6 +289,8 @@ export declare const sharedActionSchema: z.ZodObject<{
     operation: z.ZodEnum<{
         decision_record: "decision_record";
         decision_retire: "decision_retire";
+        flow_browser: "flow_browser";
+        flow_browser_off: "flow_browser_off";
         flow_card_add: "flow_card_add";
         flow_card_approve: "flow_card_approve";
         flow_card_assign: "flow_card_assign";

package/dist/contracts/chat-actions.js

@@ -61,6 +61,9 @@ export const chatActionRequestSchemas = {
     flow_trigger_pause: z.strictObject({ trigger: id }),
     flow_trigger_resume: z.strictObject({ trigger: id }),
     flow_trigger_remove: z.strictObject({ trigger: id }),
+    /** Browser use in the flow's script zones (flow-browser.ts): allowing it takes the person's own password in the secure screen. */
+    flow_browser: z.strictObject({ flow: id }),
+    flow_browser_off: z.strictObject({ flow: id }),
     subagent_create: z.strictObject({ repo: words, template: z.unknown().optional(), name: z.unknown().optional(), soul: z.unknown().optional() }),
     subagent_soul: z.strictObject({ subagent: id, soul: words }),
     subagent_state: z.strictObject({ subagent: id, state: z.enum(["active", "paused", "removed"]) }),