toolroll 0.9.63 → 0.9.67

package/dist/flows-cli.js

@@ -16,11 +16,12 @@ import { saveScript } from './flow-scripts.js';
 import { exportFlow, fetchFlowFile, FLOW_FILE_MAX_BYTES, FlowFileError, importFlow, parseFlowFile, planFlowImport } from './flow-share.js';
 import { describeStandingOrder } from './flow-schedule.js';
 import { STARTER_FLOWS, starterFlowOf, starterOf, startersFor, starterTerms, switchOnStarter } from './flow-starters.js';
-import { addFlowTriggerTo, checkFlowTriggerNow, describeTrigger, removeFlowTrigger, setFlowTriggerOn, triggerConfigOf, validateTriggerConfig } from './flow-triggers.js';
+import { addFlowTriggerTo, checkFlowTriggerNow, describeTrigger, removeFlowTrigger, setFlowTriggerOn, triggerConfigOf, validateTriggerConfig, rawTakesDeliveries } from './flow-triggers.js';
 import { deciderOf, FLOW_KIND_WORDS, FLOW_TEMPLATES, flowDigest, flowFromSteps, flowTerms, stepsFor } from './flows.js';
 import { prepareUnattendedCandidates, activeUnattendedGrant, parseUnattendedAsk, revokeUnattended, signUnattended, unattendedViewOf, unattendedWords, untilWords, UNATTENDED_MAX_RUNS } from './flow-unattended.js';
 import { MODE_MAX_DAYS } from './modes.js';
 import { verifyApproverByPassword } from './principal.js';
+import { proveCredential } from './scope.js';
 import { projectName } from './project.js';
 const EXIT = { ok: 0, failed: 1, usage: 2, refused: 3 };
 const json = { name: 'json', takesValue: false, meaning: 'answer with one machine envelope on stdout' };
@@ -502,7 +503,12 @@ export async function runFlowsCommand(positional, flags, context) {
             const zone = definition.stages.find(one => one.id === (config.zone ?? definition.start))?.title ?? 'the first zone';
             return preview(flow.repo, `Add a trigger to ${flow.name}`, [words, `Cards start in ${zone}.`, 'Work a card starts still waits for your usual approvals.'], { flowId: flow.id, trigger: config });
         }
-        const made = addFlowTriggerTo(store, flow, input.value, who, now, context.configDir);
+        // A trigger that takes deliveries mints an address: a credential act, a password typed for this command (never the
+        // remembered login under Passwordless) (docs/plans/passwordless.md).
+        const ingress = rawTakesDeliveries(input.value);
+        if (ingress && !proveCredential(store, acting.name, acting.token).ok)
+            return refuse(flow.repo, 'unauthenticated', 'Making a webhook address takes your password, typed: pass --token.');
+        const made = addFlowTriggerTo(store, flow, input.value, who, now, context.configDir, ingress ? { ingress: 'proved' } : {});
         if (!made.ok)
             return refuse(flow.repo, 'invalid-trigger', made.message);
         await prepareUnattendedCandidates(store, flow.id);

package/dist/flows-ui.d.ts

@@ -1,5 +1,3 @@
-/** Flows in the console: the list of a person's flows, and one flow's canvas
- * (the React view's data, plus a plain fallback page the view replaces). */
 import type { BrowserFlowView } from "./browser-workspace.js";
 import type { FlowRow, Store } from "./store.js";
 import { type FlowFile, type FlowImportPlan } from "./flow-share.js";

package/dist/flows-ui.js

@@ -1,6 +1,12 @@
+/** Flows in the console: the list of a person's flows, and one flow's canvas
+ * (the React view's data, plus a plain fallback page the view replaces). */
+import { liveAttemptOf, steerControlsFor } from "./steer-controls.js";
 import { draftFor, flowDefinitionOf } from "./flow-engine.js";
 import { describeStandingOrder } from "./flow-schedule.js";
-import { describeTrigger, triggerHeadline, FLOW_TRIGGER_KINDS, FLOW_TRIGGER_WORDS, githubRepoOf, HOOK_PATH, hookReady, planeStatusLink, readHooksBase, readLinearKey, takesDeliveries, triggerConfigOf } from "./flow-triggers.js";
+import { describeTrigger, triggerHeadline, FLOW_TRIGGER_KINDS, FLOW_TRIGGER_WORDS, githubRepoOf, HOOK_PATH, hookReady, planeStatusLink, readHooksBase, readLinearKey, senderOf, takesDeliveries, triggerConfigOf } from "./flow-triggers.js";
+import { SENDER_WORDS } from "./webhook-signing.js";
+import { READER_CAPTURED } from "./webhook-readers.js";
+import { hostOf, linkWords, provedWords, snapshotOf } from "./task-source.js";
 import { deciderOf, FLOW_COLORS, FLOW_KIND_WORDS, FLOW_STAGE_KINDS } from "./flows.js";
 import { flowInsights, troubleWords } from "./flow-insights.js";
 import { parseSortDecision, sortChip } from "./flow-sort.js";
@@ -20,6 +26,40 @@ import { unattendedViewOf } from "./flow-unattended.js";
 import { readFlowSecrets } from "./flow-secrets.js";
 import { html, joinHtml, postForm } from "./html.js";
 const projectName = (repo) => repo.split(/[\\/]/).filter(Boolean).pop() ?? repo;
+/** v126: what happens to deliveries turned away (refused with 503), as far as each sender is known to say: nothing
+ * here claims a loss that a sender's own retries may still make good. */
+function resendWords(config) {
+    if (config.kind === "github")
+        return "GitHub doesn't retry on its own: resend them from the repository's Settings → Webhooks → this webhook → Recent Deliveries → Redeliver.";
+    if (config.kind === "linear")
+        return "Linear may retry a refused delivery. Look in the webhook's settings in Linear for its recent deliveries; any it doesn't resend can't be recovered here.";
+    const sender = config.kind === "webhook" ? senderOf(config) : "none";
+    return sender === "vercel" ? "Vercel retries refused deliveries for up to a day, so some may still arrive. Its webhook's delivery attempts are listed in Vercel's webhook settings; any it gives up on are lost."
+        : sender === "sentry" ? "Sentry may retry a refused delivery. Your Internal Integration's Dashboard in Sentry (Developer Settings) shows its request log; any it doesn't resend are lost, though new alerts for the same issues still arrive."
+            : "The sender may retry. Look in its webhook delivery log and resend from there if it offers it; any it doesn't resend are lost.";
+}
+/** v126: what a webhook trigger's row says about how its deliveries are proved. */
+function hookView(trigger, config, dir) {
+    const ready = hookReady(trigger, dir);
+    const dropped = trigger.droppedCount > 0 && trigger.droppedSince !== null ? { count: trigger.droppedCount, since: trigger.droppedSince, resend: resendWords(config) } : null;
+    if (config.kind !== "webhook")
+        return { ready, needsSecret: config.kind === "linear", sender: null, makesSecret: false, warning: null, readerNote: null, dropped, scope: null };
+    const sender = senderOf(config);
+    // What it needs first, first: an unset secret refuses everything, so that is said before any narrowing.
+    const warning = trigger.hookHash === null && (sender === "none" || ready) ? "No address yet: choose New address to make one and give it to the sender."
+        : sender === "none" ? "Unsigned: anyone with its address can add cards. Choose who signs its deliveries to close that."
+            : !ready ? `Not set up: its deliveries are refused until ${sender === "sentry" || sender === "vercel" ? `${SENDER_WORDS[sender]}'s secret is pasted (with New address for the address to give it)` : "it is set up"}.`
+                : (sender === "sentry" || sender === "vercel") && config.project == null ? `Any ${SENDER_WORDS[sender]} project this secret covers can add cards. Name the project to narrow it.`
+                    : null;
+    // A sender that signs only the body: byte-identical requests are one delivery (§3).
+    const repeats = sender === "github-style" ? "Identical requests count once. If the sender must send the same request again and have it count, use Standard Webhooks." : null;
+    // A reader written from its sender's documentation, not yet from a captured delivery, says so on its own line,
+    // whatever else the row says (webhook-readers.ts).
+    const readerNote = (sender === "sentry" || sender === "vercel") && !READER_CAPTURED[sender]
+        ? `Reader unverified: Toolroll reads ${SENDER_WORDS[sender]} deliveries from ${SENDER_WORDS[sender]}'s documented examples; no real delivery has been checked yet.` : null;
+    return { ready, needsSecret: sender === "sentry" || sender === "vercel", sender, makesSecret: sender === "standard" || sender === "github-style", warning, readerNote: [readerNote, repeats].filter(one => one !== null).join(" ") || null, dropped,
+        scope: sender === "sentry" || sender === "vercel" ? { project: config.project ?? null, team: config.team ?? null } : null };
+}
 export const FLOWS_CSS = `.flows{max-width:880px;min-width:0}.flows .card{padding:16px 18px;margin:12px 0}.flows .flow-row{display:flex;justify-content:space-between;align-items:baseline;gap:12px;flex-wrap:wrap}.flows .flow-row h2{font-size:1.05rem;margin:0}.flows .flow-counts{font-size:.85rem;color:var(--so-muted)}.flows form{display:grid;gap:10px;margin:0}.flows label{display:grid;gap:6px}.flows input,.flows select{box-sizing:border-box;width:100%;max-width:100%}.flows button{justify-self:start;min-height:44px}.flows .flow-fallback ol{padding-left:20px}.flows summary{cursor:pointer;min-height:44px;display:flex;align-items:center;font-weight:600}.flows .flow-buttons{display:flex;flex-wrap:wrap;align-items:center;gap:8px;margin:10px 0 0}.flows .flow-import{margin-top:18px;padding-top:14px;border-top:1px solid var(--so-line)}.flows .flow-import h3{font-size:.95rem;margin:0}.flows .flow-terms{list-style:none;padding:0;margin:8px 0 16px;display:grid;gap:10px}.flows .flow-terms li{white-space:pre-line;overflow-wrap:anywhere}.flows .flow-terms pre{white-space:pre-wrap;overflow-wrap:anywhere;font-size:.8rem;margin:6px 0 0}.flows .flow-import-preview h2{font-size:1rem;margin:20px 0 4px}.flows .flow-untrusted{font-weight:600}.flows button.primary{background:var(--primary);color:var(--primary-foreground);border-color:var(--primary)}.flows fieldset{border:0;padding:0;margin:0;display:grid;gap:10px;min-width:0}.flows legend{font-weight:600;padding:0;margin-bottom:6px}.flows textarea[hidden]{display:none}.flows button.secondary{background:transparent;color:var(--foreground);border:1px solid var(--border)}@media(max-width:600px){.flows input,.flows select{font-size:16px}}@media(max-width:760px){.flows .card{padding:10px 12px;margin:8px 0;position:relative}.flows .flow-row{row-gap:2px}.flows .flow-row h2 a::after{content:"";position:absolute;inset:0;border-radius:inherit}.flows .flow-counts{line-height:1.35}}`;
 /** The flows a person can open, with how many cards wait in each, and the new-flow form. */
 export function flowsListHtml(store, flows, projects, canCreate, problem) {
@@ -142,14 +182,22 @@ export function flowView(store, flow, viewer, selectedCard, setup = { dir: null,
             id: card.id, title: card.title, description: card.description, stage: card.stage, state: card.state,
             waiting: card.state === "active" && card.task !== null && (stage?.kind === "task" || stage?.kind === "report")
                 ? canReadTask ? flowCardTaskLine(store, card.task, taskRepo, now, secretsFor(taskRepo)) : "Task unavailable" : card.waiting,
-            task: task === null ? null : { id: task, href: `/t/${encodeURIComponent(task)}` },
+            task: task === null ? null : { id: task, href: `/t/${encodeURIComponent(task)}`,
+                // Its running attempt's composer, for an approver who may read the task (steer-controls.ts).
+                ...(() => {
+                    const ref = card.state === "active" && canReadTask && viewer.approver ? store.lookupRef(task) : null;
+                    const run = ref === null ? null : liveAttemptOf(store, ref.id, now);
+                    const composer = run === null ? null : steerControlsFor(store, task, run, now, viewer.approver);
+                    return composer === null ? {} : { composer };
+                })() },
             createdBy: card.createdBy, updatedAt: card.updatedAt,
             canDecide,
             // What a "Send to me" sent shows once, in its own box (sent), not again here; a report zone's items and full report
             // (`<id>.items`, `<id>.report`) are for later zones, and its summary is shown.
             outputs: Object.entries(card.outputs).filter(([id]) => !id.includes(".") && stages.find(one => one.id === id)?.kind !== "send").map(([id, text]) => ({ stage: id, title: title(id), text })),
             history: [...moves, ...owned].sort((a, b) => b.at.localeCompare(a.at)).slice(0, 30),
-            source: card.source,
+            // v126: an outside event's card says how it was proved and where its link goes, from what was kept at receipt.
+            source: card.source === null ? null : (() => { const snapshot = snapshotOf(card.source); return snapshot === null ? card.source : { ...card.source, proved: provedWords(snapshot), host: hostOf(card.source.url), shown: card.source.url === null ? null : linkWords(card.source.url) }; })(),
             owner: card.owner, watchers, watching: watchers.includes(viewer.name),
             mine: card.owner === viewer.name || watchers.includes(viewer.name) || canDecide || choosing?.person === viewer.name,
             comments: discussion.filter(one => one.kind === "comment").map(one => ({ id: one.id, author: one.author, body: one.body, mentions: one.mentions, at: one.at })),
@@ -178,7 +226,7 @@ export function flowView(store, flow, viewer, selectedCard, setup = { dir: null,
             ...(config === null ? { name: "Trigger", detail: "Can't be read" } : triggerHeadline(config, store)),
             zone: title(config?.zone ?? definition?.start ?? ""), zoneId: config?.zone ?? definition?.start ?? "", state: trigger.state, status: trigger.lastOutcome, statusLink: planeStatusLink(config, trigger.lastOutcome), statusAt: trigger.lastAt, failing: trigger.failures > 0,
             button: config?.kind === "button" ? { label: config.label, questions: config.questions } : null,
-            hook: config !== null && takesDeliveries(config) ? { ready: hookReady(trigger, setup.dir), needsSecret: config.kind === "linear" } : null,
+            hook: config !== null && takesDeliveries(config) ? hookView(trigger, config, setup.dir) : null,
             checkable: ((config?.kind === "github" || config?.kind === "linear") && config.delivery === "poll") || config?.kind === "email" || (config?.kind === "schedule" && config.script !== undefined) || config?.kind === "plane-review",
             shared: config?.kind === "button" && trigger.hookHash !== null,
             ...(config?.kind === "schedule" && config.order !== undefined ? { order: describeStandingOrder(config.order, flow.repo, config.schedule) } : {}),

package/dist/flows.d.ts

@@ -1,3 +1,4 @@
+import { type SourceLike } from "./task-source.js";
 import { type ContractIssue, type ContractResult } from "./contracts/contract.js";
 import { CHOICES_MAX, CHOICES_MIN, FLOW_COLORS, FLOW_END, FLOW_MERGE_METHODS, FLOW_STAGE_KINDS, LONGEST_WAIT_MINUTES, SCRIPT_LANGUAGES, SCRIPT_NAME, sortKeyOf, type FlowDefinition, type FlowStage, type FlowStageKind, type FlowStepFields, type FlowWait, type ScriptLanguage, type TriggerInput } from "./contracts/flow.js";
 export { CHOICES_MAX, CHOICES_MIN, FLOW_COLORS, FLOW_END, FLOW_MERGE_METHODS, FLOW_STAGE_KINDS, LONGEST_WAIT_MINUTES, SCRIPT_LANGUAGES, SCRIPT_NAME, sortKeyOf };
@@ -66,11 +67,13 @@ export declare function choiceTargets(stage: Pick<FlowStage, "options">): string
 export declare function replyTarget(stage: Pick<FlowStage, "options" | "onFail">): string | null;
 /** What a card's work is held to: the zones' steps and paths, never where they sit on the canvas. */
 export declare function flowDigest(definition: FlowDefinition): string;
+/** `source` (v126): where the card came from, when an outside event's delivery made it ({{card.source}}). */
 type FlowFillCard = {
     title: string;
     description: string | null;
     note: string | null;
     outputs: Record<string, string>;
+    source?: SourceLike | null;
 };
 /** Fill a zone's text from the card: title, description, the latest note and earlier zones' reports. */
 export declare function fillFlowText(template: string, card: FlowFillCard, encode?: (value: string) => string): string;
@@ -83,6 +86,7 @@ export declare const flowAttachedMark: (label: string) => string;
 export declare function flowWorkTemplate(instructions: string, card: {
     description: string | null;
     note: string | null;
+    source?: SourceLike | null;
 }): string;
 /** How a filled-in value is named where it is attached: the same words flowGoalCuts labels it with. */
 export declare function flowValueLabel(key: string, stageTitle?: (id: string) => string): string;

package/dist/flows.js

@@ -50,6 +50,7 @@
 import { TEXT_LIMITS } from "./text-limits.js";
 import { createHash } from "node:crypto";
 import { projectName } from "./project.js";
+import { cardReference } from "./task-source.js";
 import { parseContract, readVersioned } from "./contracts/contract.js";
 import { stageReferenceProblems } from "./contracts/stage-output.js";
 import { CHOICES_MAX, CHOICES_MIN, FLOW_ALIASES, FLOW_COLORS, FLOW_DEFINITION_VERSION, FLOW_END, FLOW_MERGE_METHODS, FLOW_STAGE_KINDS, flowDefinitionSchema, flowStepsSchema, HEADERS_MAX, legacySubagentStep, LONGEST_WAIT_MINUTES, savedFlowDefinitionSchema, SCRIPT_LANGUAGES, SCRIPT_NAME, sortKeyOf, SURE_AT_MAX, SURE_AT_MIN, ZONE_ID, } from "./contracts/flow.js";
@@ -477,7 +478,7 @@ export function flowDigest(definition) {
     return createHash("sha256").update(JSON.stringify({ start: definition.start, terms })).digest("hex").slice(0, 32);
 }
 /** {{stage.<id>}} is an earlier zone's output; a report zone also fills {{stage.<id>.items}} and {{stage.<id>.report}}. */
-const FILLED = /\{\{\s*(card\.title|card\.description|card\.email|note|stage\.([a-z0-9-]+(?:\.(?:items|report))?))\s*\}\}/g;
+const FILLED = /\{\{\s*(card\.title|card\.description|card\.email|card\.source|note|stage\.([a-z0-9-]+(?:\.(?:items|report))?))\s*\}\}/g;
 /** Fill a zone's text from the card: title, description, the latest note and earlier zones' reports. */
 export function fillFlowText(template, card, encode = value => value) {
     return template.replace(FILLED, (_match, key, stage) => encode(fillOne(key, stage, card))).trim();
@@ -494,6 +495,9 @@ export function flowWorkTemplate(instructions, card) {
         ...(names("card.title") || names("card.description") ? [] : [`The card: {{card.title}}${card.description ? "\n\n{{card.description}}" : ""}`]),
         ...(names("card.title") && !names("card.description") && card.description ? ["Details on the card:\n{{card.description}}"] : []),
         ...(names("note") || !card.note ? [] : ["Changes asked for: {{note}}"]),
+        // v126: an outside event's card says where it came from — a filled value like the others, so it is fitted into the
+        // goal with them (whole when it fits, attached when it doesn't), never at the cost of the zone's own words.
+        ...(names("card.source") || cardReference(card.source) === "" ? [] : ["{{card.source}}"]),
     ];
     return [instructions, ...extra].join("\n\n");
 }
@@ -507,6 +511,8 @@ export function flowValueLabel(key, stageTitle = id => id) {
         return "The card's description";
     if (key === "card.email")
         return "The card's email address";
+    if (key === "card.source")
+        return "Where the card came from";
     if (key === "note")
         return "The note it was sent back with";
     const match = /^stage\.([a-z0-9-]+)(?:\.(items|report))?$/.exec(key);
@@ -556,6 +562,8 @@ function fillOne(key, stage, card) {
     {
         if (key === "card.title")
             return card.title;
+        if (key === "card.source")
+            return cardReference(card.source);
         if (key === "card.description")
             return card.description ?? "";
         if (key === "card.email")

package/dist/html.d.ts

@@ -55,6 +55,15 @@ export type PostFormOptions = {
 };
 /** The server's request context supplies the request's CSRF token (server/request-context.ts). */
 export declare function provideFormToken(source: () => string | undefined): void;
+export declare function providePasswordless(source: () => boolean): void;
+/**
+ * A ceremony's re-authentication field: rendered as given, or — with Passwordless on for this signed-in browser —
+ * nothing at all (the form posts an empty password; the act proves the session). Never used for credential acts,
+ * the sign-in form, a new password, or a secret or API key field.
+ */
+export declare function reauth(field: Html): Html;
+/** The same question for a page's own script that builds a re-authentication field itself. */
+export declare const passwordlessRendering: () => boolean;
 /**
  * A POST form: the action, the request's one CSRF field, the optional
  * project revision and return fields, other hidden fields, then the body.

package/dist/html.js

@@ -111,6 +111,17 @@ export function attributes(values) {
 let formToken = () => undefined;
 /** The server's request context supplies the request's CSRF token (server/request-context.ts). */
 export function provideFormToken(source) { formToken = source; }
+/** Passwordless (docs/plans/passwordless.md), as the request sees it: the request context provides it. */
+let passwordlessNow = () => false;
+export function providePasswordless(source) { passwordlessNow = source; }
+/**
+ * A ceremony's re-authentication field: rendered as given, or — with Passwordless on for this signed-in browser —
+ * nothing at all (the form posts an empty password; the act proves the session). Never used for credential acts,
+ * the sign-in form, a new password, or a secret or API key field.
+ */
+export function reauth(field) { return passwordlessNow() ? html `` : field; }
+/** The same question for a page's own script that builds a re-authentication field itself. */
+export const passwordlessRendering = () => passwordlessNow();
 /**
  * A POST form: the action, the request's one CSRF field, the optional
  * project revision and return fields, other hidden fields, then the body.

package/dist/invoke.d.ts

@@ -20,6 +20,9 @@ import { type AgentSpec, type Invocation, type ProviderRunner, type AgentEnding
 import { type VersionProbe } from "./attest.js";
 import type { Store } from "./store.js";
 import type { RunOptions } from "./exec.js";
+import type { Runner } from "./worktree.js";
+import { type WritesMode } from "./agent-fence.js";
+import { type NetworkProfile } from "./egress.js";
 export type { ProviderRunner } from "./provider.js";
 /** The claude binary name — kept for the legacy quota rows and tests that
  * describe history; new code carries a resolved AgentSpec instead. */
@@ -53,6 +56,8 @@ export type AgentOutcome = {
      * strikes of bad agent work).
      */
     initFailed: boolean;
+    /** An ACP conversation's facts (provider.ts ParsedEnvelope.acp): read by the conformance check only. */
+    acp?: NonNullable<import("./provider.js").ParsedEnvelope["acp"]>;
 };
 /**
  * The value-shaped gateway result (Phase 3 B5): a refusal is a VALUE, so
@@ -78,6 +83,8 @@ export type InvokeResult = {
     /** Bounded agent reply when a spawned turn later failed a protocol
      * gate. Pre-spawn refusals omit it because no reply can exist. */
     finalMessage?: string | null;
+    /** An ACP conversation's facts, when the refusal came after a spawn (the conformance check grades a cancel). */
+    acp?: NonNullable<import("./provider.js").ParsedEnvelope["acp"]>;
 };
 /**
  * Spend money, on the record. Throws — never refuses quietly — when the run
@@ -86,10 +93,38 @@ export type InvokeResult = {
  * bug, not a case. Attestation and protocol refusals are VALUES (above),
  * not throws — those are cases, and they must dispose cleanly.
  */
+/**
+ * What a launch may reach on the network (egress.ts, docs/plans/agent-baseline-hardening.md arc 1). `policy`: the
+ * network a build's approval sealed (or the narrowed legacy one), enforced through the run's own proxy. `via`: the
+ * caller already runs the proxy (a scout's public-web proxy, its browser): only those loopback ports are reachable.
+ * Absent: the provider's own hosts only (a planner, a check — nothing that installs or browses).
+ */
+export type LaunchNetwork = {
+    policy: NetworkProfile;
+} | {
+    via: number[];
+};
 export declare function invokeAgent(store: Store, runId: number, spec: AgentSpec, invocation: Omit<Invocation, "model">, options: RunOptions & {
     runner?: ProviderRunner;
     clock?: () => Date;
     versionProbe?: VersionProbe;
     keyHome?: string;
     accumulateUsage?: boolean;
+    network?: LaunchNetwork;
+    writes?: WritesMode;
 }): Promise<InvokeResult>;
+/**
+ * A build's setup and check commands, run in its fence (arc 2): the same denies as its agent's (Toolroll's state,
+ * credentials, other projects and runs), its write allowlist when its approval sealed one (its checkout and Git data,
+ * its project's caches, and a temp folder of the command's own), and its package managers pointed at those caches.
+ * Their network stays as it was. A machine without an OS fence runs them as before; a fence that can't be prepared
+ * (a checkout whose binding no longer proves) runs nothing.
+ */
+export declare function fencedCommands(store: Store, runId: number, writes: WritesMode, inner: Runner, available?: () => boolean): Runner;
+/**
+ * A project's checks run in a checkout of a result's commit made for them (result-follow-ups.ts, batch-checks.ts), in
+ * the same fence as a build's commands: Toolroll's state, credentials, other projects and runs denied; under the
+ * project's writes setting, only that checkout, its Git data, its own temp folder, the project's caches and its check
+ * database writable. Where nothing can confine them, they run only when an instance operator allowed unconfined agents.
+ */
+export declare function fencedCheckoutCommands(store: Store, repo: string, checkout: string, inner: Runner, available?: () => boolean): Runner;