toolroll 0.9.56 → 0.9.58

package/dist/remote-exec.js

@@ -14,11 +14,12 @@ import { envelopeJson } from './envelope.js';
 import { COMMAND_GUIDE } from './surface.js';
 import { centralProfile, UsageError } from './team-cli.js';
 import { CLI_FILES_BYTES, CLI_WAIT_SECONDS } from './cli-http.js';
+import { TOKEN_REPLACEMENT } from './password-bearer.js';
 import { contractRow, fileArguments, STEP_UP_MESSAGE } from './remote-command.js';
 export { contractRow, STEP_UP_MESSAGE } from './remote-command.js';
 const EXIT = { ok: 0, failed: 1, usage: 2, refused: 3 };
-/** Team commands own their own central path (team-cli.ts). */
-const TEAM_COMMANDS = new Set(['connect', 'lead', 'conversation', 'chat', 'brief']);
+/** Team commands own their own central path (team-cli.ts); `session` sends its own checked request (session-cli.ts). */
+const TEAM_COMMANDS = new Set(['connect', 'lead', 'conversation', 'chat', 'brief', 'session']);
 const RESPONSE_BYTES = 16 * 1024 * 1024;
 const REQUEST_TIMEOUT_MS = (CLI_WAIT_SECONDS + 35) * 1_000;
 async function bounded(response) {
@@ -45,7 +46,7 @@ async function bounded(response) {
     return JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(Buffer.concat(chunks)));
 }
 /** One request, never retried. */
-async function post(origin, token, request, options) {
+export async function postCli(origin, token, request, options) {
     try {
         const timeout = AbortSignal.timeout(REQUEST_TIMEOUT_MS);
         const response = await (options.fetch ?? fetch)(`${origin}/api/cli`, {
@@ -152,7 +153,7 @@ export async function maybeRunRemoteCommand(argv, options = {}) {
     if (profile === null || !profile.apiToken) {
         if (!explicit)
             return null;
-        return refuse('usage', 'This profile has no API token. Connect again with your so_ token (toolroll connect <origin> --token-stdin).', EXIT.usage);
+        return refuse('usage', `This profile has no API token. ${TOKEN_REPLACEMENT}, then connect again with it (toolroll connect <origin> --token-stdin).`, EXIT.usage);
     }
     if (row === null || mode === 'no') {
         return refuse('usage', `${command} runs only on this computer. Drop --profile to run it here.`, EXIT.usage);
@@ -192,7 +193,7 @@ export async function maybeRunRemoteCommand(argv, options = {}) {
     };
     if (row?.invocation === 'task wait')
         return waitRemotely(sent, files, profile, options, deliver);
-    return deliver(await post(profile.origin, profile.token, { argv: sent, files }, options));
+    return deliver(await postCli(profile.origin, profile.token, { argv: sent, files }, options));
 }
 /**
  * `task wait` holds the server for at most CLI_WAIT_SECONDS per request; the client keeps asking within the caller's
@@ -203,7 +204,7 @@ async function waitRemotely(argv, files, profile, options, deliver) {
     const given = at < 0 ? null : Number(argv[at + 1]);
     const base = at < 0 ? argv : argv.filter((_one, index) => index !== at && index !== at + 1);
     if (given !== null && (!Number.isFinite(given) || given < 0))
-        return deliver(await post(profile.origin, profile.token, { argv, files }, options));
+        return deliver(await postCli(profile.origin, profile.token, { argv, files }, options));
     const json = base.includes('--json');
     const probe = json ? base : [...base, '--json'];
     const started = Date.now();
@@ -212,7 +213,7 @@ async function waitRemotely(argv, files, profile, options, deliver) {
     while (true) {
         const remaining = given === null ? CLI_WAIT_SECONDS : Math.max(0, given - (Date.now() - started) / 1_000);
         const slice = Math.min(CLI_WAIT_SECONDS, Math.floor(remaining * 1_000) / 1_000);
-        const outcome = await post(profile.origin, profile.token, { argv: [...probe, '--timeout', String(slice)], files }, options);
+        const outcome = await postCli(profile.origin, profile.token, { argv: [...probe, '--timeout', String(slice)], files }, options);
         if (outcome.kind !== 'answer')
             return deliver(outcome);
         let reason;
@@ -227,7 +228,7 @@ async function waitRemotely(argv, files, profile, options, deliver) {
             if (json)
                 return deliver(outcome);
             // Settled (or out of time): the server renders the final answer in the person's own format.
-            return deliver(await post(profile.origin, profile.token, { argv: [...base, '--timeout', '0'], files }, options));
+            return deliver(await postCli(profile.origin, profile.token, { argv: [...base, '--timeout', '0'], files }, options));
         }
         if (signal.aborted)
             return deliver(outcome);

package/dist/request-budget.d.ts

@@ -1,6 +1,6 @@
 /**
  * Request budgets for person API tokens (v112): how many requests one `so_` token may make across all accepting routes.
- * One budget per token, keyed by its api_token row id (never the secret, its name or an address), shared by those
+ * One budget per token, keyed by its credential row id (a person's API token, v118) (never the secret, its name or an address), shared by those
  * routes. A read token gets 120 requests in any sliding minute, an act token 30, and either 10,000 in a rolling day;
  * an instance operator may override any of these for the installation or for one token in the console (step-up).
  *

package/dist/scope.js

@@ -5,7 +5,8 @@ import { validateScopeText } from "./task-text.js";
 import { AsyncLocalStorage } from "node:async_hooks";
 import { projectAuthority } from "./project-access.js";
 import { activeRemote } from "./remote-run.js";
-import { claimActor, currentActor, parseLeadToken } from "./actor.js";
+import { claimActor, currentActor } from "./actor.js";
+import { parseLeadToken } from "./api-tokens.js";
 /**
  * What a task is allowed to become, agreed before anything builds it.
  *

package/dist/serve.js

@@ -16,6 +16,7 @@ import { MOBILE_VIEWPORT_SCRIPT } from "./mobile-viewport.js";
 import { projectAuthority } from "./project-access.js";
 import { discoverTools, projectToolsOf, secretsSetFor, TOOL_CATALOG } from "./project-tools.js";
 import { isEdgeAddress, refuseEdge } from "./server/edge-refusal.js";
+import { announcePasswordBearer, isPasswordBearer, PASSWORD_BEARER_REFUSED, passwordBearerAccepted } from "./password-bearer.js";
 import { createSharedGuards } from "./server/guards.js";
 import { createHandlerRegistry } from "./server/handler-registry.js";
 import {} from "./server/remote-hooks.js";
@@ -606,6 +607,17 @@ export function createDecisionServer(options) {
         const matchedRoute = matchRoute(method, hook.pathname);
         const edgeRoute = matchedRoute?.stage === 'edge' ? matchedRoute : null;
         const wrongMethodEdge = edgeRoute === null ? ROUTES.find(row => row.stage === 'edge' && new RegExp(row.pattern).test(hook.pathname)) ?? null : null;
+        // D7: a password on a request still signs in this release, announced on every answer and named in every refusal;
+        // from the release that removes it, it is refused here before anything checks it.
+        if (isPasswordBearer(request.headers.authorization)) {
+            if (!(options.passwordBearerAccepted ?? passwordBearerAccepted())) {
+                request.resume();
+                return hook.pathname.startsWith('/api/')
+                    ? respond(response, 401, 'application/json; charset=utf-8', JSON.stringify({ ...(hook.pathname.startsWith('/api/team') ? { version: 1 } : {}), ok: false, code: 'password-bearer-refused', message: PASSWORD_BEARER_REFUSED }))
+                    : respond(response, 401, 'text/plain; charset=utf-8', PASSWORD_BEARER_REFUSED);
+            }
+            announcePasswordBearer(response);
+        }
         if (edgeRoute?.host === 'before')
             return dispatchEdge(edgeRoute, { url: hook, who: null, request, response, method });
         if (wrongMethodEdge?.host === 'before')
@@ -667,6 +679,9 @@ export function createDecisionServer(options) {
         if (edgeRoute?.domain === 'people')
             return provenPasswordAccount.run(passwordProof, () => dispatchEdge(edgeRoute, { url, who, request, response, method }));
         if (who === null) {
+            // A password on a request that did not sign in is a machine's refusal, never a login page.
+            if (isPasswordBearer(request.headers.authorization))
+                return respond(response, 401, "text/plain; charset=utf-8", "authenticate first");
             // A GET to an exact task or result (a phone's deep link) signs in and
             // comes back to it — the destination is a same-site path only.
             return method === "GET"

package/dist/server/chat.js

@@ -40,7 +40,7 @@ import { refuse, screen } from "./chrome.js";
 import { chatResultHref, chatReturnWithLatest, chatReturnWithSaid, projectChatHref, redirect, respond, safeChatReturn, safeReturn, taskChatHref, taskHref } from "./http.js";
 import { chatAckPage, chatPage, coordinatorProposalsSection, decisionsFor, leadAfterComposerHtml, leadChatVersion, leadMintCard, leadPage, leadThreadHtml, PHONE_CARD_FACT, TASK_COMPOSER_MODES, taskChatLiveRegion, teamProposalCardParts } from "./render-chat.js";
 import {} from "./render-pages.js";
-import { completionForm, homePhaseWords, owedAcceptanceOf, resultPanelHtml } from "./render-results.js";
+import { completionForm, hardBlockerOf, homePhaseWords, owedAcceptanceOf, resultPanelHtml } from "./render-results.js";
 import { browserCaller, oneLineUa } from "./session.js";
 export function createChatHandlers(runtime) {
     const { firstRunStepsNow, managedRepos, leadWords, store, options, phoneSetup, visible, liveTurns, leadSaid, evidenceRoot, clock, sessions, CHAT_CANDIDATE_TTL_MS, chatFetcher, CHAT_CANDIDATES_PER_APPROVER, chatCeilingDigest, workAccess, familyOf, firstTasks, leadPrincipal, taskChatFocus, chatScopeOf, leadConversationRows, demoLeadHere, sendScreen, chromeFor, teamBrowserReply, team, teamChatProvider, runVisible, runIsLive, resultDetailOf, pullRequestTargetOf, chatEnablement, startLeadConversation, projectFamilyPeek, needsYouBadge, liveRefreshSeconds, chatKeyFor, chatCatalog, providerHome, mintApprovalNonce, checkLocalAgents, agentSignInCommand, bustBadge, authenticateApprover, revisionDestination, armTaskResume, consumeApprovalNonce } = runtime;
@@ -185,7 +185,9 @@ export function createChatHandlers(runtime) {
         const roomId = url.searchParams.get('conversation');
         const resultLink = (href) => roomId ? href + '&conversation=' + encodeURIComponent(roomId) : href;
         // Accept and finish is here: the one act that accepts the person's own checks and finishes the task.
-        const finishes = resultRun !== null && who.role === 'approver' && focusTask?.assignment?.state === 'ready-to-check' && focusTask.assignment.receipt?.runId === resultRun.id;
+        // Never offered where Complete is refused whatever is accepted (a failed check, a HIGH finding).
+        const finishes = resultRun !== null && who.role === 'approver' && focusTask?.assignment?.state === 'ready-to-check' && focusTask.assignment.receipt?.runId === resultRun.id &&
+            hardBlockerOf(focusTask.assignment) === null;
         const resultPanel = resultRun === null
             ? null
             : html `${resultPanelHtml(resultDetailOf(resultRun, who, now), {
@@ -267,7 +269,7 @@ export function createChatHandlers(runtime) {
         if (repos.length > 0) {
             try {
                 fleetSnapshot = store.chatSnapshot(repos, now);
-                const summaries = workIndexPage(store, now, { principal: 'operator', repos, includeUnplaced: false, viewer: who.name }, { limit: 100 }).items;
+                const summaries = workIndexPage(store, now, { principal: 'operator', repos, includeUnplaced: false, viewer: who.name }, { limit: 100, root: evidenceRoot }).items;
                 fleetSnapshot.assignmentStates = Object.fromEntries(summaries.flatMap(value => [value.rootId, value.activeTaskId].map(id => [id, { state: value.assignmentState, label: value.status.label, detail: value.status.detail }])));
                 fleetSnapshot.attentionCount = needsYouBadge(null);
             }
@@ -1291,9 +1293,9 @@ export function createChatHandlers(runtime) {
                 agent: `${providerName(run.provider)} on ${run.runner}`, phase: homePhaseWords(run), project: run.repo === null ? null : projectName(run.repo), since: run.startedAt,
                 activity: runActivityOf(store, run, now) };
         });
-        const all = workIndexPage(store, now, access, { view: "all", limit: WORK_INDEX_MAX_LIMIT });
-        const needs = workIndexPage(store, now, access, { view: "needs-you", limit: WORK_INDEX_MAX_LIMIT });
-        const done = workIndexPage(store, now, access, { view: "completed", limit: WORK_INDEX_MAX_LIMIT });
+        const all = workIndexPage(store, now, access, { view: "all", limit: WORK_INDEX_MAX_LIMIT, root: evidenceRoot });
+        const needs = workIndexPage(store, now, access, { view: "needs-you", limit: WORK_INDEX_MAX_LIMIT, root: evidenceRoot });
+        const done = workIndexPage(store, now, access, { view: "completed", limit: WORK_INDEX_MAX_LIMIT, root: evidenceRoot });
         const weekAgo = new Date(now.getTime() - 7 * 86_400_000).toISOString();
         const counts = [
             { key: "working", label: "Working now", value: agents.length, href: "/work?view=running" },

package/dist/server/edge-refusal.d.ts

@@ -1,5 +1,7 @@
 import type { IncomingMessage, ServerResponse } from 'node:http';
 import { type RouteDeclaration } from './route-table.js';
+/** What a request to the retired /api/sessions transport hears (D7). */
+export declare const SESSIONS_MOVED: string;
 export declare function isEdgeAddress(path: string): boolean;
 /** Preserve each transport's refusal envelope without invoking an undeclared adapter. */
 export declare function refuseEdge(request: IncomingMessage, response: ServerResponse, path: string, declared: RouteDeclaration | null): void;

package/dist/server/edge-refusal.js

@@ -1,5 +1,7 @@
-import { sessionDescriptor } from '../session-contract.js';
+import { TOKEN_REPLACEMENT } from '../password-bearer.js';
 import { ROUTES } from './route-table.js';
+/** What a request to the retired /api/sessions transport hears (D7). */
+export const SESSIONS_MOVED = `Session operations moved to /api/cli. Update toolroll, ${TOKEN_REPLACEMENT.charAt(0).toLowerCase()}${TOKEN_REPLACEMENT.slice(1)}, connect with it, and run toolroll session <operation>.`;
 export function isEdgeAddress(path) {
     return ROUTES.some(row => row.stage === 'edge' && new RegExp(row.pattern).test(path))
         || /^\/(?:oauth|hooks|api\/(?:sessions|team|cli))(?:\/|$)/.test(path)
@@ -15,13 +17,13 @@ export function refuseEdge(request, response, path, declared) {
         type = 'application/json';
         body = JSON.stringify({ jsonrpc: '2.0', id: null, error: { code: -32000, message: 'the MCP gateway takes POST only — one JSON-RPC message per request' } });
     }
-    else if (path.startsWith('/api/sessions/')) {
-        const spec = sessionDescriptor(path.split('/')[3] ?? '');
+    else if (path === '/api/sessions' || path.startsWith('/api/sessions/')) {
+        // D7: session operations moved to /api/cli. An older client hears that nothing was sent, and what to use instead.
+        response.statusCode = 404;
         type = 'application/json';
         response.setHeader('X-Toolroll-Delivery', 'not-sent');
-        if (spec)
-            response.setHeader('allow', 'POST');
-        body = JSON.stringify({ version: 1, ...(spec ? { operation: spec.operation } : {}), ok: false, status: 'rejected', delivery: 'not-sent', retry: spec?.mutation === false ? 'safe-read' : 'never', reason: spec ? 'method-not-allowed' : 'unsupported-operation', message: spec ? 'Session operations require POST.' : 'This session operation is not supported.', nextActions: [] });
+        response.setHeader('X-Standing-Orders-Session-Delivery', 'not-sent');
+        body = JSON.stringify({ version: 1, ok: false, status: 'rejected', delivery: 'not-sent', retry: 'never', reason: 'moved', message: SESSIONS_MOVED, nextActions: [] });
     }
     else if (path === '/api/cli' || path.startsWith('/api/team')) {
         type = 'application/json';

package/dist/server/guards.js

@@ -2,7 +2,7 @@ import { OWNER_ACTIONS, sharedActionPayload } from '../chat-actions.js';
 import { CONSOLE_FORMS, readForm } from "../contracts/console-api.js";
 import { timingSafeEqual } from "node:crypto";
 import {} from "node:http";
-import { parseApiToken, secretMatches, tokenLive, tokenProjects } from "../api-tokens.js";
+import { tokenLive, tokenProjects } from "../api-tokens.js";
 import { oauthProjects, oauthTokenAllowed } from "../mcp-oauth.js";
 import { REMOTE_MESSAGES, reproveRemote } from "../operate-remote.js";
 import { canonicalProject, rowVisible } from "../project.js";
@@ -264,9 +264,10 @@ export function createSharedGuards(runtime) {
             const source = runtime.joinSourceOf(request), at = Date.now();
             if (runtime.signInBudget.waitFor(source, at) > 0)
                 return null;
-            const parsed = parseApiToken(presented);
-            const kept = parsed === null ? null : runtime.store.apiTokenSecret(parsed.id);
-            if (parsed === null || kept === null || !secretMatches(parsed.secret, kept.secretHash)) {
+            // The one credential check (api-tokens.ts): only a person's API token signs in here.
+            const found = runtime.store.presentedCredential(presented);
+            const kept = found?.kind === "person" ? runtime.store.apiTokenSecret(found.id) : null;
+            if (kept === null) {
                 runtime.signInBudget.failed(source, at);
                 return null;
             }

package/dist/server/http.d.ts

@@ -43,6 +43,8 @@ export type ServeOptions = {
     cliRunner?: RunOperateAs;
     /** Tests: remote command metadata until the shared contract declares it. */
     cliModeOf?: CliHttpOptions['modeOf'];
+    /** Tests: whether a password on a request is still accepted (default: this release's version, password-bearer.ts). */
+    passwordBearerAccepted?: boolean;
     /** Tests: the clock request budgets for API tokens count by (request-budget.ts). */
     requestBudgetClock?: () => number;
     /** Where repos.json lives — every enrollment locks exactly this file. */

package/dist/server/remote.js

@@ -9,7 +9,7 @@ import { reproveRemote } from "../operate-remote.js";
 import { rowVisible } from "../project.js";
 import { RequestBudget, SourceAdmission } from "../request-budget.js";
 import { authenticateAccount } from "../scope.js";
-import { createSessionEndpoint } from '../session-server.js';
+import { createSessionRunner } from '../session-remote.js';
 import {} from "../store.js";
 import { handleTeamHttp, TEAM_PASSWORD_REVERIFY_MS } from '../team-http.js';
 import { handleTeamsHttp } from "../teams.js";
@@ -97,16 +97,17 @@ export function createRemoteHandlers(runtime) {
             return who?.via === 'cookie' ? teamBrowserReply(reply, actor, who.session.csrf) : reply;
         },
     });
+    // D7: native session operations are remote commands too (`session …` over /api/cli), run by the session owner.
+    const sessionRunner = createSessionRunner({ store, workspace: coding, projects: codingProjects, projectAllowed: repo => rowVisible(liveCeiling(), repo), clock });
     // Remote CLI: one live API token names the person; the shared command boundary decides everything else.
     const cliEndpoint = (request, response) => handleCliHttp(request, response, {
         admit: principal => requestBudget.admit(principal.tokenId, "api"),
         authenticate: tokenPrincipalOf,
         run: async () => options.cliRunner ?? (await import("../operate.js")).runOperateAs ?? null,
         modeOf: options.cliModeOf,
+        session: sessionRunner,
         store,
     });
-    const sessionEndpoint = createSessionEndpoint({ store, workspace: coding, projects: codingProjects, projectAllowed: repo => rowVisible(liveCeiling(), repo),
-        admit: admitPasswordSource, admitAuthenticated: admitBearer });
     const mcpHttp = createMcpHttp({ store, clock, evidenceRoot, ...(options.requestBudgetClock === undefined ? {} : { requestBudgetClock: options.requestBudgetClock }), signedIn: request => identify(request, true, true) !== null, admit: person => requestBudget.admit(person.principal.tokenId, "mcp"),
         resourceMetadata: request => { const origin = consoleOrigin(request.headers.host); return origin === null ? null : resourceMetadataUrl(origin); },
         enrolled: () => [...new Set([...managedRepos(), ...store.listProjects().map(project => project.path)])], ...(options.runOperateAs === undefined ? {} : { runAs: options.runOperateAs }) });
@@ -138,8 +139,8 @@ export function createRemoteHandlers(runtime) {
             return;
         return respond(response, 404, 'text/plain; charset=utf-8', 'No such address.');
     };
-    // D5: native coding sessions and the central team service are deprecated (still served this release); each
-    // answer says so in a Deprecation header (RFC 9745).
+    // D5: the central team service is deprecated (still served this release); each answer says so in a Deprecation
+    // header (RFC 9745).
     // Each protocol adapter keeps its own operation boundary; every row still names its own entry.
     const registrations = handlersOf("remote", {}, {
         "edge.telegram-hook": async ({ request, response }) => { await telegramHook(hookContext, request, response); },
@@ -152,14 +153,6 @@ export function createRemoteHandlers(runtime) {
         "edge.oauth-token": async ({ request, response, url }) => { await oauthHttp(request, response, url); },
         "edge.oauth-authorize": async ({ request, response, url }) => { await oauthHttp(request, response, url); },
         "edge.oauth-consent": async ({ request, response, url }) => { await oauthHttp(request, response, url); },
-        "edge.sessions-list": async ({ request, response }) => { response.setHeader('Deprecation', 'true'); await sessionEndpoint(request, response); },
-        "edge.sessions-show": async ({ request, response }) => { response.setHeader('Deprecation', 'true'); await sessionEndpoint(request, response); },
-        "edge.sessions-changes": async ({ request, response }) => { response.setHeader('Deprecation', 'true'); await sessionEndpoint(request, response); },
-        "edge.sessions-start": async ({ request, response }) => { response.setHeader('Deprecation', 'true'); await sessionEndpoint(request, response); },
-        "edge.sessions-send": async ({ request, response }) => { response.setHeader('Deprecation', 'true'); await sessionEndpoint(request, response); },
-        "edge.sessions-stop": async ({ request, response }) => { response.setHeader('Deprecation', 'true'); await sessionEndpoint(request, response); },
-        "edge.sessions-resume": async ({ request, response }) => { response.setHeader('Deprecation', 'true'); await sessionEndpoint(request, response); },
-        "edge.sessions-recover": async ({ request, response }) => { response.setHeader('Deprecation', 'true'); await sessionEndpoint(request, response); },
         "edge.team-read": async ({ request, response }) => { response.setHeader('Deprecation', 'true'); await teamEndpoint(request, response); },
         "edge.team-send": async ({ request, response }) => { response.setHeader('Deprecation', 'true'); await teamEndpoint(request, response); },
         "edge.cli": async ({ request, response }) => { await cliEndpoint(request, response); },

package/dist/server/render-results.d.ts

@@ -12,7 +12,7 @@ import { type BuildReviewView } from "../review-switch.js";
 import { type AcceptanceCriterion, type approvalOf } from "../scope.js";
 import { type ReportItem } from "../scout-report.js";
 import { type Artifact, type DiffComment, type Publication, type RepairChainRow, type ReviewRetryState, type Run, type Store, type TaskState } from "../store.js";
-import { type PullRequestFact, type TaskStatus } from "../task-status.js";
+import { type ReleaseState, type PullRequestFact, type TaskStatus } from "../task-status.js";
 import { type DisplayStatus, type PublicationFacts, type ReviewFacts } from "../workspace-ui.js";
 import { type Chrome, type Screen } from "./chrome.js";
 import { type Html } from "../html.js";
@@ -78,6 +78,7 @@ export declare function criterionMatrixHtml(matrix: readonly CriterionMatrixRow[
     links?: EvidenceLinkMap;
     fileAnchors?: ReadonlyMap<string, string>;
     verdict?: string | null;
+    release?: ReleaseState | undefined;
 }): Html;
 /** One policy summary beneath the requirements. Per-requirement concerns
  * are already visible in the matrix; do not repeat their full text here. */
@@ -674,6 +675,8 @@ export declare const CHECK_EXCERPT_LINES = 12;
  * change's first file, labelled as not cited), the screenshots it cites
  * (none cited: every validated one), and the agent's own note. */
 export declare function personCheckItems(proof: ProofBundleView, patchText: string | null, shots: readonly ResultScreenshot[], runId: number): BrowserCheckItem[];
+/** The completion blocker no acceptance resolves (a failed check, an unresolved HIGH finding), in words, or null. */
+export declare function hardBlockerOf(assignment: AssignmentSnapshot | null | undefined): string | null;
 /** A Needs you result's one action (needs-you.ts): a link to the act that resolves it, or Confirm it
  * stopped behind the password. Null under every other headline. */
 export declare function needActionOf(assignment: AssignmentSnapshot | null, status: TaskStatus | null, csrf: string, returnTo: string, result?: {

package/dist/server/render-results.js

@@ -21,7 +21,7 @@ import {} from "../scope.js";
 import { parseReport } from "../scout-report.js";
 import {} from "../store.js";
 import { runCostWords } from "../summary.js";
-import { demoChecksOf, pullRequestFactOf, requirementsOf, requirementWordOf, STATUS_MORE, statusDetailsHtml, statusIconSvg, statusWhyHtml } from "../task-status.js";
+import { checkBackingOf, CHECKED_AT_RELEASE, demoChecksOf, pullRequestFactOf, requirementsOf, requirementWordOf, STATUS_MORE, statusDetailsHtml, statusIconSvg, statusWhyHtml } from "../task-status.js";
 import { ACCEPT_NEEDS_REASON, acceptWordsOf, cantAcceptYetOf, evidenceProblemOf, MISMATCH_HEADLINE, receiptHeadingOf, receiptPublicationWords, reportMismatchesOf, RESULT_DECISION_SENTENCE, resultHeadlineOf, resultStatusOf, REVIEW_TOKENS } from "../workspace-ui.js";
 import { createHash, randomBytes } from "node:crypto";
 import { buildsViews, oneLineOf, projectChip, safePrUrl, screen, sentenceCase, strokeIcon, when, whenTime } from "./chrome.js";
@@ -173,13 +173,14 @@ export function criterionMatrixHtml(matrix, options = {}) {
         const confirmed = row.assessment !== undefined && state === "pass";
         // Plain words (task-status brief): the retired assessment step is not a state a person acts on.
         // The card's Requirements row reads the same words from the same source (task-status.ts), so they agree.
-        const label = requirementWordOf(row, options.verdict);
+        const label = requirementWordOf(row, options.verdict, options.release);
         const cls = label === "Met" ? "badge-done" : label === "You check" ? "badge-manual-review" : "badge-note";
         const warnings = [];
         // Only replace the known boilerplate. Other recorded failure details
         // remain verbatim, so concision cannot hide a different problem.
         const detail = row.detail.filter(line => !(row.assessment && row.review && line === `${row.review.author} ${row.review.judgement === "contradicts" ? "contradicts" : "needs more evidence for"} criterion "${row.id}": ${row.review.note}`) && !(state === "manual-review" && /^criterion "[^"\n]+" requires manual-review evidence — an operator must accept it before this can verify$/.test(line)));
-        if (!awaitingAssessment && state !== "pass" && detail.length > 0)
+        // A requirement a release check covers, or that waits only on one, has nothing wrong to say.
+        if (!awaitingAssessment && state !== "pass" && label !== "Met" && label !== CHECKED_AT_RELEASE && detail.length > 0)
             warnings.push(html `<ul class="requirement-issues">${detail.map(line => html `<li>${line}</li>`)}</ul>`);
         const review = row.review;
         if (review !== null && review.judgement !== "upholds") {
@@ -671,13 +672,16 @@ export function reviewCockpitDetailParts(view, csrf, noted, canRetryReview, tab,
         action: false,
     });
     parts.push(html `<div id="verification" data-cockpit-section="result">${panel.html}</div>`);
-    const blocked = cantAcceptYetOf(proof?.verdict ?? null, proof?.reasons ?? [], accepted);
+    // What no acceptance resolves (a failed check, a HIGH finding): Complete is refused, so no Accept is offered and
+    // the one line says the next step.
+    const hardStop = hardBlockerOf(assignment);
+    const blocked = hardStop ?? cantAcceptYetOf(proof?.verdict ?? null, proof?.reasons ?? [], accepted);
     const youCheck = panel.panel.youCheck;
     // Accept and finish posts the completion; when an acceptance is owed (the person's own checks, or a reason a
     // report that doesn't match its changes asks for), the same request records it first.
     const owed = accepted ? null : youCheck?.accept != null ? { note: null } : panel.panel.need?.accept != null ? { note: panel.panel.need.accept.note }
         : blocked === ACCEPT_NEEDS_REASON ? { note: "Why is this safe to accept?" } : null;
-    const complete = assignment?.state === "ready-to-check" && assignment.receipt !== null && canRetryReview && csrf !== ""
+    const complete = hardStop === null && assignment?.state === "ready-to-check" && assignment.receipt !== null && canRetryReview && csrf !== ""
         ? { action: `${taskHref(view.taskId)}/complete`, receipt: assignment.receipt.digest, run: run.id, accept: owed } : null;
     if (complete !== null)
         parts.push(completionForm(view.taskId, run.id, complete.receipt, view.detail?.pullRequestTo ?? null, owed));
@@ -686,8 +690,10 @@ export function reviewCockpitDetailParts(view, csrf, noted, canRetryReview, tab,
     const matrix = proof === null || proof.proofProblem !== null ? [] : proof.matrix;
     const unanswered = accepted || youCheck == null ? [] : youCheck.items.length > 0 ? youCheck.items.map(one => one.statement === "" ? one.words : one.statement) : youCheck.lines;
     const base = !acceptsHere ? null : acceptWordsOf({
-        checks: checks === undefined ? null : checks.running != null ? "running" : checks.level === "off" && checks.status !== "passed" ? "off" : checks.status,
-        unmet: matrix.filter(row => row.state !== "pass" && row.state !== "manual-review").length,
+        // Checks Off that a release check already covers read as passed (release-coverage.ts).
+        checks: checks === undefined ? null : checks.running != null ? "running" : checks.level === "off" && checks.status !== "passed" ? checks.release != null ? "passed" : "off" : checks.status,
+        // Release-aware words (task-status.ts): a requirement waiting only on a release check, or covered by one, isn't unmet.
+        unmet: matrix.filter(row => !["Met", "You check", CHECKED_AT_RELEASE].includes(requirementWordOf(row, null, checks === undefined ? undefined : checkBackingOf(checks)))).length,
         action: complete !== null ? "complete" : "accept",
         publishing: view.detail?.publishing ?? "other",
         proof: proof !== null && proof.proof !== null && proof.proofProblem === null,
@@ -700,7 +706,7 @@ export function reviewCockpitDetailParts(view, csrf, noted, canRetryReview, tab,
     const followUps = view.detail.followUps ?? null;
     const checksRunning = checks?.running != null || (followUps?.checks.some(one => one.state === "waiting" || one.state === "running") ?? false);
     const runChecks = canRetryReview && csrf !== "" && followUps !== null && (followUps.full || followUps.quick) && !checksRunning &&
-        (checks === undefined || checks.status === "not-run" || checks.status === "unavailable")
+        (checks === undefined || ((checks.status === "not-run" || checks.status === "unavailable") && checks.release == null))
         // Back on this result's Checks tab, where #follow-ups shows the run it started.
         ? { action: `/r/${run.id}/checks`, level: followUps.full ? "full" : "quick", returnTo: `${here}&run=${run.id}&tab=checks` } : null;
     const need = panel.panel.need;
@@ -1774,7 +1780,8 @@ export function resultPanelParts(detail, o) {
             checkParts.push(detail.signedCriteria > 0 ? html `<p class="meta">The approved scope has ${detail.signedCriteria} requirement${detail.signedCriteria === 1 ? "" : "s"}, but this build has no requirement-by-requirement verification.</p>` : html `<p class="meta">This scope signed no acceptance checks.</p>`);
         }
         else {
-            checkParts.push(criterionMatrixHtml(proof.matrix, { runId, links: proof.matrixLinks, fileAnchors: detail.fileAnchors, verdict: proof.verdict }));
+            checkParts.push(criterionMatrixHtml(proof.matrix, { runId, links: proof.matrixLinks, fileAnchors: detail.fileAnchors, verdict: proof.verdict,
+                release: current?.receipt == null ? undefined : checkBackingOf(current.receipt.checks) }));
         }
         checkParts.push(semanticCoverageHtml(proof.matrix, proof.qualityMode));
         if (reviewConflict(proof.matrix, proof.machineVerdict, proof.verdict))
@@ -1930,11 +1937,18 @@ export function personCheckItems(proof, patchText, shots, runId) {
         };
     });
 }
+/** The completion blocker no acceptance resolves (a failed check, an unresolved HIGH finding), in words, or null. */
+export function hardBlockerOf(assignment) {
+    return assignment?.readiness?.blockers.find(one => one.key === "check-failed" || one.key === "high")?.message ?? null;
+}
 /** A Needs you result's one action (needs-you.ts): a link to the act that resolves it, or Confirm it
  * stopped behind the password. Null under every other headline. */
 export function needActionOf(assignment, status, csrf, returnTo, result) {
     if (assignment === null || status === null || status.headline !== "Needs you" || status.need == null)
         return null;
+    // Accepting can't resolve it: Request changes is the way on, beside the reason.
+    if (result !== undefined && hardBlockerOf(assignment) !== null)
+        return null;
     const action = assignment.primaryAction;
     const rebuild = { href: null, confirm: null, rebuild: { action: `${taskHref(assignment.rootId)}/requeue` } };
     // Built to an earlier plan: Build again, in place (the task page's requeue).

package/dist/server/route-table.js

@@ -79,9 +79,6 @@ edge("remote", "edge.oauth-authorize", "GET,HEAD", "/oauth/authorize");
 edge("remote", "edge.oauth-consent", "POST", "/oauth/authorize", { callers: ["cookie"], scope: "step-up", viewer: true, proof: "adapter" });
 edge("settings", "edge.google-callback", "GET", "/settings/google/callback", { callers: ["service"], proof: "adapter" });
 edge("settings", "edge.connect-callback", "GET", "/settings/tools/connected", { callers: ["service"], proof: "adapter" });
-for (const operation of ["list", "show", "changes", "start", "send", "stop", "resume", "recover"]) {
-    edge("remote", `edge.sessions-${operation}`, "POST", `/api/sessions/${operation}`, { callers: ["bearer"], scope: ["list", "show", "changes"].includes(operation) ? "read" : "act", project: "adapter", proof: "adapter" });
-}
 edge("remote", "edge.team-read", "GET", "/api/team", { callers: ["cookie", "bearer"], scope: "read", project: "adapter", proof: "adapter" });
 edge("remote", "edge.team-send", "POST", "/api/team", { callers: ["cookie", "bearer"], scope: "read", project: "adapter", proof: "adapter" });
 edge("remote", "edge.cli", "POST", "/api/cli", { callers: ["bearer"], scope: "read", project: "adapter", proof: "adapter" });

package/dist/server/tasks.js

@@ -165,8 +165,8 @@ export function createTasksHandlers(runtime) {
             // Console v2: results ready to review and work running now, from the same admitted work index.
             ...(() => {
                 const row = (one) => ({ taskId: one.rootId, title: one.title, detail: one.status.detail, repo: one.repo });
-                const needsYou = workIndexPage(store, now, workAccess(), { view: "needs-you", limit: 40, project });
-                const runningNow = workIndexPage(store, now, workAccess(), { view: "running", limit: 40, project });
+                const needsYou = workIndexPage(store, now, workAccess(), { view: "needs-you", limit: 40, project, root: evidenceRoot });
+                const runningNow = workIndexPage(store, now, workAccess(), { view: "running", limit: 40, project, root: evidenceRoot });
                 return { ready: needsYou.items.filter(one => one.assignmentState === "ready-to-check").map(row), running: runningNow.items.map(row) };
             })(),
         };
@@ -195,7 +195,7 @@ export function createTasksHandlers(runtime) {
         const rollup = project === null && !unscopedMode;
         let work;
         try {
-            work = workIndexPage(store, now, workAccess(), { view, limit: 40, cursor: url.searchParams.get('cursor'), project });
+            work = workIndexPage(store, now, workAccess(), { view, limit: 40, cursor: url.searchParams.get('cursor'), project, root: evidenceRoot });
             const facts = requestContext.getStore();
             if (facts !== undefined) {
                 // These counts cover the exact admitted project lens, including
@@ -1382,7 +1382,7 @@ export function createTasksHandlers(runtime) {
         // CI repair, suggestion-first (M8.18): a red episode never spawns an
         // agent by itself — it EARNS a button, and the button creates one
         // unapproved task through the same revision machinery as review
-        // comments. Deterministic id = one draft per task/PR, ever.
+        // comments. One draft per task/PR, ever: the merge blocker records it.
         const id = Number(draftRepair[1]);
         const found = store.getRun(id);
         if (found === null || !visible(taskRepoOf(found.taskRef))) {
@@ -1401,10 +1401,6 @@ export function createTasksHandlers(runtime) {
         // failure was SEEN on and when (audit C-2) — a PR that advanced since
         // is a different failure, and the click time is not an observation.
         const episode = store.latestOpenCiEpisode(publication.githubRepo, publication.prNumber);
-        // Suffixes survive truncation (audit C-7): the prefix gives way, the
-        // identity-bearing tail never does.
-        const suffix = `-ci-${publication.prNumber}`;
-        const draftId = `${sourceTaskId.slice(0, 64 - suffix.length)}${suffix}`;
         const brief = {
             schema: 1,
             kind: "ci-repair",
@@ -1425,25 +1421,32 @@ export function createTasksHandlers(runtime) {
         // repair use (contract handoff task 2): the inherited terms come from
         // the source rows inside the seal; the scope read above only names
         // the digest this draft was composed against.
-        const sealed = store.sealRevision({
-            source: { task: sourceTaskId, run: id, scopeDigest: sourceScope?.digest ?? null },
-            brief: { evidenceRoot, key, sha256: createHash("sha256").update(briefBytes).digest("hex"), bytes: briefBytes.length, capture: "machine-authored ci-repair brief (exit 0)" },
-            child: {
-                id: draftId,
-                title: `repair ${sourceTaskId}: CI failing on PR #${publication.prNumber}`,
-                repair: `repair the failing CI on PR #${publication.prNumber} (failing head ${(episode?.headSha ?? publication.headSha).slice(0, 12)}). ` +
-                    `Read the failing checks on GitHub before approving; this draft carries no log content.`,
-            },
-            commentIds: null,
-            requestedBy: who.name,
-        }, now);
+        // One draft per task/PR, ever: the PR's merge blocker names it, lifted or not, and is written in the seal's transaction.
+        const sealed = store.transact(() => {
+            const prior = store.raw().prepare("SELECT task_id FROM merge_blocker WHERE publication = ? AND task_id IS NOT NULL ORDER BY rowid LIMIT 1").get(publication.id);
+            if (prior !== undefined)
+                return { ok: false, reason: "duplicate", detail: String(prior["task_id"]) };
+            const result = store.sealRevision({
+                source: { task: sourceTaskId, run: id, scopeDigest: sourceScope?.digest ?? null },
+                brief: { evidenceRoot, key, sha256: createHash("sha256").update(briefBytes).digest("hex"), bytes: briefBytes.length, capture: "machine-authored ci-repair brief (exit 0)" },
+                child: {
+                    title: `repair ${sourceTaskId}: CI failing on PR #${publication.prNumber}`,
+                    repair: `repair the failing CI on PR #${publication.prNumber} (failing head ${(episode?.headSha ?? publication.headSha).slice(0, 12)}). ` +
+                        `Read the failing checks on GitHub before approving; this draft carries no log content.`,
+                },
+                commentIds: null,
+                requestedBy: who.name,
+            }, now);
+            // The merge blocker rides the SAME breath as the draft (merge grant,
+            // findings 3/12/13): while this repair exists, the source PR merges
+            // NOTHING — sticky until the operator's unblock act or the PR closes.
+            if (result.ok)
+                store.createMergeBlocker(publication.id, result.id, now);
+            return result;
+        });
         if (!sealed.ok) {
-            return refuse(response, who, sealed.reason === "duplicate" ? 409 : sealed.reason === "stale-source" || sealed.reason === "comments-taken" ? 409 : 400, sealed.reason === "duplicate" ? `already drafted as ${draftId}` : `could not draft: ${sealed.detail}`, `/r/${id}`);
+            return refuse(response, who, sealed.reason === "duplicate" ? 409 : sealed.reason === "stale-source" || sealed.reason === "comments-taken" ? 409 : 400, sealed.reason === "duplicate" ? `already drafted as ${sealed.detail}` : `could not draft: ${sealed.detail}`, `/r/${id}`);
         }
-        // The merge blocker rides the SAME breath as the draft (merge grant,
-        // findings 3/12/13): while this repair exists, the source PR merges
-        // NOTHING — sticky until the operator's unblock act or the PR closes.
-        store.createMergeBlocker(publication.id, sealed.id, now);
         return redirect(response, taskHref(sealed.id));
     }
     async function resolveIncident(ctx) {

package/dist/session-cli.d.ts

@@ -1,13 +1,42 @@
-import { type SessionDescriptor, type SessionOperation } from './session-contract.js';
-export type SessionCliOptions = {
-    fetch?: typeof fetch;
-    env?: NodeJS.ProcessEnv;
+import { type SessionDescriptor, type SessionRequest, type SessionResponse } from './session-contract.js';
+import { type TeamCliOptions } from './team-cli.js';
+/**
+ * `toolroll session …` (D7): native session operations run on the central server over `POST /api/cli`, signed in with
+ * the API token `toolroll connect` saved, like every other remote command. The client checks and sends the exact
+ * request; the server (session-remote.ts) runs it through the existing session owner and answers one session envelope.
+ */
+export type SessionCliOptions = TeamCliOptions & {
     readStdin?: () => Promise<string>;
     stderr?: (line: string) => void;
 };
-export declare const SESSION_CLI_ACTIONS: readonly ["capabilities", ...SessionOperation[]];
-export declare function sessionCliFlags(spec: SessionDescriptor): Record<string, 'value' | 'flag'>;
-/** Credentials are never sent to a URL with embedded authority, an API path,
- * query, fragment or an insecure remote host. Fetch cannot follow redirects. */
-export declare function sessionServiceOrigin(raw: string): string;
+/** The files key the prompt travels under: the server reads no paths, only what the request carries. */
+export declare const SESSION_PROMPT_FILE = "prompt";
+export declare const SESSION_CLI_ACTIONS: readonly ["capabilities", ...import("./session-contract.js").SessionOperation[]];
+export declare const SESSION_TOKEN_REQUIRED = "Session commands use your saved API token. Create an API token with `toolroll tokens create`, then save it with `toolroll connect <origin> --as <account> --token-stdin`.";
+/** The flags an operation takes: on this computer (where the prompt may come from a file or stdin, and a saved
+ * profile is chosen), or on the server (where the prompt is only ever the request's own file). */
+export declare function sessionCliFlags(spec: SessionDescriptor, side?: 'client' | 'server'): Record<string, 'value' | 'flag'>;
+export type SessionArguments = {
+    spec: SessionDescriptor;
+    flags: Record<string, string | true>;
+    positionals: string[];
+};
+/** One parser for both sides of /api/cli: `<operation> [<session-id>] --flag value …`. */
+export declare function parseSessionArguments(argv: readonly string[], side: 'client' | 'server'): SessionArguments | {
+    problem: string;
+};
+/** The validated request the parsed arguments and prompt spell. */
+export declare function sessionRequestOf({ spec, flags, positionals }: SessionArguments, prompt: string | undefined): {
+    ok: true;
+    request: SessionRequest;
+} | {
+    ok: false;
+    message: string;
+};
+/** The exact argv the server runs for a validated request: always --json, the prompt as the request's one file. */
+export declare function sessionArgv(spec: SessionDescriptor, request: SessionRequest): string[];
+/** The plain-text answer, the same on either side of the transport. */
+export declare function renderSessionResponse(response: SessionResponse): string;
+/** 0 delivered · 1 unknown (inspect first) · 3 refused. */
+export declare const sessionExitCode: (response: SessionResponse) => number;
 export declare function runSessionCommand(argv: readonly string[], write: (line: string) => void, options?: SessionCliOptions): Promise<number>;