toolroll 0.9.45 → 0.9.47

package/dist/browser-workspace.d.ts

@@ -2,6 +2,7 @@
  * produced by the existing trusted server renderers, never by a model-supplied
  * fragment. These projections do not authenticate, mutate or grant authority. */
 import type { TeamSnapshot } from './team-contract.js';
+import type { RunActivity } from './activity-line.js';
 import type { BrandIconId } from './brand-icons.js';
 import type { AssignmentSnapshot } from './assignment.js';
 export { browserCrewFromIndex, browserWorkActionHref } from './browser-crew.js';
@@ -26,7 +27,12 @@ export type BrowserNavigationItem = {
     href: string;
     active: boolean;
     count?: number;
+    /** What the count covers, said aloud and on hover: "3 need you in shop". */
+    countLabel?: string;
 };
+/** The Tasks badge's words: the count and the projects it covers
+ * ("3 need you in shop", "1 needs you across all your projects"). */
+export declare function needsYouLabelOf(count: number, projectName: string | null, saturated?: boolean): string;
 export type BrowserChatLink = {
     kind: 'project' | 'task';
     title: string;
@@ -53,6 +59,8 @@ export type BrowserCrewItem = {
     detail?: string;
     /** "<name> is on it.": the person's own lead took it on, by the name they gave it. */
     lead?: string;
+    /** A running task: what its agent did last, and when. */
+    activity?: RunActivity;
 };
 export type BrowserMessage = {
     id: number;
@@ -419,6 +427,13 @@ export type BrowserTaskView = {
             action: BrowserLink | null;
         } | null;
     } | null;
+    /** What the agent did last on the live run, and when; the page words it against its own clock (activity-line.ts). */
+    activity?: RunActivity | null;
+    /** The task's live stream (/t/<id>/live): change nudges and who else has it open. Absent: the page reads on its beat. */
+    live?: {
+        href: string;
+        at: string | null;
+    } | null;
     /** Stop, on the Building card: the exact live build's stop form (posts its run id). */
     stop?: {
         action: string;
@@ -1166,6 +1181,8 @@ export type BrowserHomeAgent = {
     phase: string;
     project: string | null;
     since: string;
+    /** What the agent did last, and when. */
+    activity?: RunActivity;
 };
 export type BrowserHomeCount = {
     key: 'working' | 'waiting' | 'ready' | 'done';
@@ -1277,4 +1294,4 @@ export declare function browserProjectsOf(projects: readonly {
     name: string;
     path: string;
 }[]): BrowserProject[];
-export declare function browserNavigationOf(path: string, project?: string | null, needsYou?: number): BrowserNavigationItem[];
+export declare function browserNavigationOf(path: string, project?: string | null, needsYou?: number, tasksProject?: string | null, needsYouLabel?: string): BrowserNavigationItem[];

package/dist/browser-workspace.js

@@ -1,6 +1,12 @@
 import { browserCrewFromIndex } from './browser-crew.js';
 export { browserCrewFromIndex, browserWorkActionHref } from './browser-crew.js';
 import { workIndexPage } from './work-index.js';
+/** The Tasks badge's words: the count and the projects it covers
+ * ("3 need you in shop", "1 needs you across all your projects"). */
+export function needsYouLabelOf(count, projectName, saturated = false) {
+    const where = projectName === null ? 'across all your projects' : `in ${projectName}`;
+    return `${count}${saturated ? '+' : ''} ${count === 1 && !saturated ? 'needs' : 'need'} you ${where}`;
+}
 /** Safe inside a script[type=application/json] element. JSON escaping alone
  * does not stop the HTML parser from closing that element at </script>. */
 export function serializeBrowserWorkspace(workspace) {
@@ -31,14 +37,14 @@ export function browserProjectsOf(projects) {
                 knowledgeHref: `/settings/knowledge?repo=${encodeURIComponent(project.path)}` }];
     });
 }
-export function browserNavigationOf(path, project = null, needsYou = 0) {
+export function browserNavigationOf(path, project = null, needsYou = 0, tasksProject = project, needsYouLabel) {
     const pathname = path.split('?')[0].split('#')[0];
     const knowledge = pathname === '/settings/knowledge' || pathname.startsWith('/settings/knowledge/');
     return [
         { label: 'Chat', href: '/chat', active: pathname === '/chat' },
-        { label: 'Tasks', href: `/work${project === null ? '' : `?project=${encodeURIComponent(project)}`}`,
+        { label: 'Tasks', href: `/work${tasksProject === null ? '' : `?project=${encodeURIComponent(tasksProject)}`}`,
             active: pathname === '/work' || pathname === '/tasks' || pathname.startsWith('/t/') || pathname.startsWith('/r/'),
-            ...(needsYou > 0 ? { count: needsYou } : {}) },
+            ...(needsYou > 0 ? { count: needsYou, ...(needsYouLabel === undefined ? {} : { countLabel: needsYouLabel }) } : {}) },
         { label: 'Flows', href: '/flows', active: pathname === '/flows' || pathname.startsWith('/flows/') },
         { label: 'Projects', href: '/projects', active: pathname === '/projects' },
         { label: 'Knowledge', href: `/settings/knowledge${project === null ? '' : `?repo=${encodeURIComponent(project)}`}`, active: knowledge },

package/dist/builder.js

@@ -60,6 +60,7 @@ import { invokeAgent } from "./invoke.js";
 import { TELEGRAM_TOKEN_ENVS } from "./names.js";
 import { OPENROUTER_ENV_KEY, auditOf, ALL_CREDENTIAL_ENV } from "./provider.js";
 import { openLiveLog } from "./live.js";
+import { withRunActivity } from "./task-activity.js";
 import { CheckProgressTracker } from "./check-progress.js";
 import { captureParkEvidence, captureTerminalDiff, captureBaseTree, evidenceRoot, handoffName, isImagePath, WORKTREE_EVIDENCE_DIR, storeHandoffArtifact, looksLikeProtocolFile, mailboxName, progressFileName, proofFileName, rubricFileName, proposalFileName, quarantineMailboxes, readMailbox, readVerifiedArtifact, scanForSecrets, redactSecretLines, storeEvidence, validateScreenshotBytes, imageDimensions, SCREENSHOT_BYTE_CAP, boundStreamHeadTail } from "./evidence.js";
 import { PROOF_LIMITS, parseProof, serializeProof, adjudicate, artifactManifestOnly, sameDiffStatFacts } from "./proof.js";
@@ -1139,7 +1140,8 @@ export async function build(store, request) {
     // The live window (arc 1): display state beside the run, never evidence.
     // Every streaming transport emits events now (peek); a file that cannot
     // open is a null, and a null never costs a build.
-    const liveLog = openLiveLog(root, request.runId);
+    // What the agent did last rides the same stream into one row (live tasks).
+    const liveLog = withRunActivity(openLiveLog(root, request.runId), store, request.runId, clock);
     // The retry base (steering fix for run 1465's proof): the SAME pinned
     // base the machine will use to capture the sealed diff (settleProof
     // below, mirroring store.firstBuilderBase's own doc). Null on a first
@@ -1329,7 +1331,7 @@ export async function build(store, request) {
             omitEnv: AGENT_ENV_DENYLIST,
             ...(agent === undefined ? {} : { runner: agent }),
             ...(request.onProviderSpawn === undefined ? {} : { onSpawn: request.onProviderSpawn }),
-            ...(liveLog === null ? {} : { onStreamEvent: (event) => liveLog.observe(event) }),
+            onStreamEvent: (event) => liveLog.observe(event),
             // The receipt (finding 8): the stream proved the prompt reached the
             // agent — settle delivery NOW, durably, whatever happens to the run
             // later. The runner latches and isolates this callback; a throw

package/dist/cli-http.d.ts

@@ -2,6 +2,7 @@ import type { IncomingMessage, ServerResponse } from 'node:http';
 import type { Store } from './store.js';
 import type { Principal } from './operate.js';
 import { type RemoteCommandLookup } from './remote-command.js';
+import { type Admission, type BudgetLimit } from './request-budget.js';
 /**
  * `POST /api/cli` (remote CLI, Phase 1): a teammate's laptop sends the argv it would have run locally, and the central
  * server runs that same command as that person. There is no per-resource API here and no second policy: the transport
@@ -28,6 +29,8 @@ export type CliFailure = {
     ok: false;
     code: string;
     message: string;
+    limit?: BudgetLimit;
+    retryAfter?: number;
 };
 /** Inlined file contents, summed as UTF-8 bytes. */
 export declare const CLI_FILES_BYTES: number;
@@ -40,6 +43,8 @@ export type CliHttpOptions = {
     run: () => Promise<RunOperateAs | null>;
     /** Tests: command policy while the parallel command contract is not yet available. Defaults to COMMAND_GUIDE. */
     modeOf?: RemoteCommandLookup | undefined;
+    /** The token's request budget (request-budget.ts), charged once per request before its body is read. */
+    admit?: ((principal: Principal) => Admission) | undefined;
     store: Store;
 };
 /** Decode the request's shape and byte limits. The endpoint checks file references against its command policy. */

package/dist/cli-http.js

@@ -1,4 +1,5 @@
 import { contractRow, fileArguments, STEP_UP_MESSAGE } from './remote-command.js';
+import { limitWords } from './request-budget.js';
 /** Inlined file contents, summed as UTF-8 bytes. */
 export const CLI_FILES_BYTES = 256 * 1024;
 /** The whole JSON body: the files plus argv and JSON escaping headroom. */
@@ -6,10 +7,10 @@ export const CLI_REQUEST_BYTES = 2 * CLI_FILES_BYTES;
 const ARGV_MAX = 256;
 const ARG_BYTES = 16 * 1024;
 const FILES_MAX = 16;
-function send(response, status, value) {
+function send(response, status, value, headers = {}) {
     if (response.destroyed || response.writableEnded)
         return;
-    response.writeHead(status, { 'content-type': 'application/json; charset=utf-8', 'cache-control': 'no-store', 'x-content-type-options': 'nosniff' });
+    response.writeHead(status, { 'content-type': 'application/json; charset=utf-8', 'cache-control': 'no-store', 'x-content-type-options': 'nosniff', ...headers });
     response.end(JSON.stringify(value));
 }
 async function body(request) {
@@ -95,6 +96,15 @@ export async function handleCliHttp(request, response, options) {
     }
     if (!principal)
         return reject(401, 'unauthenticated', 'This API token is not valid (expired, revoked or its person removed).');
+    // Counted once here, however long the command then holds the request (a task wait is one request).
+    const admitted = options.admit === undefined ? { ok: true } : options.admit(principal);
+    if (!admitted.ok && admitted.status === 503)
+        return reject(503, 'limits-unavailable', 'Request limits could not be checked; nothing ran. Try again shortly.');
+    if (!admitted.ok) {
+        send(response, 429, { ok: false, code: 'rate-limited', message: limitWords(admitted.limit, admitted.retryAfter), limit: admitted.limit, retryAfter: admitted.retryAfter }, { 'retry-after': String(admitted.retryAfter) });
+        request.resume();
+        return true;
+    }
     let value;
     try {
         value = await body(request);

package/dist/cli.js

@@ -208,6 +208,7 @@ export const OPERATE_COMMANDS = new Set([
     "task",
     "project",
     "ledger",
+    "audit",
     "storage",
     "monitoring",
     "integrations",
@@ -254,7 +255,7 @@ export const OPERATE_COMMANDS = new Set([
     "run",
     "routine",
     "flows",
-    "config", "chat", "proposals", "mode", "chat-approval", "people", "keys",
+    "config", "chat", "proposals", "mode", "chat-approval", "people", "tokens", "keys",
     "setup",
     "verify",
     "intake",
@@ -304,6 +305,11 @@ export async function main(argv, write = line => console.log(line), mainOptions
         write("-o requires --json — the output file receives the machine envelope");
         return USAGE_EXIT;
     }
+    // A new API token is shown once, on screen: never saved to a file by the entry point.
+    if (outputFile !== undefined && args.find(one => !one.startsWith("-")) === "tokens") {
+        write("-o isn't used with tokens: a new token is shown once, never saved to a file");
+        return USAGE_EXIT;
+    }
     resetCapturedEnvelope();
     // Long-running commands (serve, up) emit their ONE envelope at startup,
     // when its URL is useful — so -o is preflighted BEFORE dispatch (an

package/dist/contracts/cli.d.ts

@@ -714,6 +714,53 @@ export declare const COMMAND_OUTPUTS: {
         reason: z.ZodString;
         message: z.ZodOptional<z.ZodString>;
     }, z.core.$loose>], "ok">;
+    readonly audit: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        envelopeVersion: z.ZodLiteral<1>;
+        ok: z.ZodLiteral<true>;
+        command: z.ZodLiteral<"audit">;
+        filters: z.ZodObject<{
+            person: z.ZodNullable<z.ZodString>;
+            token: z.ZodNullable<z.ZodString>;
+            source: z.ZodNullable<z.ZodEnum<{
+                api: "api";
+                mcp: "mcp";
+            }>>;
+            since: z.ZodNullable<z.ZodString>;
+        }, z.core.$loose>;
+        actions: z.ZodArray<z.ZodObject<{
+            id: z.ZodNumber;
+            at: z.ZodString;
+            person: z.ZodString;
+            token: z.ZodNullable<z.ZodString>;
+            source: z.ZodEnum<{
+                api: "api";
+                mcp: "mcp";
+            }>;
+            kind: z.ZodEnum<{
+                command: "command";
+                tool: "tool";
+            }>;
+            name: z.ZodString;
+            command: z.ZodString;
+            tool: z.ZodNullable<z.ZodString>;
+            repo: z.ZodNullable<z.ZodString>;
+            taskId: z.ZodNullable<z.ZodString>;
+            outcome: z.ZodEnum<{
+                error: "error";
+                ok: "ok";
+                refused: "refused";
+            }>;
+            reason: z.ZodNullable<z.ZodString>;
+        }, z.core.$loose>>;
+        limit: z.ZodNumber;
+        nextCursor: z.ZodNullable<z.ZodString>;
+    }, z.core.$loose>, z.ZodObject<{
+        envelopeVersion: z.ZodLiteral<1>;
+        ok: z.ZodLiteral<false>;
+        command: z.ZodLiteral<"audit">;
+        reason: z.ZodString;
+        message: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>], "ok">;
     readonly "skills list": z.ZodDiscriminatedUnion<[z.ZodObject<{
         envelopeVersion: z.ZodLiteral<1>;
         ok: z.ZodLiteral<true>;

package/dist/contracts/cli.js

@@ -148,6 +148,16 @@ const taskShowOutput = answers("task show", {
     proofAccepted: z.boolean(),
     stops: list,
 });
+/** `audit` (remote-audit.ts): one page of remote actions, newest first, and the filters it applied. */
+const auditOutput = answers("audit", {
+    filters: z.looseObject({ person: nullable(str), token: nullable(str), source: nullable(z.enum(["api", "mcp"])), since: nullable(str) }),
+    actions: rows({
+        id: int, at: str, person: str, token: nullable(str), source: z.enum(["api", "mcp"]), kind: z.enum(["command", "tool"]), name: str, command: str,
+        tool: nullable(str), repo: nullable(str), taskId: nullable(str), outcome: z.enum(["ok", "refused", "error"]), reason: nullable(str),
+    }),
+    limit: int,
+    nextCursor: nullable(str),
+});
 const flowListed = z.looseObject({ id: int, name: str, repo: str, project: str, zones: z.array(str), triggers: int, cardsWaiting: int, needDecision: int });
 /**
  * The commands whose answers name their fields: the most-used ones (contract, the no-verb scan, status,
@@ -189,6 +199,7 @@ export const COMMAND_OUTPUTS = {
     "cap list": answers("cap list", { repo: str, capabilities: list }),
     gaps: answers("gaps", { repo: str, gaps: list }),
     reap: answers("reap", { count: int, released: list }),
+    audit: auditOutput,
     "skills list": answers("skills list", { guides: rows({ name: str, title: str, oneLiner: str }) }),
 };
 const declared = new Map(Object.entries(COMMAND_OUTPUTS));

package/dist/contracts/console-api.d.ts

@@ -80,6 +80,7 @@ export declare const CONSOLE_FORMS: {
     readonly policy: FormContract<"ceiling" | "models" | "password" | "provider" | "tools">;
     readonly approval: FormContract<"not_requester" | "password" | "paths" | "protect" | "repo">;
     readonly sessions: FormContract<"access" | "action" | "days" | "everyone" | "name" | "password" | "session" | "token">;
+    readonly requestLimits: FormContract<"act-per-minute" | "action" | "password" | "per-day" | "per-minute" | "read-per-minute" | "target">;
     readonly signIn: FormContract<"action" | "client-id" | "client-secret" | "groups-claim" | "issuer" | "label" | "password" | "passwords" | "scopes" | `group-${string}` | `projects-${string}` | `role-${string}`>;
     readonly updates: FormContract<"password" | "version" | "when">;
     readonly retention: FormContract<"chat" | "checkouts" | "evidence" | "notifications" | "password">;

package/dist/contracts/console-api.js

@@ -89,6 +89,7 @@ export const CONSOLE_FORMS = {
     policy: formContract("POST /settings/policy", ["password", "provider", "models", "tools", "ceiling"]),
     approval: formContract("POST /settings/approval", ["repo", "password", "protect", "paths", "not_requester"]),
     sessions: formContract("POST /settings/sessions", ["everyone", "action", "session", "token", "name", "access", "days", "password"]),
+    requestLimits: formContract("POST /settings/request-limits", ["target", "action", "read-per-minute", "act-per-minute", "per-minute", "per-day", "password"]),
     signIn: formContract("POST /settings/sign-in", ["action", "password", "issuer", "client-id", "client-secret", "label", "scopes", "groups-claim", "passwords"], { prefixes: ["group-", "role-", "projects-"] }),
     updates: formContract("POST /settings/updates, /settings/updates/seen, /settings/updates/cancel", ["password", "version", "when"]),
     retention: formContract("POST /settings/retention", ["password", "evidence", "checkouts", "chat", "notifications"]),

package/dist/contracts/mcp-oauth.d.ts

@@ -0,0 +1,53 @@
+/**
+ * MCP sign-in (mcp-oauth.ts): what an MCP client may send when it registers itself (RFC 7591) and when it trades a
+ * code or a refresh secret for tokens (RFC 6749 §4.1.3, §6, with PKCE, RFC 7636).
+ *
+ * A registration is read strictly for the fields Toolroll uses and ignores the rest (RFC 7591 §2: unknown metadata
+ * is ignored). Only public clients register: no secret is issued, so `token_endpoint_auth_method` is `none` when
+ * given. Whether a redirect is https, or http on 127.0.0.1 / [::1], is checked by mcp-oauth.ts after reading.
+ */
+import { z } from "zod";
+import { type ContractResult } from "./contract.js";
+/** The most redirects one client registers, and how long each and the client's name may be. */
+export declare const OAUTH_LIMITS: {
+    readonly redirects: 5;
+    readonly redirect: 512;
+    readonly name: 100;
+};
+export declare const OAUTH_GRANTS: readonly ["authorization_code", "refresh_token"];
+export declare const oauthRegistrationSchema: z.ZodObject<{
+    redirect_uris: z.ZodArray<z.ZodString>;
+    client_name: z.ZodOptional<z.ZodString>;
+    token_endpoint_auth_method: z.ZodOptional<z.ZodLiteral<"none">>;
+    grant_types: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        authorization_code: "authorization_code";
+        refresh_token: "refresh_token";
+    }>>>;
+    response_types: z.ZodOptional<z.ZodArray<z.ZodLiteral<"code">>>;
+}, z.core.$strip>;
+/** A PKCE verifier (RFC 7636 §4.1) and a S256 challenge (43 base64url characters). */
+export declare const PKCE_VERIFIER: RegExp;
+export declare const PKCE_CHALLENGE: RegExp;
+/** A token request, by grant type. Every value is one form field. */
+export declare const oauthTokenRequestSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    grant_type: z.ZodLiteral<"authorization_code">;
+    code: z.ZodString;
+    redirect_uri: z.ZodString;
+    client_id: z.ZodString;
+    code_verifier: z.ZodString;
+    resource: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    grant_type: z.ZodLiteral<"refresh_token">;
+    refresh_token: z.ZodString;
+    client_id: z.ZodString;
+    resource: z.ZodOptional<z.ZodString>;
+    scope: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>], "grant_type">;
+export type OAuthRegistration = z.infer<typeof oauthRegistrationSchema>;
+export type OAuthTokenRequest = z.infer<typeof oauthTokenRequestSchema>;
+export declare const readOAuthRegistration: (input: unknown) => ContractResult<OAuthRegistration>;
+/** A token request's form: a field given twice is refused (RFC 6749 §3.2); fields this grant doesn't take are ignored. */
+export declare function readOAuthTokenRequest(form: URLSearchParams): ContractResult<OAuthTokenRequest> | {
+    ok: false;
+    repeated: true;
+};

package/dist/contracts/mcp-oauth.js

@@ -0,0 +1,40 @@
+/**
+ * MCP sign-in (mcp-oauth.ts): what an MCP client may send when it registers itself (RFC 7591) and when it trades a
+ * code or a refresh secret for tokens (RFC 6749 §4.1.3, §6, with PKCE, RFC 7636).
+ *
+ * A registration is read strictly for the fields Toolroll uses and ignores the rest (RFC 7591 §2: unknown metadata
+ * is ignored). Only public clients register: no secret is issued, so `token_endpoint_auth_method` is `none` when
+ * given. Whether a redirect is https, or http on 127.0.0.1 / [::1], is checked by mcp-oauth.ts after reading.
+ */
+import { z } from "zod";
+import { parseContract } from "./contract.js";
+/** The most redirects one client registers, and how long each and the client's name may be. */
+export const OAUTH_LIMITS = { redirects: 5, redirect: 512, name: 100 };
+export const OAUTH_GRANTS = ["authorization_code", "refresh_token"];
+export const oauthRegistrationSchema = z.object({
+    redirect_uris: z.array(z.string().min(1).max(OAUTH_LIMITS.redirect)).min(1).max(OAUTH_LIMITS.redirects),
+    client_name: z.string().max(OAUTH_LIMITS.name).optional(),
+    token_endpoint_auth_method: z.literal("none").optional(),
+    grant_types: z.array(z.enum(OAUTH_GRANTS)).min(1).max(2).optional(),
+    response_types: z.array(z.literal("code")).min(1).max(1).optional(),
+});
+/** A PKCE verifier (RFC 7636 §4.1) and a S256 challenge (43 base64url characters). */
+export const PKCE_VERIFIER = /^[A-Za-z0-9._~-]{43,128}$/;
+export const PKCE_CHALLENGE = /^[A-Za-z0-9_-]{43}$/;
+const bounded = z.string().min(1).max(2048);
+/** A token request, by grant type. Every value is one form field. */
+export const oauthTokenRequestSchema = z.discriminatedUnion("grant_type", [
+    z.object({ grant_type: z.literal("authorization_code"), code: bounded, redirect_uri: bounded, client_id: bounded, code_verifier: z.string().regex(PKCE_VERIFIER), resource: bounded.optional() }),
+    z.object({ grant_type: z.literal("refresh_token"), refresh_token: bounded, client_id: bounded, resource: bounded.optional(), scope: bounded.optional() }),
+]);
+export const readOAuthRegistration = (input) => parseContract(oauthRegistrationSchema, input);
+/** A token request's form: a field given twice is refused (RFC 6749 §3.2); fields this grant doesn't take are ignored. */
+export function readOAuthTokenRequest(form) {
+    const fields = {};
+    for (const [key, value] of form) {
+        if (Object.hasOwn(fields, key))
+            return { ok: false, repeated: true };
+        fields[key] = value;
+    }
+    return parseContract(oauthTokenRequestSchema, fields);
+}

package/dist/credentials-ui.d.ts

@@ -16,6 +16,11 @@ export type CredentialsView = {
     })[];
     tokens: ApiTokenRow[];
     now: number;
+    /** Request limits (request-budget-ui.ts): words for each token's line, and the operator's disclosure. */
+    limits?: {
+        note: (token: ApiTokenRow) => string;
+        section: string;
+    };
 };
 export declare function credentialsHtml(view: CredentialsView, csrf: string, notice: {
     said?: string | null;

package/dist/credentials-ui.js

@@ -1,9 +1,11 @@
-import { TOKEN_DAYS } from "./api-tokens.js";
+import { daysLeft, expiryNoticeDue, TOKEN_DAYS, tokenLive } from "./api-tokens.js";
+import { projectName } from "./project.js";
 const e = (value) => String(value ?? "").replace(/[&<>"']/g, c => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" })[c]);
 export const CREDENTIALS_CSS = `.credentials{max-width:820px;min-width:0}.credentials .card{padding:14px 16px;margin:12px 0}.credentials h2{font-size:1.05rem;margin:0 0 8px}` +
     `.credentials .rows{display:grid;gap:0;border:1px solid var(--so-line);border-radius:10px;overflow:hidden}.credentials .row-item{display:flex;align-items:center;justify-content:space-between;gap:12px;padding:10px 14px;border-bottom:1px solid var(--so-line)}` +
     `.credentials .row-item:last-child{border-bottom:0}.credentials .row-item p{margin:0}.credentials .row-item .meta{font-size:.85rem}.credentials form{margin:0}.credentials button{min-height:40px;white-space:nowrap}` +
     `.credentials .create{display:grid;gap:10px}.credentials .create label{display:grid;gap:6px}.credentials .create input,.credentials .create select{box-sizing:border-box;width:100%}.credentials .badge-here{font-size:.75rem;padding:1px 6px;border-radius:999px;background:var(--so-success-soft);color:var(--so-success);margin-left:6px}` +
+    `.credentials .row-item>div{min-width:0}.credentials .row-item p{overflow-wrap:anywhere}.credentials .soon{color:var(--so-warning,#9a6700);font-weight:600}` +
     `@media(max-width:600px){.credentials .row-item{flex-wrap:wrap}.credentials .create input,.credentials .create select{font-size:16px}}`;
 /** "Chrome on macOS", from a user agent, for a person to recognise a session. */
 export function deviceWords(agent) {
@@ -30,16 +32,26 @@ export function credentialsHtml(view, csrf, notice) {
         `${one.here ? "" : post({ action: "end-session", session: one.idHash }, "Sign out")}</div>`).join("")}</div>`;
     const others = view.sessions.filter(one => !one.here && one.account === view.who).length;
     const endOthers = others > 0 && !view.everyone ? post({ action: "end-others" }, `Sign out everywhere else (${others})`) : "";
-    const live = view.tokens.filter(one => one.revokedAt === null && Date.parse(one.expiresAt) > view.now);
+    const live = view.tokens.filter(one => tokenLive(one, view.now));
+    // v111: its projects, and one state: when it stops (soon, said once and marked) or, once replaced, when it ends.
+    const ends = (one) => {
+        if (one.replacedBy !== null && one.overlapUntil !== null)
+            return `<span class="soon">Replaced · stops ${e(one.overlapUntil.slice(11, 16))} UTC</span>`;
+        if (expiryNoticeDue(one, view.now) === null)
+            return `Expires ${e(one.expiresAt.slice(0, 10))}`;
+        const days = daysLeft(one.expiresAt, view.now);
+        return `<span class="soon">Expires ${days <= 1 ? "within a day" : `in ${days} days`}</span>`;
+    };
+    const scope = (one) => one.projects === null ? "All projects" : one.projects.length === 0 ? "No projects" : one.projects.map(repo => e(projectName(repo))).join(", ");
     const tokens = live.length === 0 ? `<p class="meta">No API tokens.</p>` : `<div class="rows">${live.map(one => `<div class="row-item" data-token="${e(one.id)}"><div><p>${view.everyone ? `<strong>${e(one.account)}</strong> · ` : ""}${e(one.name)} · ${one.access === "act" ? "Can act" : "Read only"}</p>` +
-        `<p class="meta">Expires ${e(one.expiresAt.slice(0, 10))} · last used ${e(when(one.lastUsedAt, view.now))}</p></div>${post({ action: "revoke-token", token: one.id }, "Revoke")}</div>`).join("")}</div>`;
+        `<p class="meta">${scope(one)} · ${ends(one)} · last used ${e(when(one.lastUsedAt, view.now))}${view.limits === undefined ? "" : ` · ${e(view.limits.note(one))}`}</p></div>${post({ action: "revoke-token", token: one.id }, "Revoke")}</div>`).join("")}</div>`;
     const create = `<details class="card"><summary>New API token</summary><form method="post" action="/settings/sessions" class="create">${hidden({ csrf, action: "create-token" })}` +
         `<label>Name<input type="text" name="name" maxlength="60" required placeholder="for example: CI"></label>` +
         `<label>It can<select name="access"><option value="read">Read (tasks, results, the ledger)</option><option value="act">Act as you (file and manage work; never approve)</option></select></label>` +
         `<label>Expires in<select name="days">${TOKEN_DAYS.map(days => `<option value="${days}"${days === 90 ? " selected" : ""}>${days} days</option>`).join("")}</select></label>` +
         `<label>Your Toolroll password<input type="password" name="password" autocomplete="current-password" required></label><button>Make the token</button></form></details>`;
     return `<section class="credentials">${note}${toggle}<h2>Signed in</h2>${sessions}${endOthers}<h2 style="margin-top:1.5rem">API tokens</h2>` +
-        `<p class="meta">For scripts and CI: send <code>Authorization: Bearer &lt;token&gt;</code>. A token can't approve anything.</p>${tokens}${view.everyone ? "" : create}</section>`;
+        `<p class="meta">For scripts and CI: send <code>Authorization: Bearer &lt;token&gt;</code>. A token can't approve anything.</p>${tokens}${view.everyone ? "" : create}${view.limits?.section ?? ""}</section>`;
 }
 /** The token, once: a focused page with no script. */
 export function tokenShownHtml(name, token, access, expiresAt) {

package/dist/export.js

@@ -29,14 +29,14 @@ import { readEmailSettings } from "./email-settings.js";
 import { SUBSCRIPTION_CAPABLE, readAuthMode } from "./keys.js";
 export const EXPORT_FORMAT = "standing-orders/export/v1";
 /** Tables that hold nothing but secrets or short-lived sign-in material, and derived search indexes. */
-const SECRET_TABLES = new Set(["web_session", "ceremony_nonce", "telegram_pairing", "slack_pair", "discord_pair", "teams_pair"]);
+const SECRET_TABLES = new Set(["web_session", "ceremony_nonce", "telegram_pairing", "slack_pair", "discord_pair", "teams_pair", "oauth_code", "oauth_refresh"]);
 const DERIVED_TABLE = /^(sqlite_|memory_search)/;
 /** Columns that hold a secret (or what stands in for one): never exported. */
 const SECRET_COLUMNS = new Set([
     "api_token.secret_hash", "lead_credential.secret_hash", "approver.credential_hash", "coordinator_credential.credential_hash", "runner.credential_hash", "invite.token_hash",
     "flow_trigger.hook_hash", "held_session.cookie", "push_subscription.endpoint", "push_subscription.p256dh", "push_subscription.auth",
     "chat_turn.credential_key", "mate_session.credential_key", "mate_turn.credential_key", "bridge_lease.push_url", "workflow_preview.token",
-    "quota.credential_fp",
+    "quota.credential_fp", "oauth_grant.renew_hash", "oauth_client.source_hash",
 ]);
 /** A column named like this holds a secret unless it is reviewed below; an unreviewed one is dropped. */
 const SECRET_NAME = /hash|secret|token|passw|cookie|csrf|credential|p256dh|^auth$|key|nonce|endpoint|url/i;
@@ -56,7 +56,7 @@ export function categoryOf(table) {
         [/^teammate/, "teammates"],
         [/^(flow|routine|workflow_)/, "flows"],
         [/^(chat_|mate_|team_|telegram_|slack_|discord_|teams_|notification|push_|bridge_lease)/, "chats"],
-        [/^(approver|api_token|lead_credential|invite|sso_identity|coordinator_)/, "people"],
+        [/^(approver|api_token|lead_credential|invite|sso_identity|coordinator_|oauth_)/, "people"],
         [/^(run|artifact|claim|worktree$|execution_slot|contest|tournament_terms|fallback_cycle|fallback_transition|held_session|session_turn|attended_authorization|criterion_review|diff_comment|proof_|review_request|repair_chain|incident|publication$|merge_|side_spend|knowledge_snapshot|learning_snapshot|skill_snapshot)/, "runs"],
         [/^(task|hold$|plan_|scope_|tool_seal|decision|external_|skill_test)/, "tasks"],
         [/^(project|approval_policy|capability|verify_command|worktree_setup|backend_grant|intake_grant|publication_grant|operating_mode|knowledge_|learning_|memory_|skill_)/, "projects"],
@@ -67,6 +67,7 @@ export function categoryOf(table) {
 /** Extra shapes beside the evidence scanner's: this installation's own tokens and password hashes, and bearer headers. */
 const EXTRA_SHAPES = [
     /\bso_[a-f0-9]{12}_[A-Za-z0-9_-]{43}/g,
+    /\bsor_[a-f0-9]{12}_[A-Za-z0-9_-]{43}/g,
     /\blt_[a-f0-9]{12}_[A-Za-z0-9_-]{43}/g,
     /\bscrypt\$[^\s"',;]+/g,
     /\bBearer\s+[A-Za-z0-9._~+/-]{16,}=*/gi,

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

@@ -0,0 +1,2 @@
+import type { Store } from "./store.js";
+export declare function flowCardTaskLine(store: Store, taskId: string, repo: string, now: Date, secrets?: readonly string[]): string;

package/dist/flow-card-task.js

@@ -0,0 +1,57 @@
+/** The task behind an agent zone, read through the same status as its task page.
+ * Only saved milestone progress belongs on the card; tool calls and logs do not. */
+import { assignmentOf } from "./assignment.js";
+import { scanForSecrets } from "./evidence.js";
+import { scrubIntegrationText } from "./integrations.js";
+import { assignmentStatusFacts, taskStatusOf } from "./task-status.js";
+import { taskWorkSummaryOf } from "./work-summary.js";
+import { buildProgressOf } from "./workspace-ui.js";
+/** Redact before shortening: a cut-off credential must never slip through a scanner.
+ * Structured arguments, commands and credential assignments aren't card copy. */
+function cardReason(text, fallback, secrets) {
+    if (text === null)
+        return fallback;
+    const raw = /[{}\[\]`]|\b[\w.-]+\s*=|(?:^|\s)--[\w-]+|\b(?:arguments|tool_input|command|cmd|password|passwd|token|secret|api[_ -]?key|authorization)\s*:|\bcurl\s/i.test(text);
+    if (raw || secrets.some(secret => secret !== "" && text.includes(secret)) || scanForSecrets(text).length > 0)
+        return fallback;
+    const clean = scrubIntegrationText(text, secrets).replace(/[\p{Cf}]/gu, "").replace(/[.\s]+$/, "");
+    if (clean === "" || clean.includes("[hidden]"))
+        return fallback;
+    return clean.length > 100 ? `${clean.slice(0, 99).trimEnd()}…` : clean;
+}
+export function flowCardTaskLine(store, taskId, repo, now, secrets = []) {
+    const access = { principal: "operator", repos: [repo], dependencyRepos: [repo] };
+    const assignment = assignmentOf(store, taskId, now, access);
+    if (assignment === null)
+        return "Task unavailable";
+    const work = taskWorkSummaryOf(store, assignment.activeTaskId, now, access);
+    if (work === null)
+        return "Task unavailable";
+    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
+    // when the full receipt has no artifact root from which to read its check.
+    const check = assignment.receipt === null ? null : store.runCheckFor(assignment.receipt.runId);
+    if (facts.checks?.status === "unavailable" && check !== null)
+        facts.checks = { ...facts.checks, status: check.status, exitCode: check.exitCode };
+    const status = taskStatusOf(facts);
+    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.
+        const what = status.need?.key === "answer" || status.need?.key === "other"
+            ? cardReason(status.sentence, fallback, secrets) : fallback;
+        return `Waiting on you: ${what}`;
+    }
+    if (status.headline === "Building" && live !== null) {
+        const ref = store.lookupRef(assignment.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)
+            return `Stuck: ${cardReason(progress.stuck.why, `step ${progress.step} of ${progress.total}`, secrets)}`;
+        if (progress !== null)
+            return `Building · step ${progress.step} of ${progress.total}`;
+    }
+    if (status.headline === "Failed")
+        return `Stuck: ${cardReason(status.sentence, "Open the task", secrets)}`;
+    return status.headline === "Ready for review" ? "Ready" : status.headline;
+}

package/dist/flow-live.d.ts

@@ -12,8 +12,8 @@ export type FlowViewer = {
     response: ServerResponse;
     valid: () => boolean;
 };
-/** What changes when anything on the canvas changes: one row, one read, kept short and opaque. */
-export declare function flowFingerprint(store: Store, flow: number): string | null;
+/** What changes when anything on the canvas changes: metadata only, kept short and opaque. */
+export declare function flowFingerprint(store: Store, flow: number, now?: Date): string | null;
 export type FlowRooms = {
     /** Keep this page's stream on the flow until it closes; the first event says where the flow stands. */
     join: (flow: number, viewer: FlowViewer) => void;