toolroll 0.9.12 → 0.9.14

package/dist/task-status.js

@@ -114,7 +114,9 @@ function detailsOf(headline, facts) {
             row("pull-request", "Pull request", `${name} open`, "none", { href: github });
     }
     const req = facts.requirements;
-    if (req != null && req.total > 0) {
+    if (req != null && req.total > 0 && req.unverified === true)
+        row("requirements", "Requirements", "Unverified", "none");
+    else if (req != null && req.total > 0) {
         const unmet = req.total - req.met - req.yours;
         const text = `${req.met} of ${req.total} met${req.yours > 0 ? ` · You check ${req.yours}` : ""}`;
         row("requirements", "Requirements", text, unmet > 0 ? problem(headline) : req.met === req.total ? "ok" : "none", unmet > 0 && headline !== "Failed" ? { action: { label: "See which", href: facts.links?.checks ?? facts.links?.result ?? null } } : {});
@@ -264,6 +266,10 @@ export function requirementsOf(matrix) {
     const met = (row) => row.state === "pass" || (row.assessment?.evidenceState === "pass" && (row.review ?? null) === null);
     return { met: matrix.filter(met).length, total: matrix.length, yours: matrix.filter(row => !met(row) && row.state === "manual-review").length };
 }
+/** A refuted report verifies none of its requirements, whatever it marked met (a person's acceptance doesn't change that). */
+export function unverifiedWhenRefuted(requirements, verdict) {
+    return requirements === null || verdict !== "refuted" ? requirements : { ...requirements, unverified: true };
+}
 /** Saved evidence health from the receipt's artifact list and its caveats. */
 export function evidenceOf(receipt, problems = receipt?.caveats ?? []) {
     if (receipt === null)
@@ -297,7 +303,7 @@ export function assignmentStatusFacts(assignment, options = {}) {
         stage, ...(need === undefined ? {} : { need }), ...(wait === undefined ? {} : { wait }), ...(build === null ? {} : { needContext: { build } }), reason, report,
         checks,
         pullRequest: withResult ? pullRequest : null,
-        requirements: withResult ? requirementsOf(receipt?.proof?.matrix) : null,
+        requirements: withResult ? unverifiedWhenRefuted(requirementsOf(receipt?.proof?.matrix), receipt?.proof?.verdict) : null,
         evidence: withResult ? options.evidence ?? evidenceOf(receipt, [...(receipt?.caveats ?? []), ...assignment.attention]) : null,
         completedBy: assignment.completion === null ? null : assignment.completion.lead === true ? "the lead" : assignment.completion.actor.replace(/^(?:operator|coordinator|lead):/, ""),
         action: options.action ?? null,

package/dist/telegram-progress.js

@@ -7,7 +7,7 @@
 import { assignmentOf } from "./assignment.js";
 import { chatResultHref, chatControlHref } from "./chat-controls.js";
 import { phoneText, projectLabel } from "./telegram-status.js";
-import { assignmentStatusFacts, headlineEmoji, pullRequestFactOf, requirementsOf, statusDetailLines, taskStatusOf } from "./task-status.js";
+import { assignmentStatusFacts, headlineEmoji, pullRequestFactOf, requirementsOf, statusDetailLines, unverifiedWhenRefuted, taskStatusOf } from "./task-status.js";
 import { leadClaimOf } from "./lead-voice.js";
 import { chatTitle } from "./chat-voice.js";
 import { manualReviewOnly } from "./proof.js";
@@ -49,7 +49,7 @@ export function telegramProgressCard(store, run, taskId, project, now = new Date
             : exit !== null ? { status: "failed", exitCode: exit, head: run.headRevision }
                 : machine === "verified" ? { status: "passed", exitCode: null, head: run.headRevision }
                     : machine === "attested" ? { status: "not-run", exitCode: null, head: null } : null;
-        facts = { stage: "finished", report: run.role === "scout", checks, requirements: requirementsOf(proof?.matrix),
+        facts = { stage: "finished", report: run.role === "scout", checks, requirements: unverifiedWhenRefuted(requirementsOf(proof?.matrix), proof?.verdict),
             ...(pullRequest === undefined ? {} : { pullRequest }) };
     }
     else if (accessBlocked) {

package/dist/test-temp.js

@@ -18,7 +18,7 @@ export const TEST_TEMP_PREFIXES = [
     "flow-goal-", "flow-scratch", "flows-chat-", "invoke-attest-", "knowledge-test-", "learning-", "peek-", "phone-origin-",
     "proposal-repo-", "race-", "refresh-migration-", "refresh-refusal-", "release-check-", "shared-chat-", "skills-test-",
     "task-status-surfaces-", "template-repo-", "template-test-", "v14-migrate-", "v17-migrate-", "watch-anchor-",
-    "needs-you-", "deps-lock-", "deps-state-", "upgrade-fresh-", "upgrade-path-", "deploy-restore-", "result-review-",
+    "needs-you-", "deps-lock-", "deps-state-", "upgrade-fresh-", "upgrade-path-", "deploy-restore-", "result-review-", "one-result-page-",
     // Playwright's browser profiles and artifacts.
     "playwright_chromiumdev_profile-", "playwright_firefoxdev_profile-", "playwright-artifacts-",
 ];

package/dist/work-index.js

@@ -11,7 +11,7 @@ import { plainReasonOf, replacedWords, stageOfCode, taskStatusOf, workToneOf } f
 import { isCheckLevel } from './check-levels.js';
 import { MARKER } from './worktree.js';
 import { withFollowUps } from './result-follow-ups.js';
-import { ASKS, NEED_ASK, NEEDS, processNeedOf } from './needs-you.js';
+import { ASKS, NEED_ASK, NEEDS, failedAttemptSentence, processNeedOf } from './needs-you.js';
 import { LEAD_CLAIM_SQL, LEAD_IDLE_MS } from './lead-voice.js';
 export const WORK_INDEX_PAGE_LIMIT = 40;
 export const WORK_INDEX_MAX_LIMIT = 100;
@@ -369,7 +369,7 @@ export function workIndexPage(store, now, access, options = {}) {
     'running_count',running_count,'completed_count',completed_count,'queued',queued,'done_recently',done_recently)) FROM project_totals) row_json FROM totals
   UNION ALL SELECT 1,0,0,0,0,0,0,0,0,0,json_object('root_ref',root_ref,'root_id',root_id,'id',id,'root_title',root_title,'repo',repo,
     'state',state,'created_at',created_at,'family_updated',family_updated,'version_count',version_count,'earlier_active',earlier_active,
-    'earlier_id',earlier_id,'broken',broken,'live_run',live_run,'result_id',page_result_id,'result_outcome',(SELECT outcome FROM run WHERE id=page_result_id),
+    'earlier_id',earlier_id,'broken',broken,'live_run',live_run,'result_id',page_result_id,'result_outcome',(SELECT outcome FROM run WHERE id=page_result_id),'attempt_reason',(SELECT substr(reason,1,1000) FROM run WHERE task_ref IN (SELECT ref_id FROM members WHERE root_ref=page.root_ref) AND (finished_at IS NOT NULL OR outcome IS NOT NULL) AND role NOT IN ('planner','reviewer') ORDER BY id DESC LIMIT 1),
     'publication_url',(SELECT pr_url FROM publication WHERE run=page_result_id),
     'result_role',(SELECT role FROM run WHERE id=page_result_id),'live_role',(SELECT role FROM run WHERE id=page.live_run),
     'check_status',(SELECT status FROM run_check WHERE run=page_result_id),
@@ -462,7 +462,7 @@ function itemOf(row, principal, probe) {
         'decision-queue': ['Needs your decision', 'The decision queue is full.', 'inspect-decisions', 'Review open questions'],
         'result-needs-attention': ['Needs your decision', 'Inspect the saved result and resolve its remaining execution or scope issue.', 'inspect-run', 'Inspect run'],
         'process-needs-attention': ['Needs your decision', 'A process exit is not recorded. Open the attempt to check whether its work has stopped.', 'inspect-run', 'Inspect run'],
-        failed: ['Needs your decision', 'The last attempt stopped; review its incident before retrying.', 'retry-task', 'Review and retry'],
+        failed: ['Needs your decision', 'The last attempt stopped.', 'retry-task', 'Review and retry'],
         'vanished-run': ['Needs your decision', 'An unfinished attempt has no current live claim.', 'reconcile-run', 'Check the unfinished attempt'],
         stopping: ['Needs your decision', 'Stopping. The work so far is kept.', 'inspect-stop', 'View stop details'],
         stopped: ['Needs your decision', 'Paused by a person. The work so far is kept.', 'resume-run', 'Review pause'],
@@ -502,6 +502,9 @@ function itemOf(row, principal, probe) {
     }
     if (code === 'terminal-dependency' && s(row, 'dependency_id') !== null)
         detail = `${s(row, 'dependency_id')} ${s(row, 'dependency_state') === 'cancelled' ? 'was cancelled' : 'failed'} before it finished.`;
+    // A failed task says the latest finished attempt across its whole family, whatever its outcome: its recorded reason, or that none was recorded.
+    if (code === 'failed')
+        detail = failedAttemptSentence(s(row, 'attempt_reason'));
     if (code === 'result-needs-attention' && n(row, 'custody_unresolved'))
         detail = 'A process exit is not recorded. Open the result to check whether its work has stopped.';
     if (code === 'result-needs-attention' && ['built', 'no-change'].includes(s(row, 'result_outcome') ?? '')) {

package/dist/workspace-ui.d.ts

@@ -17,6 +17,8 @@
  * claimed without one.
  */
 import type { DispatchDiagnosis } from "./dispatch.js";
+import { ACCEPT_NEEDS_REASON } from "./result-acts.js";
+export { ACCEPT_NEEDS_REASON };
 import { type ProofVerdict } from "./proof.js";
 import type { ReviewRetryState, TaskState } from "./store.js";
 import type { TaskControlView } from "./task-control.js";
@@ -190,6 +192,52 @@ export declare function dispatchActionLabel(dispatch: DispatchDiagnosis | null):
 /** A finished result's display status in the shared headline's words: a
  * failed project check is Failed, a result missing its record needs a
  * person, every other saved result is Ready for review. Token and action stay. */
+/** Why a result can't be accepted as it stands, in one plain line, or null
+ * when nothing refutes it (a person's acceptance settles it). The result page
+ * shows it before Request changes, its one ink act. */
+export declare function cantAcceptYetOf(verdict: ProofVerdict | null, reasons: readonly string[], accepted: boolean): string | null;
+/** The result's headline while its report disagrees with its saved changes. */
+export declare const MISMATCH_HEADLINE = "The report doesn't match the changes";
+/** One way the report disagrees with the saved changes, in plain words: the
+ * file and lines it concerns when they are in the saved changes, or
+ * `inChanges: false` for a file the report names that the changes don't have.
+ * `reason` is the recorded words it says plainly. */
+export type ReportMismatch = {
+    text: string;
+    path: string | null;
+    lines: {
+        from: number;
+        to: number;
+    } | null;
+    inChanges: boolean | null;
+    /** The report's own note (1-based) the disagreement is about, when it names one. */
+    note: number | null;
+    reason: string;
+};
+/** Each recorded way a refuted report disagrees with its saved changes, said
+ * plainly and tied to the changed lines it concerns. `changes` maps each
+ * changed file to the lines of its first change (null when it has no line
+ * changes, a binary file say). Presentation only: the verdict is unchanged. */
+export declare function reportMismatchesOf(reasons: readonly string[], criteria: readonly {
+    id: string;
+    statement: string;
+    answered: readonly {
+        kind: string;
+        ref: string;
+    }[];
+    state?: string;
+    detail?: readonly string[];
+}[], changes: ReadonlyMap<string, {
+    from: number;
+    to: number;
+} | null>): ReportMismatch[];
+/** The line a failing check ended on: the last line of its error output that
+ * names an error, else the last line it printed, with its 1-based number in
+ * the saved log. Null when the log printed nothing. */
+export declare function lastErrorLineOf(log: string): {
+    line: number;
+    text: string;
+} | null;
 /** The result page's own sentence when the decision is on it. */
 export declare const RESULT_DECISION_SENTENCE = "Review the change, then accept it or ask for changes.";
 /** What the result page's Accept says, from facts it already shows: the

package/dist/workspace-ui.js

@@ -16,7 +16,9 @@
  * observed" name observed publication records, and deployment is never
  * claimed without one.
  */
-import { GOAL_ASSESSMENT_PENDING, manualReviewOnly } from "./proof.js";
+import { ACCEPT_NEEDS_REASON } from "./result-acts.js";
+export { ACCEPT_NEEDS_REASON };
+import { GOAL_ASSESSMENT_PENDING, manualReviewOnly, plainReasonWords } from "./proof.js";
 import { plainReasonOf, stageOfCode, taskStatusOf, workToneOf } from "./task-status.js";
 export const WORK_VIEWS = [
     { key: "all", label: "All", hint: "Every task in view, most urgent first.", empty: "Nothing is in progress. Describe work in chat or add a task, and it appears here." },
@@ -189,9 +191,9 @@ function storedResultStatusOf(result, publication) {
             label: "Result saved, but its record does not match",
             // A structural refutation is settled before the approved check is
             // weighed, so it says nothing about whether that check passed.
-            detail: withPublication("What the agent reported doesn't match the changes it saved. This doesn't say whether the project check passed."),
+            detail: withPublication("What the agent reported doesn't match the changes it saved."),
             tone: "problem",
-            action: { label: "Open the record", kind: "open-review" },
+            action: { label: "Open the result", kind: "open-review" },
         };
     }
     if (result.verdict === "short" && humanReview) {
@@ -312,6 +314,96 @@ const VERIFIED_RESULT = new Set(["ready-to-review", "pr-opened", "merge-observed
 /** A finished result's display status in the shared headline's words: a
  * failed project check is Failed, a result missing its record needs a
  * person, every other saved result is Ready for review. Token and action stay. */
+/** Why a result can't be accepted as it stands, in one plain line, or null
+ * when nothing refutes it (a person's acceptance settles it). The result page
+ * shows it before Request changes, its one ink act. */
+export function cantAcceptYetOf(verdict, reasons, accepted) {
+    if (accepted || verdict !== "refuted")
+        return null;
+    // A mismatch is the status card's own headline; here only what accepting takes.
+    return evidenceProblemOf(verdict, reasons) === "checks-failed"
+        ? "Can't accept yet: the project's check failed on these changes."
+        : ACCEPT_NEEDS_REASON;
+}
+/** The result's headline while its report disagrees with its saved changes. */
+export const MISMATCH_HEADLINE = "The report doesn't match the changes";
+const OVERCLAIMED = /^claimed changed paths? not in the sealed diff: ([\s\S]+)$/;
+const RESTATED = /^criterion "([^"]+)" was signed as "[\s\S]*" and the proof restates it as "([\s\S]*)"$/;
+const CONTRADICTED_BY_CAVEAT = /^criterion "([^"]+)" is marked met, but caveat [0-9]+ admits an exception to it: ([\s\S]*)$/;
+const NOTE_NUMBER = /^caveat ([0-9]+) /;
+const CONTRADICTED_BY_REVIEW = /^(?:reviewer:)?[^\s"]+ contradicts criterion "([^"]+)": [\s\S]*$/i;
+/** Each recorded way a refuted report disagrees with its saved changes, said
+ * plainly and tied to the changed lines it concerns. `changes` maps each
+ * changed file to the lines of its first change (null when it has no line
+ * changes, a binary file say). Presentation only: the verdict is unchanged. */
+export function reportMismatchesOf(reasons, criteria, changes) {
+    const named = (id) => {
+        const statement = criteria.find(one => one.id === id)?.statement.trim() ?? "";
+        if (statement === "")
+            return `requirement ${id}`;
+        return `“${statement.length > 90 ? `${statement.slice(0, 90).replace(/\s+\S*$/, "")}…` : statement}”`;
+    };
+    // The first file the requirement cites that the saved changes have.
+    const place = (id) => {
+        const path = criteria.find(one => one.id === id)?.answered.find(ref => ref.kind === "changed-path" && changes.has(ref.ref))?.ref ?? null;
+        return path === null ? { path: null, lines: null, inChanges: null } : { path, lines: changes.get(path) ?? null, inChanges: true };
+    };
+    const rows = reasons.flatMap((reason) => {
+        const over = OVERCLAIMED.exec(reason);
+        if (over !== null)
+            return over[1].split(", ").map(path => ({ text: "The report says it changed", path, lines: null, inChanges: changes.has(path), note: null, reason }));
+        const restated = RESTATED.exec(reason);
+        if (restated !== null)
+            return [{ text: `The report rewords ${named(restated[1])} as “${restated[2]}”`, ...place(restated[1]), note: null, reason }];
+        const caveat = CONTRADICTED_BY_CAVEAT.exec(reason);
+        const note = /^criterion "[^"]+" is marked met, but caveat ([0-9]+) /.exec(reason)?.[1] ?? NOTE_NUMBER.exec(reason)?.[1] ?? null;
+        if (caveat !== null)
+            return [{ text: `The report marks ${named(caveat[1])} met, but its own note says: ${caveat[2]}`, ...place(caveat[1]), note: Number(note), reason }];
+        const review = CONTRADICTED_BY_REVIEW.exec(reason);
+        if (review !== null)
+            return [{ text: plainReasonWords(reason), ...place(review[1]), note: null, reason }];
+        const unsigned = UNSIGNED_NOTE.exec(reason);
+        if (unsigned !== null)
+            return [{ text: `The report's note ${unsigned[1]} is about ${unsigned[2]}, which isn't one of the signed requirements: ${unsigned[3]}`, path: null, lines: null, inChanges: null, note: Number(unsigned[1]), reason }];
+        if (FAILED_CHECK.test(reason))
+            return [];
+        return [{ text: sentenceOf(plainReasonWords(reason)), path: null, lines: null, inChanges: null, note: note === null ? null : Number(note), reason }];
+    });
+    // Evidence a requirement cites that doesn't hold, unless a reason above already says so.
+    const evidence = criteria.flatMap(one => one.state !== "failed" && one.state !== "missing" ? [] : (one.detail ?? [])
+        .filter(detail => !reasons.includes(detail) && !/is waiting for the final check|requires manual-review evidence|is marked met, but caveat|was signed as/.test(detail))
+        .map((detail) => {
+        const lead = [`criterion "${one.id}"'s `, `criterion "${one.id}" `].find(prefix => detail.startsWith(prefix));
+        const rest = lead === undefined ? detail : detail.slice(lead.length);
+        return { text: `${sentenceOf(named(one.id))}: ${rest}`, ...place(one.id), note: null, reason: detail };
+    }));
+    return [...rows, ...evidence];
+}
+const UNSIGNED_NOTE = /^caveat ([0-9]+) names ("[^"]*"(?:, "[^"]*")*), (?:a criterion the proof authored|which is no signed)[\s\S]*?: ([\s\S]*)$/;
+/** A sentence starts with a capital letter. */
+function sentenceOf(text) {
+    return text === "" ? text : `${text.charAt(0).toUpperCase()}${text.slice(1)}`;
+}
+/** The line a failing check ended on: the last line of its error output that
+ * names an error, else the last line it printed, with its 1-based number in
+ * the saved log. Null when the log printed nothing. */
+export function lastErrorLineOf(log) {
+    const lines = log.split("\n");
+    const printed = (text) => text.trim() !== "" && !/^\$ /.test(text) && !/^\(exit -?[0-9]+\)$/.test(text.trim()) && !/^--- (stdout|stderr) ---$/.test(text.trim());
+    const stderr = lines.findIndex(text => text.trim() === "--- stderr ---");
+    const pick = (from, to) => {
+        let last = null;
+        for (let index = to - 1; index >= from; index -= 1) {
+            if (!printed(lines[index]))
+                continue;
+            if (/error|fail|✗|✕|×|assert|exception|panic|cannot|not found/i.test(lines[index]))
+                return { line: index + 1, text: lines[index].trim() };
+            last ??= index;
+        }
+        return last === null ? null : { line: last + 1, text: lines[last].trim() };
+    };
+    return (stderr >= 0 ? pick(stderr + 1, lines.length) : null) ?? pick(0, stderr >= 0 ? stderr : lines.length);
+}
 /** The result page's own sentence when the decision is on it. */
 export const RESULT_DECISION_SENTENCE = "Review the change, then accept it or ask for changes.";
 export function acceptWordsOf(facts) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "toolroll",
-  "version": "0.9.12",
+  "version": "0.9.14",
   "description": "A control plane for unattended coding agents — queue tasks, walk away, come back to pull requests. Agents build in leased worktrees, never touch your default branch, and interrupt you only for decisions that need a human.",
   "directories": {
     "doc": "docs"