toolroll 0.9.84 → 0.9.85

package/dist/flow-cadence.d.ts

@@ -13,26 +13,32 @@ import { type TriggerIo, type TriggerPass } from "./flow-triggers.js";
 import { type ReplyWatch, type ReplyWatchIo } from "./flow-replies.js";
 import { type StepIo, type StepPass } from "./flow-steps.js";
 import type { Store } from "./store.js";
+import { type Git } from "./landed-cleanup.js";
+import { type YouiyouxPass } from "./youiyoux-intake.js";
 /** How often the worker moves cards, checks triggers, reads replies and runs steps, builds or not. */
 export declare const FLOW_EVERY_MS = 15000;
 /** One pass of a kind for a project at a time in this process: a second one asked for while it runs is skipped
  * (`idle`), and the next cadence takes up whatever it would have done. Cards are also claimed in the database,
  * so passes in other processes can't act twice either. */
 export declare function alone<T>(kind: string, project: string, idle: T, run: () => Promise<T>): Promise<T>;
+/** `youiyouxGit`: the hardened git an options request's result is read with (the plane's own runner; gitOf by default). */
 export type FlowIo = {
     triggers: TriggerIo;
     replies: ReplyWatchIo;
     steps: StepIo;
     evidenceRoot?: string;
+    youiyouxGit?: Git;
 };
 export type FlowHousekeeping = {
     triggers: TriggerPass;
+    youiyoux: YouiyouxPass;
     replies: ReplyWatch;
     steps: StepPass;
     flows: FlowAdvance;
 };
-/** One project's flow pass: triggers (which may start cards), replies (which move waiting cards), steps, then moves.
- * `halted` (a stop or paused admission) skips everything that reaches outside; moves still run. */
+/** One project's flow pass: triggers (which may start cards), youiyoux requests (which file tasks that wait for a
+ * person, and move an options request's options to youiyoux's hub and a decision there back), replies (which move waiting cards), steps, then moves. `halted` (a stop or paused admission) skips
+ * everything that reaches outside; moves still run. */
 export declare function flowHousekeeping(store: Store, repo: string, clock: () => Date, io: FlowIo, halted: () => boolean): Promise<FlowHousekeeping>;
 /** Move one project's cards. Synchronous, so two can't overlap in a process; each move is checked against the
  * card's visit in its own transaction, so a pass in another process can't move a card twice. */

package/dist/flow-cadence.js

@@ -12,6 +12,8 @@ import { advanceFlows } from "./flow-engine.js";
 import { runFlowTriggers } from "./flow-triggers.js";
 import { watchFlowReplies } from "./flow-replies.js";
 import { runFlowSteps } from "./flow-steps.js";
+import { gitOf } from "./landed-cleanup.js";
+import { NO_YOUIYOUX_PASS, runYouiyoux } from "./youiyoux-intake.js";
 /** How often the worker moves cards, checks triggers, reads replies and runs steps, builds or not. */
 export const FLOW_EVERY_MS = 15_000;
 const running = new Set();
@@ -30,11 +32,22 @@ export async function alone(kind, project, idle, run) {
         running.delete(key);
     }
 }
-/** One project's flow pass: triggers (which may start cards), replies (which move waiting cards), steps, then moves.
- * `halted` (a stop or paused admission) skips everything that reaches outside; moves still run. */
+const NO_REQUESTS = NO_YOUIYOUX_PASS;
+/** One project's flow pass: triggers (which may start cards), youiyoux requests (which file tasks that wait for a
+ * person, and move an options request's options to youiyoux's hub and a decision there back), replies (which move waiting cards), steps, then moves. `halted` (a stop or paused admission) skips
+ * everything that reaches outside; moves still run. */
 export async function flowHousekeeping(store, repo, clock, io, halted) {
     const triggers = halted() ? { added: 0, checked: 0, problems: [] }
         : await alone("triggers", repo, { added: 0, checked: 0, problems: [] }, () => runFlowTriggers(store, repo, clock(), io.triggers));
+    const youiyoux = halted() ? NO_REQUESTS
+        : await alone("youiyoux", repo, NO_REQUESTS, async () => {
+            try {
+                return await runYouiyoux(store, repo, clock(), { dir: io.triggers.dir, env: process.env, git: io.youiyouxGit ?? gitOf(), evidenceRoot: io.evidenceRoot ?? null });
+            }
+            catch (error) {
+                return { ...NO_REQUESTS, problems: [`youiyoux: ${error instanceof Error ? error.message : "could not read requests"}`] };
+            }
+        });
     // One mailbox serves every project, so its reads are one at a time across them all.
     const replies = halted() ? { read: 0, taken: 0, problem: null }
         : await alone("replies", "*", { read: 0, taken: 0, problem: null }, () => watchFlowReplies(store, clock(), io.replies));
@@ -42,7 +55,7 @@ export async function flowHousekeeping(store, repo, clock, io, halted) {
         : await alone("steps", repo, { ran: 0, problems: [] }, () => runFlowSteps(store, repo, clock(), io.steps));
     // Last, so a step that just finished, or a card a trigger just added, moves now.
     const flows = moveCards(store, repo, clock(), io.evidenceRoot);
-    return { triggers, replies, steps, flows };
+    return { triggers, youiyoux, replies, steps, flows };
 }
 /** Move one project's cards. Synchronous, so two can't overlap in a process; each move is checked against the
  * card's visit in its own transaction, so a pass in another process can't move a card twice. */

package/dist/flow-card-task.d.ts

@@ -1,2 +1,11 @@
 import type { Store } from "./store.js";
+import { type TaskStatus } from "./task-status.js";
+/** A task's status as its page reads it, from the store alone (no evidence files); null when it can't be read. */
+/** `root`: where results' saved evidence is. Without it the receipt is read without its saved checks, so a completion
+ * (bound to the receipt read with them) doesn't read as one: a status that must say Complete passes it. */
+export declare function storedTaskStatus(store: Store, taskId: string, repo: string, now: Date, root?: string): {
+    status: TaskStatus;
+    activeTaskId: string;
+    live: ReturnType<Store["getRun"]>;
+} | null;
 export declare function flowCardTaskLine(store: Store, taskId: string, repo: string, now: Date, secrets?: readonly string[]): string;

package/dist/flow-card-task.js

@@ -19,14 +19,17 @@ function cardReason(text, fallback, secrets) {
         return fallback;
     return clean.length > 100 ? `${clean.slice(0, 99).trimEnd()}…` : clean;
 }
-export function flowCardTaskLine(store, taskId, repo, now, secrets = []) {
+/** A task's status as its page reads it, from the store alone (no evidence files); null when it can't be read. */
+/** `root`: where results' saved evidence is. Without it the receipt is read without its saved checks, so a completion
+ * (bound to the receipt read with them) doesn't read as one: a status that must say Complete passes it. */
+export function storedTaskStatus(store, taskId, repo, now, root) {
     const access = { principal: "operator", repos: [repo], dependencyRepos: [repo] };
-    const assignment = assignmentOf(store, taskId, now, access);
+    const assignment = assignmentOf(store, taskId, now, access, root);
     if (assignment === null)
-        return "Task unavailable";
+        return null;
     const work = taskWorkSummaryOf(store, assignment.activeTaskId, now, access);
     if (work === null)
-        return "Task unavailable";
+        return null;
     const live = work.liveRunId === null ? null : store.getRun(work.liveRunId);
     const facts = assignmentStatusFacts(assignment, { work: work.status, planning: live?.role === "planner" });
     // The canvas reads no evidence files. Keep the machine's recorded check visible
@@ -35,7 +38,13 @@ export function flowCardTaskLine(store, taskId, repo, now, secrets = []) {
     // With neither, nothing about the check was read here: the line says nothing about it, never a pass and never an ask.
     if (facts.checks?.status === "unavailable")
         facts.checks = check === null ? null : { ...facts.checks, status: check.status, exitCode: check.exitCode };
-    const status = taskStatusOf(facts);
+    return { status: taskStatusOf(facts), activeTaskId: assignment.activeTaskId, live };
+}
+export function flowCardTaskLine(store, taskId, repo, now, secrets = []) {
+    const read = storedTaskStatus(store, taskId, repo, now);
+    if (read === null)
+        return "Task unavailable";
+    const { status, live } = read;
     if (status.headline === "Needs you") {
         const fallback = status.need?.action.label ?? "Open the task";
         // The question itself is useful; routine approvals are clearer as the short action.
@@ -44,7 +53,7 @@ export function flowCardTaskLine(store, taskId, repo, now, secrets = []) {
         return `Waiting on you: ${what}`;
     }
     if (status.headline === "Building" && live !== null) {
-        const ref = store.lookupRef(assignment.activeTaskId);
+        const ref = store.lookupRef(read.activeTaskId);
         const checkpoint = store.latestCheckpointForRun(live.id);
         const progress = buildProgressOf(checkpoint?.taskRef !== ref?.id ? null : checkpoint?.snapshot.milestones.map(one => ({ description: null, state: one.state, note: one.note })));
         if (progress?.stuck != null)

package/dist/integrations-ui.js

@@ -14,7 +14,7 @@ export const INTEGRATIONS_CSS = `.integrations{max-width:760px;min-width:0}.inte
     `.integrations .integration>:not(.integration-action),.integrations .integration-body>*{grid-column:1}.integrations .integration-body{display:contents}.integrations .integration:first-of-type{border-top:0}.integrations .integration-head{margin:0;display:flex;flex-wrap:wrap;gap:6px 10px;align-items:center;min-width:0}` +
     `.integrations .integration .integration-body>*{margin-left:calc(var(--brand-mark) + 10px)}.integrations .integration-head strong{overflow-wrap:anywhere}.integrations .integration p{margin:2px 0 0;min-width:0;overflow-wrap:anywhere}` +
     `.integrations .integration-action{grid-column:2;grid-row:1 / span 3;align-self:center;margin:0}.integrations .integration-action button,.integrations .integration-action .button-link{min-height:44px;white-space:nowrap}` +
-    `.integrations .integration .integration-action button{width:auto}.integrations .integration .integration-action a.integration-quiet{background:var(--so-paper);color:var(--so-ink);border:1px solid var(--so-input-line)}` +
+    `.integrations .integration .integration-action button{width:auto}.integrations .integration .integration-action a.integration-quiet,.integrations .integration .integration-action button.integration-quiet{background:var(--so-paper);color:var(--so-ink);border:1px solid var(--so-input-line)}` +
     `.integrations .integration-fix{color:var(--so-danger)}.integrations code{overflow-wrap:anywhere}.integrations details{margin-top:4px;font-size:.8125rem}.integrations summary{cursor:pointer;padding:4px 0}` +
     `.integration-state{display:inline-flex;align-items:center;gap:6px;font-size:.75rem;font-weight:500;padding:0 8px;border-radius:5px;line-height:20px;white-space:nowrap}` +
     `.integration-state i{width:6px;height:6px;border-radius:50%;background:currentColor}` +
@@ -33,6 +33,10 @@ function action(one, csrf) {
     if (a.kind === "test") {
         return csrf === "" ? "" : postForm("/settings/integrations/test", html `<button type="submit">Send test</button>`, { attrs: { class: "integration-action" }, hidden: { key: one.key } });
     }
+    // A project's youiyoux requests: one switch for that project.
+    if (a.kind === "switch") {
+        return csrf === "" ? "" : postForm("/settings/integrations/youiyoux", html `<button type="submit"${a.on ? "" : html ` class="integration-quiet"`}>${a.label}</button>`, { attrs: { class: "integration-action" }, hidden: { repo: a.repo, on: a.on ? "1" : "0" } });
+    }
     // A command is run where Toolroll runs; a page is linked. Fix and Set up both say which.
     // Fix is the one filled action on the page; Set up stays quiet so a list of unused services doesn't shout.
     if (a.href !== null)
@@ -50,12 +54,13 @@ function row(one, csrf) {
         ? html `<span class="integration-state integration-state--checking"><i aria-hidden="true"></i>Checking</span>`
         : html `<span class="integration-state integration-state--${one.state}"><i aria-hidden="true"></i>${STATE_WORDS[one.state]}</span>`;
     const facts = [one.account, one.detail, one.credentials].filter(Boolean).join(" · ");
-    const command = one.action.kind !== "test" ? one.action.command : null;
-    const fix = one.action.kind === "fix" ? html `<p class="integration-fix" role="status">${one.action.words}</p>` : "";
+    const command = one.action.kind === "setup" || one.action.kind === "fix" ? one.action.command : null;
+    const words = one.action.kind === "fix" || one.action.kind === "switch" ? one.action.words : null;
+    const fix = words !== null ? html `<p class="integration-fix" role="status">${words}</p>` : "";
     const run = command === null || (one.action.kind === "fix" && one.action.words.includes(command)) ? "" : html `<p class="meta">Run <code>${command}</code> on the computer running Toolroll.</p>`;
     const seen = [one.lastSuccessAt === null ? null : html `Last success ${when(one.lastSuccessAt)}`, one.usedBy.length === 0 ? null : html `Used by ${one.usedBy.join(", ")}`].filter(Boolean);
     const history = one.state === "not-set-up" || seen.length === 0 ? "" : html `<p class="meta">${joinHtml(seen, " · ")}</p>`;
-    const lastError = one.lastError === null || one.state === "not-set-up" ? "" : one.state === "broken" && one.action.kind === "fix" && one.action.words === one.lastError
+    const lastError = one.lastError === null || one.state === "not-set-up" ? "" : one.state === "broken" && words === one.lastError
         ? html `<p class="meta">Failed ${when(one.lastErrorAt ?? "")}</p>`
         : html `<details><summary>Last error ${one.lastErrorAt === null ? "" : when(one.lastErrorAt)}</summary><p class="meta">${one.lastError}</p></details>`;
     return html `<div class="integration" data-integration="${one.key}" data-state="${one.state}"><p class="integration-head">${brandMarkHtml(markFor(one), one.name, one.state === "connected")}<strong>${one.name}</strong> ${badge}</p>${action(one, csrf)}<div class="integration-body">${facts === "" ? "" : html `<p class="meta">${facts}</p>`}${fix}${run}${history}${lastError}</div></div>`;

package/dist/integrations.d.ts

@@ -18,7 +18,15 @@ export type IntegrationAction = ({
     kind: "fix";
     label: "Fix";
     words: string;
-} & IntegrationPlace);
+} & IntegrationPlace)
+/** A project's youiyoux requests: one switch, and the problem to fix when it is Broken. */
+ | {
+    kind: "switch";
+    label: "Turn off" | "Turn on";
+    repo: string;
+    on: boolean;
+    words: string | null;
+};
 export type Integration = {
     key: string;
     group: IntegrationGroup;

package/dist/integrations.js

@@ -31,6 +31,7 @@ import { LINEAR_URL, readHooksBase, readLinearKey } from "./flow-triggers.js";
 import { credentialModeOf, projectToolsOf, readToolSecrets, missingSecrets, secretsSetFor, testToolOf } from "./project-tools.js";
 import { origin, readMonitoring } from "./monitoring-settings.js";
 import { targetOf } from "./monitoring.js";
+import { youiyouxState } from "./youiyoux-intake.js";
 export const STATE_WORDS = { connected: "Connected", "not-set-up": "Not set up", broken: "Broken" };
 const NO_ACTIVITY = { okAt: null, error: null, errorAt: null, failing: false };
 const PROBE_MS = 8_000;
@@ -459,10 +460,46 @@ function combine(target, row) {
     }
     return { ...base, ...common, state: "connected", action: { kind: "test", label: "Send test" } };
 }
+/**
+ * youiyoux change requests, one row per project that uses youiyoux (youiyoux-intake.ts): Connected with how many of
+ * its requests are queued, Broken when the last pass couldn't read its folder or some of its files, or Not set up when
+ * a person turned it off; one row Not set up when no project uses it. Read from the store and the folders' presence.
+ */
+function youiyouxIntegrations(io) {
+    // In the order every other row's keys come (combine), so `--json` reads alike.
+    const row = (key, account, facts, state, action) => ({
+        key, group: "code", name: "youiyoux", usedBy: facts.usedBy ?? [], account, detail: facts.detail, checked: true, checkedAt: facts.checkedAt ?? null,
+        lastSuccessAt: facts.lastSuccessAt ?? null, lastError: facts.lastError ?? null, lastErrorAt: facts.lastErrorAt ?? null, state, action,
+    });
+    const rows = io.repos.flatMap((repo) => {
+        let state;
+        try {
+            state = youiyouxState(io.store, repo);
+        }
+        catch {
+            return [];
+        }
+        if (!state.uses)
+            return [];
+        const key = `youiyoux:${repo}`, account = basename(repo);
+        const turn = (on, words) => ({ kind: "switch", label: on ? "Turn on" : "Turn off", repo, on, words });
+        if (state.off)
+            return [row(key, account, { detail: "Turned off" }, "not-set-up", turn(true, null))];
+        const facts = { usedBy: [`Tasks in ${account}`], detail: `${plural(state.queued, "request")} queued`, checkedAt: state.checkedAt };
+        if (state.problem === null)
+            return [row(key, account, { ...facts, lastSuccessAt: state.checkedAt }, "connected", turn(false, null))];
+        const words = scrubIntegrationText(state.problem);
+        return [row(key, account, { ...facts, lastError: words, lastErrorAt: state.checkedAt }, "broken", turn(false, words))];
+    });
+    return rows.length > 0 ? rows : [row("youiyoux", null, { detail: "Starts by itself in a project with a youi.project.json" }, "not-set-up", { kind: "setup", label: "Set up", href: null, command: null })];
+}
 /** Every integration as it stands now, from files and saved history only: no network, no process, never slow. */
 export function integrationsNow(io) {
     const rows = readIntegrationChecks(io.store);
-    return targets(io).map(target => combine(target, rows.get(target.key)));
+    const list = targets(io).map(target => combine(target, rows.get(target.key)));
+    const linear = list.findIndex(one => one.key === "linear");
+    list.splice(linear + 1, 0, ...youiyouxIntegrations(io));
+    return list;
 }
 /** Run the checks (all, or the named ones), record each answer, and return the list. */
 export async function checkIntegrations(io, keys) {
@@ -512,7 +549,11 @@ export function renderIntegrations(list, secrets = null) {
                 lines.push(`${"".padEnd(width)}  last success ${whenText(one.lastSuccessAt)}${one.lastError === null ? "" : ` · last error ${whenText(one.lastErrorAt)}: ${one.lastError}`}`);
             if (one.action.kind === "fix")
                 lines.push(`${"".padEnd(width)}  Fix: ${one.action.words}${one.action.command === null || one.action.words.includes(one.action.command) ? "" : ` (run ${one.action.command})`}`);
-            if (one.action.kind === "setup")
+            if (one.action.kind === "switch" && one.action.words !== null)
+                lines.push(`${"".padEnd(width)}  Fix: ${one.action.words}`);
+            if (one.action.kind === "switch" && one.action.on)
+                lines.push(`${"".padEnd(width)}  Turn on: Settings → Integrations`);
+            if (one.action.kind === "setup" && (one.action.command !== null || one.action.href !== null))
                 lines.push(`${"".padEnd(width)}  Set up: ${one.action.command !== null ? `run ${one.action.command}` : `Settings (${one.action.href ?? "/settings"})`}`);
             return lines;
         }), ...note];

package/dist/landed-cleanup.d.ts

@@ -1,3 +1,4 @@
+import { type AssignmentSnapshot } from "./assignment.js";
 import type { RemoteMainRead, RemoteMains } from "./remote-main.js";
 import type { Store } from "./store.js";
 import { type Git } from "./teardown-git.js";
@@ -70,6 +71,9 @@ export type LandedCandidate = {
     targets: LandedTarget[];
     keeps: LandedKeep[];
 };
+/** Use the current manual completion guards. Only a recorded merge of this exact result can settle them. Also why a
+ * youiyoux options task a person decided on in the hub stays for review (youiyoux-intake.ts). */
+export declare function completionProblem(store: Store, assignment: AssignmentSnapshot, root: string): string | null;
 /**
  * Results in a project whose work landed, with what their teardown would remove and what stays. Reads only.
  * `limit` caps how many results are read against git (reconcile's bound; results read before and unchanged since

package/dist/landed-cleanup.js

@@ -237,8 +237,9 @@ function resultProblem(store, runId, head) {
         return "its result couldn't be read";
     return run.outcome === "no-change" || run.baseRevision === head ? "its result has no new work" : null;
 }
-/** Use the current manual completion guards. Only a recorded merge of this exact result can settle them. */
-function completionProblem(store, assignment, root) {
+/** Use the current manual completion guards. Only a recorded merge of this exact result can settle them. Also why a
+ * youiyoux options task a person decided on in the hub stays for review (youiyoux-intake.ts). */
+export function completionProblem(store, assignment, root) {
     if (assignment.state !== "ready-to-check" && assignment.state !== "complete")
         return "it needs a decision first";
     if (assignment.state === "complete")

package/dist/lead-capabilities.js

@@ -181,7 +181,8 @@ export function integrationCapabilities(list) {
     return list.map(one => {
         const link = one.group === "agents" ? "providers" : one.group === "tools" ? "tools" : INTEGRATION_LINK[one.key.replace(/^.*:/, "").toLowerCase()] ?? INTEGRATION_LINK[one.name.toLowerCase()] ?? "integrations";
         const lets = one.usedBy.length > 0 ? `use ${one.name} for ${one.usedBy.join(", ")}` : `use ${one.name}`;
-        const next = one.action.kind === "setup" ? `Not set up: set up ${one.name} in Settings` : one.action.kind === "fix" ? `Fix: ${one.action.words}` : null;
+        const next = one.action.kind === "setup" ? `Not set up: set up ${one.name} in Settings` : one.action.kind === "fix" ? `Fix: ${one.action.words}`
+            : one.action.kind === "switch" ? (one.action.words !== null ? `Fix: ${one.action.words}` : one.action.on ? `Turned off: turn ${one.name} on in Settings → Integrations` : null) : null;
         return { name: one.name, kind: one.group, state: STATE_WORDS[one.state], ok: one.state === "connected", account: one.account, usedBy: one.usedBy, lastError: one.lastError, lets, next, link: next === null ? null : link };
     });
 }

package/dist/lead-cli.js

@@ -1,3 +1,4 @@
+import { parseFeedbackImage } from "./result-review.js";
 import { configureLeadFollow, leadFollowStatus } from './lead-follow.js';
 import { closedQuestionWords } from "./decision.js";
 /**
@@ -104,7 +105,8 @@ export function proposalBlock(store, proposal, repos, number) {
         const snapshot = proposal.payload["snapshot"];
         const selected = Array.isArray(proposal.payload["notes"]) ? proposal.payload["notes"] : [];
         const notes = snapshot?.notes.filter(one => selected.includes(one.id)) ?? [];
-        return [line, ...notes.map(one => `     ${one.path === null ? "" : `${one.path}${one.line === null ? "" : `:${one.line}`}: `}${one.note}`),
+        const image = parseFeedbackImage(proposal.payload["image"]);
+        return [line, ...(image ? [`     Screenshot ${image.artifact} · result #${image.run}`] : []), ...notes.map(one => `     ${one.image ? `Screenshot ${one.image.artifact} · result #${one.image.run}: ` : ""}${one.path === null ? "" : `${one.path}${one.line === null ? "" : `:${one.line}`}: `}${one.note}`),
             proposal.payload["operation"] === "revise" ? "     Creates a revision of the same task; approval is separate." : "     Saves feedback; no work starts."];
     }
     return proposal.kind === "answer" ? [line, ...answerContextLines(store, proposal.payload)] : [line];

package/dist/lead-tools.d.ts

@@ -1,3 +1,4 @@
+import { type FeedbackImage } from "./result-review.js";
 import { type CommitmentChannel } from "./lead-commitments.js";
 import { type Integration } from "./integrations.js";
 import type { AuthMode } from "./keys.js";
@@ -23,6 +24,7 @@ export type LeadToolContext = {
         step: number;
         snapshot: ReviewSnapshot;
     }>;
+    replyImage?: FeedbackImage;
     /** Where evidence lives, when the surface knows — a scout's report reads from here. */
     evidenceRoot?: string;
     /** Records the screenshots this turn selected, under the turn, for a channel that delivers files; returns how many are recorded. Absent: nothing durable is kept. */

package/dist/lead-tools.js

@@ -1,9 +1,11 @@
+import { sameFeedbackImage } from "./result-review.js";
 import { sweepLine, sweepTable } from "./lead-sweep.js";
 import { connectionsOf, oneClickOf } from "./mcp-connect.js";
 import { checkLevelFromWords, isCheckLevel } from "./check-levels.js";
 import { policyParts } from "./policy.js";
 import { randomUUID } from 'node:crypto';
 import { dirname, join } from 'node:path';
+import { projectOutcomes, projectOutcomesPage } from './project-outcomes.js';
 import { repositoryContextRead } from './repository-context.js';
 import { assignmentCatchUp } from './assignment-brief.js';
 import { CHAT_ACTIONS, CHAT_ACTION_FIELDS, isChatAction, prepareSharedAction, sharedActionNeedsReview, sharedActionPayload } from './chat-actions.js';
@@ -18,6 +20,7 @@ import { cancelCommitment, CHECK_RESULTS, conditionWords, latestResultRun, recor
 import { searchMemory } from "./project-memory.js";
 import { integrationsNow, STATE_WORDS } from "./integrations.js";
 import { CAPABILITIES_UNREAD, capabilitiesOf, needsCapabilities } from "./lead-capabilities.js";
+import { feedbackImageProblem } from "./result-actions.js";
 import { readChatResult, reviewInputProblem } from "./chat-review.js";
 import { RESULT_IMAGES_PER_TURN_CAP, selectResultImages } from "./chat-evidence.js";
 import { CHAT_CONTROLS, isChatControl } from "./chat-controls.js";
@@ -377,7 +380,7 @@ export function agentsOver(store, taskId, now) {
  * find_tools and advertised from the next request of the same reply.
  */
 export const LEAD_CORE_TOOLS = new Set([
-    "find_tools", "get_brief", "recap", "list_repos", "get_project_context", "search_project_memory", "get_capabilities",
+    "find_tools", "get_brief", "recap", "list_repos", "get_project_context", "get_project_activity", "search_project_memory", "get_capabilities",
     "list_tasks", "get_task", "get_result", "get_diff", "get_check_log", "list_decisions", "get_decision",
     "get_actions", "get_action_status", "propose_action", "propose_task", "propose_scope", "propose_steer",
     "propose_answer", "propose_review", "remember", "ask_owner", "commit_to",
@@ -475,6 +478,15 @@ const LEAD_TOOL_HANDLERS = {
             return { ok: true, body: assignmentCatchUp(ctx.store, ctx.now, { principal: 'operator', repos: ctx.who.repos }, repo === null ? {} : { repo }, ctx.evidenceRoot) };
         },
     },
+    get_project_activity: {
+        description: 'Read project Activity: current Ready backlog, finished-to-decision elapsed time, explicit revisions and recorded cost for completed families in the last 60 days. Includes coverage and a page of underlying tasks (offset: nextOffset for more); not review labor or a quality score.',
+        handle: (ctx, args) => {
+            const repo = repoPathOf(ctx.who, args['repo']);
+            if (!repo || !ctx.store.accountCanAccess(ctx.who.name, repo))
+                return { ok: false, message: 'Choose an available project from list_repos.' };
+            return { ok: true, body: projectOutcomesPage(projectOutcomes(ctx.store, repo, ctx.now, { principal: 'operator', repos: ctx.who.repos }), Number(args['offset'] ?? 0)) };
+        },
+    },
     get_project_context: {
         description: 'Find source excerpts or advisory import impact. Read-only; unavailable indexing falls back to source search.',
         handle: (ctx, args) => {
@@ -656,6 +668,7 @@ const LEAD_TOOL_HANDLERS = {
                     changes: snippet.slice(0, 1000), changesShortened: snippet.length > 1000,
                     verification: ctx.store.proofVerdictFor(snapshot.run)?.verdict ?? "not verified",
                     accepted: ctx.store.proofAcceptance(snapshot.run) !== null,
+                    images: (snapshot.images ?? []).map(one => ({ id: one.artifact, run: one.run })),
                     evidenceTool: "get_acceptance_evidence",
                     canRevise: snapshot.execution === snapshot.task } };
         },
@@ -789,7 +802,7 @@ const LEAD_TOOL_HANDLERS = {
         },
     },
     propose_review: {
-        description: "Read get_result first. revise uses selected saved_notes plus optional note on the SAME task; note saves only. Omitted saved_notes stays untouched.",
+        description: "Read get_result first. revise uses selected saved_notes plus optional note on the SAME task; note saves only. Omitted saved_notes stays untouched. To comment on a screenshot, use its image id from get_result_images. If this channel cannot select one, link to the result Comment control and say feedback still needs submitting there.",
         handle: (ctx, args) => {
             const read = ctx.readResults?.get(Number(args["run"]));
             if (read === undefined || read.step >= ctx.step)
@@ -812,8 +825,20 @@ const LEAD_TOOL_HANDLERS = {
                 return { ok: false, message: "Write feedback or select saved notes for a revision." };
             if (operation === "revise" && read.snapshot.task !== read.snapshot.execution)
                 return { ok: false, message: "A newer revision is current. Read that version before requesting changes." };
+            const wanted = args["image"] === null ? undefined : args["image"] ?? (note !== null && ctx.replyImage?.run === read.snapshot.run ? ctx.replyImage.artifact : undefined);
+            let image = null;
+            if (wanted !== undefined) {
+                image = read.snapshot.images?.find(one => one.artifact === wanted) ?? null;
+                if (image === null || ctx.evidenceRoot === undefined || note === null)
+                    return { ok: false, message: "Choose a saved screenshot from the result you read and write feedback." };
+                if (ctx.replyImage?.artifact === wanted && !sameFeedbackImage(ctx.replyImage, image))
+                    return { ok: false, message: "The screenshot you replied to changed. Open the result and select it again." };
+                const problem = feedbackImageProblem(ctx.store, ctx.evidenceRoot, read.snapshot.run, image);
+                if (problem !== null)
+                    return { ok: false, message: problem };
+            }
             const id = ctx.draft("review", { task: read.snapshot.task, taskTitle: read.snapshot.title, run: read.snapshot.run,
-                snapshot: read.snapshot, operation, note, path, line, notes });
+                snapshot: read.snapshot, operation, note, path, line, notes, image });
             return id === null ? tooMany() : { ok: true, body: { proposal: id, kind: "review", awaiting: "confirmation", operation } };
         },
     },
@@ -1497,7 +1522,8 @@ const LEAD_TOOL_HANDLERS = {
             const integrations = list.map(one => ({
                 name: one.name, kind: one.group, state: STATE_WORDS[one.state], account: one.account, detail: one.detail, usedBy: one.usedBy,
                 lastSuccessAt: one.lastSuccessAt, lastError: one.lastError,
-                next: one.action.kind === "setup" ? "Not set up: open Settings → Integrations to set it up" : one.action.kind === "fix" ? `Fix: ${one.action.words}` : null,
+                next: one.action.kind === "setup" ? "Not set up: open Settings → Integrations to set it up" : one.action.kind === "fix" ? `Fix: ${one.action.words}`
+                    : one.action.kind === "switch" ? (one.action.words !== null ? `Fix: ${one.action.words}` : one.action.on ? "Turned off: turn it on in Settings → Integrations" : null) : null,
             }));
             return { ok: true, body: { integrations, settings: "show_control integrations opens Settings → Integrations; never invent a link" } };
         },

package/dist/lead.d.ts

@@ -38,6 +38,8 @@ export type LeadTurnInput = {
      * visible thread so a task-scoped composer still reads like a normal
      * conversation. */
     context?: string;
+    /** Exact image from the transport record of the message being answered. */
+    replyImage?: import("./result-review.js").FeedbackImage;
     fetcher?: typeof fetch;
     /** Injected by tests; production invokes the isolated local harness. */
     subscriptionRunner?: SubscriptionLeadRunner;

package/dist/lead.js

@@ -110,7 +110,7 @@ function settleBy(work, ms) {
     const late = new Promise(resolve => { timer = setTimeout(() => resolve(LATE), Math.max(0, ms)); });
     return Promise.race([work, late]).finally(() => clearTimeout(timer));
 }
-const READ_TOOLS = new Set(["get_brief", "get_project_context", "get_actions", "get_action_status", "get_skills", "get_acceptance_evidence", "recap", "list_repos", "list_tasks", "get_task", "get_result", "get_result_images", "get_controls", "get_agents", "get_project_knowledge", "get_task_conversation", "get_diff", "get_check_log", "get_project_tools", "get_flows", "get_flow_insights", "list_decisions", "get_decision", "queue"]);
+const READ_TOOLS = new Set(["get_brief", "get_project_context", "get_project_activity", "get_actions", "get_action_status", "get_skills", "get_acceptance_evidence", "recap", "list_repos", "list_tasks", "get_task", "get_result", "get_result_images", "get_controls", "get_agents", "get_project_knowledge", "get_task_conversation", "get_diff", "get_check_log", "get_project_tools", "get_flows", "get_flow_insights", "list_decisions", "get_decision", "queue"]);
 /** The last messages of the thread as provider-neutral history, newest kept first until the byte cap. */
 export function historyFor(store, thread, queuedMessageId, named = queuedMessageId !== undefined) {
     // Admitted messages only (v128): a queued message — this one, a teammate's, or one removed while waiting — never
@@ -205,7 +205,7 @@ export async function runLeadTurn(input) {
         return refuse("thread-closed");
     if (liveSession.ceilingDigest !== who.ceilingDigest || liveThread.ceilingDigest !== who.ceilingDigest)
         return refuse("ceiling-changed");
-    const digest = createHash("sha256").update(JSON.stringify([thread.id, message, input.context ?? null])).digest("hex");
+    const digest = createHash("sha256").update(JSON.stringify([thread.id, message, input.context ?? null, ...(input.replyImage === undefined ? [] : [input.replyImage])])).digest("hex");
     const receipt = request === undefined ? null : store.leadRequestReceipt(session.id, request);
     if (receipt !== null)
         return receipt.digest === digest ? { ok: true, replayed: true, turn: receipt.turn } : refuse("request-changed");
@@ -568,7 +568,7 @@ export async function runLeadTurn(input) {
             // caller of executeLeadTool): the model learns the road (find_tools, then the next step) and the reply goes on.
             const outcome = !advertisedNames.has(call.name)
                 ? { ok: false, message: `${call.name} isn't available in this step. Call find_tools with what you want to do; tools it finds can be called from your next step.` }
-                : executeLeadTool({ store, who, now: clock(), draft, selectEvidence, step: steps, readDecisions, readResults, searchedMemory, checkedCapabilities, ask, findTools, ...(input.integrations === undefined ? {} : { integrations: input.integrations }), thread: thread.id, turn: turnId, ...(promiseChannelOfTurn(input.channel) === undefined ? {} : { channel: promiseChannelOfTurn(input.channel) }), ...(input.evidenceRoot === undefined ? {} : { evidenceRoot: input.evidenceRoot }), ...(input.mediaDelivery === undefined ? {} : { mediaDelivery: input.mediaDelivery }) }, call.name, call.args, view);
+                : executeLeadTool({ store, who, now: clock(), draft, selectEvidence, ...(input.replyImage === undefined ? {} : { replyImage: input.replyImage }), step: steps, readDecisions, readResults, searchedMemory, checkedCapabilities, ask, findTools, ...(input.integrations === undefined ? {} : { integrations: input.integrations }), thread: thread.id, turn: turnId, ...(promiseChannelOfTurn(input.channel) === undefined ? {} : { channel: promiseChannelOfTurn(input.channel) }), ...(input.evidenceRoot === undefined ? {} : { evidenceRoot: input.evidenceRoot }), ...(input.mediaDelivery === undefined ? {} : { mediaDelivery: input.mediaDelivery }) }, call.name, call.args, view);
             let displayOutcome = { state: "succeeded" };
             if (!outcome.ok) {
                 const reason = leadToolFailureReason(call.name, outcome.message);

package/dist/operate.d.ts

@@ -99,7 +99,7 @@ export type OperateOptions = {
     /** Injected by tests: how the console looks at project folders off its thread (folder-look.ts). */
     folderLook?: FolderLookOptions;
 };
-export type OnboardSeams = Partial<Pick<OnboardIo, "home" | "env" | "cwd" | "interactive" | "confirm" | "findRepo" | "checkConnection" | "pullRequests">>;
+export type OnboardSeams = Partial<Pick<OnboardIo, "home" | "env" | "cwd" | "interactive" | "confirm" | "findRepo" | "checkConnection" | "pullRequests" | "youiyoux">>;
 export declare const OPERATE_HELP: string;
 /** Parsed flags, with the positionals left over. */
 type Args = {
@@ -237,7 +237,6 @@ type Context = {
 export declare function writeLoginFileDurably(path: string, name: string, password: string): void;
 /** The platform browser opener — detached, silent, never load-bearing. */
 export declare function openBrowser(url: string): void;
-export declare function readUpConsoleUrl(dir: string): string | null;
 /**
  * The people allowed to agree to a scope.
  *

package/dist/operate.js

@@ -54,6 +54,7 @@ import { packageVersion, startMonitoring, targetOf } from "./monitoring.js";
 import { origin, readMonitoring } from "./monitoring-settings.js";
 import { logEvent } from "./log.js";
 import { FLOW_EVERY_MS, flowHousekeeping, moveCards, moveCardsAfter } from "./flow-cadence.js";
+import { NO_YOUIYOUX_PASS, youiyouxOnboardLine } from "./youiyoux-intake.js";
 import { readHooksBase, scheduleFromWords } from "./flow-triggers.js";
 import { sendSubagentSummaries } from "./subagent-admin.js";
 import { runRequestedUndos, sendSubagentWeeklies } from "./subagent-week.js";
@@ -227,7 +228,7 @@ import { isTaskSize, legOf, projectRoute, routeDigestOf, routeWords, TASK_SIZES,
 import { observeProviderReadiness, reportProviderReadinessAuthed } from "./runner.js";
 import { parseDemoUrl, projectDemoUrl, saveProjectDemo } from "./project-demo.js";
 import { effectiveConcurrency, maySlotTake, parseProjectConcurrency, PROJECT_CONCURRENCY_DEFAULT, ProjectPasses, projectConcurrency, saveProjectConcurrency, savedProjectConcurrency } from "./project-concurrency.js";
-import { activeWebhookTargets, webhookPass, LEGACY_WEBHOOK_WARNING, loadWebhookTargets, effectivePrimary, isMessagingChannel, loadConsoleUrl, phoneOrigin, saveConsoleUrl, savePrimary } from "./webhooks.js";
+import { activeWebhookTargets, webhookPass, LEGACY_WEBHOOK_WARNING, loadWebhookTargets, effectivePrimary, isMessagingChannel, loadConsoleUrl, phoneOrigin, readUpConsoleUrl, saveConsoleUrl, savePrimary, UP_CONSOLE_FILE } from "./webhooks.js";
 import { auditOf, inspectionOf, isProviderId, MONEY_CAPABILITIES, PROVIDER_IDS, validModelId, validateSpec, ALL_CREDENTIAL_ENV } from "./provider.js";
 import { attestProvider, attestationOf, versionInRange } from "./attest.js";
 import { build, proveApprovedProfile, } from "./builder.js";
@@ -278,6 +279,7 @@ export const OPERATE_HELP = `toolroll — operating the queue
                                         wait for this attempt to finish or need a person
   toolroll project use <path>        remember a saved project (optional --token-file)
   toolroll project show              show the current project and credential reference
+  toolroll project activity --json   read the current project supervision report
   toolroll project rules --repo <p>  a project's approval rules; an instance operator changes them with
                                         --not-requester on|off, --protect none|project, --protect-paths "a/**,b/**"
   toolroll project network --repo <p> [--allow h,…] [--remove h,…] [--open|--allowlist] [--local any|none]
@@ -2259,6 +2261,7 @@ function flowIoOf(context, pool, git, base) {
             dir: context.flowStepIo?.dir ?? dir, scratch: context.flowStepIo?.scratch ?? join(pool, "flow-checks"), base,
             ...(context.evidenceRoot === undefined ? {} : { evidenceRoot: context.evidenceRoot }) },
         ...(context.evidenceRoot === undefined ? {} : { evidenceRoot: context.evidenceRoot }),
+        youiyouxGit: gitOf(context.gitRunner),
     };
 }
 /**
@@ -3384,8 +3387,10 @@ async function tickCommand(flags, context) {
         syncAssignmentHandoffs(store, clock(), auth.runner.repos, context.evidenceRoot);
     settleFinished();
     const replied = replyPass.taken > 0 || replyPass.problem !== null;
-    const flows = flowPass.moved + flowPass.filed.length + flowPass.problems.length + triggerPass.added + triggerPass.problems.length + stepPass.ran + stepPass.problems.length === 0 && !replied ? {} : { flows: { ...flowPass,
-            ...(triggerPass.added + triggerPass.problems.length === 0 ? {} : { triggers: triggerPass }), ...(stepPass.ran + stepPass.problems.length === 0 ? {} : { steps: stepPass }), ...(replied ? { replies: replyPass } : {}) } };
+    const requestPass = housekeeping?.youiyoux ?? NO_YOUIYOUX_PASS;
+    const requested = requestPass.filed + requestPass.copied + requestPass.decided + requestPass.problems.length > 0;
+    const flows = flowPass.moved + flowPass.filed.length + flowPass.problems.length + triggerPass.added + triggerPass.problems.length + stepPass.ran + stepPass.problems.length === 0 && !replied && !requested ? {} : { flows: { ...flowPass,
+            ...(triggerPass.added + triggerPass.problems.length === 0 ? {} : { triggers: triggerPass }), ...(requested ? { youiyoux: requestPass } : {}), ...(stepPass.ran + stepPass.problems.length === 0 ? {} : { steps: stepPass }), ...(replied ? { replies: replyPass } : {}) } };
     const summary = () => {
         const lines = [`Considered ${considered}, built ${built}, parked ${parked}, broke ${broke}.`];
         for (const entry of dispatched) {
@@ -6396,7 +6401,7 @@ async function runWatchLoop(args) {
                 base = head.stdout.trim();
             }
             const pass = await flowHousekeeping(store, repo, context.clock, flowIoOf(context, flowPool, flowGit, base), admissionStopped);
-            flowsDid(pass.flows.moved + pass.triggers.added + pass.steps.ran + pass.replies.taken, pass.flows.filed.length, `flow pass — ${pass.triggers.added} card(s) added, ${pass.replies.taken} reply(ies) taken, ${pass.steps.ran} step(s) run, ${pass.flows.moved} moved`);
+            flowsDid(pass.flows.moved + pass.triggers.added + pass.steps.ran + pass.replies.taken, pass.flows.filed.length + pass.youiyoux.filed, `flow pass — ${pass.triggers.added} card(s) added, ${pass.youiyoux.filed} youiyoux request(s) filed, ${pass.replies.taken} reply(ies) taken, ${pass.steps.ran} step(s) run, ${pass.flows.moved} moved`);
         },
     });
     const modelWatch = startMaintenance({
@@ -6936,8 +6941,6 @@ export function openBrowser(url) {
         // A browser that will not open is a URL the greeting already printed.
     }
 }
-/** Where `up` last served its console, kept beside the database so `onboard` names the same address. */
-const UP_CONSOLE_FILE = "up-console.json";
 function recordUpConsoleUrl(dir, url, now) {
     try {
         const file = join(dir, UP_CONSOLE_FILE), temporary = `${file}.${process.pid}.tmp`;
@@ -6948,15 +6951,6 @@ function recordUpConsoleUrl(dir, url, now) {
         // A display fact: a failed write only leaves onboard on the default port.
     }
 }
-export function readUpConsoleUrl(dir) {
-    try {
-        const parsed = JSON.parse(readFileSync(join(dir, UP_CONSOLE_FILE), "utf8"));
-        return typeof parsed.url === "string" && /^https?:\/\/[^\s]+$/.test(parsed.url) ? parsed.url.replace(/\/+$/, "") : null;
-    }
-    catch {
-        return null;
-    }
-}
 /** How onboard says to sign in: the saved login file only while it still works (as `up` advertises it), else the
  * account and its password; null only when there is no account yet. Never the password itself. */
 function onboardLogin(store, loginFile) {
@@ -7041,6 +7035,8 @@ async function onboardCommand(flags, context) {
                 return `off: ${checked.message}`;
             return `off: turn on with toolroll publish setup --repo ${repo} --yes (asks your password), or in Settings → Projects`;
         }),
+        // A project that uses youiyoux has its change requests filed as tasks with no step of its own (youiyoux-intake.ts).
+        youiyoux: seams.youiyoux ?? (async (repo) => youiyouxOnboardLine(store, repo)),
         starterFlag: text(flags, "starter"),
         // Starter flows belong to a person: the flow's decisions ask them. With no account yet, none can be switched on.
         starters: {

package/dist/project-activity.d.ts

@@ -0,0 +1,20 @@
+/** Shared presentation for browser and no-script Activity; facts come only
+ * from projectOutcomes. No alternate counting or status interpretation. */
+import type { ActivityFamily, ProjectOutcomes } from './project-outcomes.js';
+export declare const activityAge: (ms: number | null) => string;
+export declare const activityMoney: (usd: number | null) => string;
+export declare const ACTIVITY_ACTORS: {
+    human: string;
+    lead: string;
+    landed: string;
+    'machine-or-unknown': string;
+};
+export type ActivityMetric = {
+    label: string;
+    value: string;
+    detail: string;
+    rows: ActivityFamily[];
+};
+export declare const activityScope: (report: ProjectOutcomes) => string;
+export declare const activityLimit: (report: ProjectOutcomes) => string;
+export declare function activityMetrics(report: ProjectOutcomes): ActivityMetric[];