@coreplane/switchboard 1.203.0 → 1.205.0

package/dist/cli.js

@@ -615,8 +615,8 @@ var init_policy = __esm({
     };
     PLACEHOLDER = /\{([^{}]*)\}/g;
     PolicyError = class extends Error {
-      constructor(message, rule) {
-        super(`authz policy: ${message} (rule ${describeRule(rule)})`);
+      constructor(message2, rule) {
+        super(`authz policy: ${message2} (rule ${describeRule(rule)})`);
         this.name = "PolicyError";
       }
     };
@@ -1188,6 +1188,42 @@ var init_schedules = __esm({
   }
 });
 
+// ../../src/execution/bashTimeout.ts
+function clampBashTimeout(requested) {
+  if (typeof requested !== "number" || !Number.isFinite(requested)) return BASH_TIMEOUT_MS;
+  return Math.min(Math.max(Math.trunc(requested), BASH_TIMEOUT_MIN_MS), BASH_TIMEOUT_MAX_MS);
+}
+function bashBudgetWithinRun(wantedMs, remainingMs) {
+  const secs = (ms) => Math.max(0, Math.round(ms / 1e3));
+  const cap = Math.trunc(remainingMs - RUN_DEADLINE_RESERVE_MS);
+  if (cap < BASH_TIMEOUT_MIN_MS) {
+    return {
+      kind: "exhausted",
+      note: `run budget exhausted \u2014 ${secs(remainingMs)}s of wall clock left, inside the ${secs(RUN_DEADLINE_RESERVE_MS)}s write-up reserve, so the command was not run; write up what you have now`
+    };
+  }
+  if (cap >= wantedMs) return { kind: "unchanged" };
+  return {
+    kind: "clipped",
+    timeoutMs: cap,
+    note: `[timeout clipped to ${secs(cap)}s \u2014 the run's wall clock ends in ${secs(remainingMs)}s]`
+  };
+}
+function bashTimeoutNote(timeoutMs) {
+  return `aborted at the ${Math.round(timeoutMs / 1e3)}s command timeout (pass the bash tool's timeoutMs for longer commands, max ${BASH_TIMEOUT_MAX_MS} ms)`;
+}
+var BASH_TIMEOUT_MS, BASH_TIMEOUT_MIN_MS, BASH_TIMEOUT_MAX_MS, RUN_DEADLINE_RESERVE_MS, EXEC_CALL_MARGIN_MS;
+var init_bashTimeout = __esm({
+  "../../src/execution/bashTimeout.ts"() {
+    "use strict";
+    BASH_TIMEOUT_MS = 5 * 6e4;
+    BASH_TIMEOUT_MIN_MS = 1e3;
+    BASH_TIMEOUT_MAX_MS = 20 * 6e4;
+    RUN_DEADLINE_RESERVE_MS = 6e4;
+    EXEC_CALL_MARGIN_MS = 3e4;
+  }
+});
+
 // ../../src/core/ship/contract.ts
 function parsePlanUnit(planMarkdown, unitId) {
   const lines = planMarkdown.split("\n");
@@ -1485,6 +1521,9 @@ var init_contract = __esm({
 });
 
 // ../../src/agents/registry.ts
+function machineNeedsRepo(machine) {
+  return machine === "repo-cold" || machine === "repo-resident";
+}
 function getAgent(name) {
   const a = AGENTS[name];
   if (!a) {
@@ -1492,11 +1531,14 @@ function getAgent(name) {
   }
   return a;
 }
-var PR_DESCRIPTION_TEMPLATE, NEVER_MERGE, CONTRACT_HEADINGS_LIST, UNIT_CONTRACT, UNIT_HANDOFF, CODING_SYSTEM, CODING_SYSTEM_RESIDENT, REVIEW_VERDICT_INSTRUCTION, REVIEW_SPEC_CHECK, REVIEW_UNIT_CONTRACT, REVIEW_WHOLE_CHANGE, REVIEW_SYSTEM, REVIEW_SYSTEM_RESIDENT, RESEARCH_SYSTEM, GENERAL_SYSTEM, AGENTS;
+var MACHINE_CLASSES, IDENTITIES, PR_DESCRIPTION_TEMPLATE, NEVER_MERGE, CONTRACT_HEADINGS_LIST, UNIT_CONTRACT, UNIT_HANDOFF, CODING_SYSTEM, CODING_SYSTEM_RESIDENT, REVIEW_VERDICT_INSTRUCTION, REVIEW_SPEC_CHECK, REVIEW_UNIT_CONTRACT, REVIEW_WHOLE_CHANGE, REVIEW_SYSTEM, REVIEW_SYSTEM_RESIDENT, RESEARCH_SYSTEM, GENERAL_SYSTEM, EXPLORE_SYSTEM, AGENTS;
 var init_registry = __esm({
   "../../src/agents/registry.ts"() {
     "use strict";
+    init_bashTimeout();
     init_contract();
+    MACHINE_CLASSES = ["none", "blank", "repo-cold", "repo-resident"];
+    IDENTITIES = ["none", "read", "write"];
     PR_DESCRIPTION_TEMPLATE = `PR description \u2014 submit it with the submit_pr_description tool for EVERY PR (this is the default, not something to wait to be asked for). Switchboard renders the GitHub body from the object you submit, so never author PR-body markdown yourself. Content contract per field (each renders as its own section): prose is unwrapped \u2014 no hard line breaks inside a paragraph. Always hyperlink the triggering issue/request. Never fabricate validation \u2014 state exactly what you ran and the real result. Keep each field concise, not padded.
 EVERY PR includes one that already exists when you push \u2014 opened by a person, by dependabot, or by an earlier run. After EVERY push to such a PR: read its current title and body (\`github_issue_get\` with the PR number works for pull requests; \`gh pr view\` where gh exists), judge them against the change as it now stands at the pushed head, and submit the object that describes the PR as it is NOW \u2014 carry forward what the existing body says that is still true (a dependency bump's release notes belong in whatWhy), add what you changed, and anchor the Tour at the new head. Switchboard replaces the PR's title and body with your rendering. A description that describes an earlier state of its branch is a bug; "it is someone else's PR" is never a reason to leave it.
 - **title**: the PR title \u2014 one line naming the change, specific enough to pick out of a PR list.
@@ -1648,18 +1690,34 @@ Answer directly and concisely. Use Slack-friendly formatting (no markdown header
 Your tools work without a workspace: the GitHub tools \u2014 \`github_repos\` (the org repositories you can reach), \`github_tree\` / \`github_file\` / \`github_search_code\` (browse, read, search their code and docs, private repos included), \`github_issue_list\` / \`github_issue_get\` (read issues), \`github_issue_create\` / \`github_issue_update\` / \`github_issue_comment\` / \`github_issue_delete\` (act on issues) \u2014 and \`web_fetch\` (read a public URL). Use them: when the user names a repo loosely ("the switchboard app"), resolve it with github_repos (or the thread) rather than asking; when asked about one of our repos, read it before answering. Report exactly what a tool did (issue number + URL) \u2014 never claim an action you did not perform, and never fabricate file contents, URLs, or command output.
 
 You cannot run commands, clone repositories, edit code, or review pull requests, and you cannot search the web. Other Switchboard agents can: for code changes or PRs tell the user to re-send with \`agent:coding\`; for a PR review, \`agent:review\`; for a web-research question, \`agent:research\` (e.g. "\`agent:coding fix the failing login test in acme/api\`", "\`agent:research compare X and Y\`"). Delete an issue only when the user explicitly asked to delete it (closing is an update).`;
+    EXPLORE_SYSTEM = `You are Switchboard's explore agent: a long, read-only investigation of a repository, answering a request from Slack.
+
+You work in a fresh sandbox with a shell (bash), read_file, and a read-scoped GitHub credential: git and gh are authenticated for reads, so clone the target repository into your workspace first (\`gh repo clone <owner/name>\` or \`git clone\`; check out the ref the request names), install what you need and run whatever the investigation calls for \u2014 builds, test suites, benchmarks, \`act\` (Docker is available). You cannot push. Your other tools: \`web_search\` and \`web_fetch\` (sources and pages), the GitHub reads \u2014 \`github_repos\`, \`github_tree\` / \`github_file\` (browse and read our repos at any ref), \`github_search_code\`, \`github_issue_list\` / \`github_issue_get\` \u2014 and \`list_skills\` / \`use_skill\`.
+
+THE DELIVERABLE IS A CLAIM TABLE. Turn the request into the claims it makes or asks about \u2014 explicit ones ("the suite runs in 4 minutes") and the implicit ones a careful engineer would check \u2014 and verify each one by running it, not by reading about it. One row per claim: the claim, the exact command you ran to check it, the number or output it produced, and a verdict (holds / does not hold / could not check \u2014 and why). Numbers over adjectives: measure a duration, count the failures, quote the version. Say what you did not get to.
+
+TIME. Your budget is up to two hours \u2014 less when a boundary or the request's \`budget:\` directive clipped it, which the runtime-config block above says \u2014 and the wrap-up warning tells you when to stop starting new checks. A single command is capped at ${BASH_TIMEOUT_MAX_MS / 6e4} minutes (pass the bash tool's \`timeoutMs\`, up to ${BASH_TIMEOUT_MAX_MS} ms, for a long one). A job that needs longer \u2014 a full suite, a build, a pipeline run \u2014 is started detached and polled across tool calls: \`setsid -f sh -c '<command> > /tmp/job.log 2>&1; echo $? > /tmp/job.exit'\`, then \`tail -n 40 /tmp/job.log\` and \`cat /tmp/job.exit\` on later calls (a plain background job dies with the command that started it; a \`setsid -f\` job outlives it). Batch commands into few tool calls; never explore file by file.
+
+READ-ONLY: NEVER open a pull request, and never commit or push \u2014 no branch, no \`gh pr create\`, no PR or issue write of any kind. You hold a read credential and your job is to find out, not to change. If the investigation shows a change is needed, say exactly what and where in your write-up and point the user at \`agent:coding\`.
+
+Maintain the user-facing status card with the update_status tool: post your plan as a checklist (\u25CB pending) once you have it, and update items as they start (\u2731) and finish (\u2713 \u2014 only after they actually happened). Items are short outcomes ("Clone and install", "Time the full suite"), never commands.
+
+Report outcomes faithfully: a check you could not run is "could not check", never a guess. Use Slack-friendly formatting (no markdown headers; *bold*, bullets, code blocks \u2014 render the claim table as aligned rows inside a code block). Your final message is posted to Slack: lead with the overall verdict in one line, then the claim table, then what a follow-up should do.`;
     AGENTS = {
       general: {
         name: "general",
         description: "Default assistant on the configured model: answers directly, reads the org's repos and manages their issues over GitHub, reads URLs. No workspace or shell.",
         system: GENERAL_SYSTEM,
         toolset: "assistant",
+        // The GitHub tools are REST in the bot process, so a general ask never
+        // provisions a workspace or sandbox (docs/reference/specs/agent-general.md item 4)
+        // and mints no credential of its own.
+        machine: "none",
+        identity: "none",
         maxTurns: 8,
         // a repo read is 2-3 calls (repos → tree → file); an issue action 1-2; still fast
         maxTokens: 16e3,
         maxMinutes: 5
-        // No `resources`: the GitHub tools are REST in the bot process, so a
-        // general ask still never provisions a workspace or sandbox (item 4).
       },
       coding: {
         name: "coding",
@@ -1677,7 +1735,9 @@ You cannot run commands, clone repositories, edit code, or review pull requests,
         cacheTtl: "1h",
         // No built-in effort: the deployment decides (`defaults.efforts.coding`,
         // `config set channel efforts.coding=…`, or `effort:` per request).
-        resources: { repo: "required" }
+        machine: "repo-resident",
+        identity: "write"
+        // pushes branches and opens pull requests
       },
       review: {
         name: "review",
@@ -1685,7 +1745,9 @@ You cannot run commands, clone repositories, edit code, or review pull requests,
         system: REVIEW_SYSTEM,
         residentSystem: REVIEW_SYSTEM_RESIDENT,
         toolset: "readonly",
-        resources: { repo: "required" },
+        machine: "repo-resident",
+        identity: "read",
+        // a read-scoped token and a read-only worktree: it cannot post or push from inside
         maxTurns: 30,
         // backstop only; wall clock is the real budget (12 bound at ~4 min in practice)
         maxTokens: 64e3,
@@ -1701,27 +1763,52 @@ You cannot run commands, clone repositories, edit code, or review pull requests,
         // pipeline orchestrator (src/core/shipPipeline.ts), whose child rounds run
         // on the coding/review defs above — runAgent is never called with THIS def.
         system: "You are Switchboard's ship pipeline. This prompt is never sent to a model \u2014 the pipeline orchestrates coding and review child runs on their own definitions.",
-        // Full toolset so a ship thread provisions a writable workspace class like
-        // coding; placeholder budgets — the pipeline is bounded by the `ship` config
-        // caps and by each child's own budgets clipped to the remaining wall clock,
-        // never by these numbers.
+        // Full toolset and the coding machine class, so repo and PR resolution
+        // gate a ship thread like a coding one. `maxMinutes` is the pipeline's
+        // wall clock (docs/reference/specs/agent-ship.md item 8): the ship preset's
+        // declared budget, which a deployment's `ship.maxMinutes` knob replaces
+        // (`shipPresetFor`) and a boundary or a `budget:` directive clips like any
+        // preset's; every child round runs its own agent's budget clipped to what
+        // remains of it. Turns and tokens are placeholders: no model call is ever
+        // made with this def.
         toolset: "full",
+        machine: "repo-resident",
+        identity: "write",
         maxTurns: 1,
         maxTokens: 16e3,
-        maxMinutes: 5,
-        resources: { repo: "required" }
+        maxMinutes: 120
       },
       research: {
         name: "research",
         description: "Answers questions with web search, URL reading, and read access to the org's repos and issues over GitHub. No workspace.",
         system: RESEARCH_SYSTEM,
         toolset: "web",
-        resources: { repo: "none" },
+        machine: "none",
         // web I/O only; no workspace is provisioned
+        identity: "none",
         maxTurns: 12,
         maxTokens: 24e3,
         maxMinutes: 8,
         effort: "medium"
+      },
+      explore: {
+        name: "explore",
+        description: "Long, read-only investigation of a repository in a cold sandbox: runs builds, suites and pipelines, searches the web, and reports a claim table with commands and numbers. Never opens a PR. Up to two hours.",
+        system: EXPLORE_SYSTEM,
+        toolset: "explore",
+        // Always a cold per-thread sandbox with the checkout, never the resident a
+        // review depends on: a two-hour job shares no container with anyone.
+        machine: "repo-cold",
+        identity: "read",
+        // a read-scoped token: it can clone and read, never push — whatever the caller holds
+        maxTurns: 150,
+        // a backstop for a two-hour loop of batched checks; the wall clock is the budget
+        maxTokens: 64e3,
+        maxMinutes: 120,
+        // A detached job polled across calls makes long steps: a 5m cache entry
+        // would expire between them, so the 2× write buys reads for the whole run.
+        cacheTtl: "1h"
+        // No built-in effort: the deployment decides, as for coding.
       }
     };
   }
@@ -2010,8 +2097,8 @@ var init_web = __esm({
   "../../src/tools/web.ts"() {
     "use strict";
     WebSearchUnavailableError = class extends Error {
-      constructor(message) {
-        super(message);
+      constructor(message2) {
+        super(message2);
         this.name = "WebSearchUnavailableError";
       }
     };
@@ -2049,8 +2136,8 @@ var init_web = __esm({
       return records.map((r) => r.address);
     };
     BlockedUrlError = class extends Error {
-      constructor(message) {
-        super(message);
+      constructor(message2) {
+        super(message2);
         this.name = "BlockedUrlError";
       }
     };
@@ -2319,6 +2406,38 @@ function validateScopeEfforts(layer, source2) {
     }
   }
 }
+function boundaryProblem(path, raw) {
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) return `${path} must be a mapping`;
+  for (const key of unknownKeys(raw, BOUNDARY_KEYS)) return `${path}: unknown field ${key}`;
+  const b = raw;
+  if (b.maxMinutes !== void 0 && (!Number.isInteger(b.maxMinutes) || b.maxMinutes < MIN_BOUNDARY_MINUTES))
+    return `${path}.maxMinutes must be an integer >= ${MIN_BOUNDARY_MINUTES}`;
+  if (b.maxIdentity !== void 0 && !IDENTITIES.includes(b.maxIdentity))
+    return `${path}.maxIdentity is "${String(b.maxIdentity)}" \u2014 valid identities: ${IDENTITIES.join(", ")}`;
+  if (b.machines !== void 0) {
+    if (!Array.isArray(b.machines)) return `${path}.machines must be a list of classes`;
+    if (b.machines.length === 0) return `${path}.machines must name at least one class`;
+    for (const m of b.machines) {
+      if (!MACHINE_CLASSES.includes(m))
+        return `${path}.machines names "${String(m)}" \u2014 valid classes: ${MACHINE_CLASSES.join(", ")}`;
+    }
+  }
+  return void 0;
+}
+function validateBoundaries(layer, source2) {
+  const check = (path, raw) => {
+    if (raw === void 0) return;
+    const problem = boundaryProblem(path, raw);
+    if (problem) throw new Error(`${source2}: ${problem}`);
+  };
+  check("defaults.boundary", layer.defaults?.boundary);
+  for (const [kind, scopes] of [
+    ["channels", layer.channels],
+    ["users", layer.users]
+  ]) {
+    for (const [id, scope] of Object.entries(scopes ?? {})) check(`${kind}.${id}.boundary`, scope.boundary);
+  }
+}
 function validateMcpServers(layer, source2) {
   const check = (path, tier, servers) => {
     if (servers === void 0) return;
@@ -2371,6 +2490,7 @@ function validateMcpServers(layer, source2) {
 function validateConfig(cfg) {
   for (const key of unknownKeys(cfg, CONFIG_KEYS)) throw new Error(`config.yaml: unknown key \`${key}\``);
   validateScopeEfforts(cfg, "config.yaml");
+  validateBoundaries(cfg, "config.yaml");
   validateMcpServers(cfg, "config.yaml");
   if (typeof cfg.organization !== "string" || cfg.organization.trim() === "") {
     throw new Error(
@@ -2470,7 +2590,7 @@ function validateRuntimeOverrides(ro) {
     }
   }
 }
-var MAX_INSTRUCTIONS_LENGTH, CONFIG_KEYS, SELF_IMPROVEMENT_KEYS;
+var MAX_INSTRUCTIONS_LENGTH, CONFIG_KEYS, SELF_IMPROVEMENT_KEYS, BOUNDARY_KEYS, MIN_BOUNDARY_MINUTES;
 var init_validate = __esm({
   "../../src/config/validate.ts"() {
     "use strict";
@@ -2512,6 +2632,90 @@ var init_validate = __esm({
       minRuns: true,
       top: true
     };
+    BOUNDARY_KEYS = { maxMinutes: true, maxIdentity: true, machines: true };
+    MIN_BOUNDARY_MINUTES = 2;
+  }
+});
+
+// ../../src/config/profile.ts
+function clipSourceLabel(scope) {
+  return scope === "directive" ? "budget directive" : `${scope} boundary`;
+}
+function identityWithin(identity2, cap) {
+  return IDENTITY_ORDER[identity2] <= IDENTITY_ORDER[cap];
+}
+function declaredProfile(preset) {
+  return { machine: preset.machine, identity: preset.identity, minutes: preset.maxMinutes };
+}
+function budgetedAgent(agent, profile) {
+  return { ...agent, maxMinutes: profile.minutes };
+}
+function intersectBoundaries(layers) {
+  const out = {};
+  for (const { scope, boundary } of layers) {
+    if (boundary.maxMinutes !== void 0 && (!out.maxMinutes || boundary.maxMinutes < out.maxMinutes.value)) {
+      out.maxMinutes = { value: boundary.maxMinutes, scope };
+    }
+    if (boundary.maxIdentity !== void 0 && (!out.maxIdentity || !identityWithin(out.maxIdentity.value, boundary.maxIdentity))) {
+      out.maxIdentity = { value: boundary.maxIdentity, scope };
+    }
+    if (boundary.machines !== void 0) {
+      const allowed = boundary.machines;
+      const value = (out.machines ? out.machines.value : allowed).filter((m) => allowed.includes(m)).sort((a, b) => MACHINE_ORDER[a] - MACHINE_ORDER[b]);
+      out.machines = { value, by: [...out.machines?.by ?? [], { scope, machines: [...allowed] }] };
+    }
+  }
+  return out.maxMinutes || out.maxIdentity || out.machines ? out : void 0;
+}
+function effectiveProfile(preset, directives, boundary) {
+  if (boundary?.maxIdentity && !identityWithin(preset.identity, boundary.maxIdentity.value)) {
+    return {
+      kind: "refused",
+      refusal: {
+        axis: "identity",
+        needs: preset.identity,
+        cap: boundary.maxIdentity.value,
+        scope: boundary.maxIdentity.scope
+      }
+    };
+  }
+  if (boundary?.machines && !boundary.machines.value.includes(preset.machine)) {
+    return {
+      kind: "refused",
+      refusal: {
+        axis: "machine",
+        needs: preset.machine,
+        allowed: boundary.machines.value,
+        scopes: boundary.machines.by.filter((b) => !b.machines.includes(preset.machine)).map((b) => b.scope)
+      }
+    };
+  }
+  let minutes = preset.maxMinutes;
+  let boundedBy;
+  if (directives.budget !== void 0 && directives.budget < minutes) {
+    minutes = directives.budget;
+    boundedBy = "directive";
+  }
+  if (boundary?.maxMinutes && boundary.maxMinutes.value < minutes) {
+    minutes = boundary.maxMinutes.value;
+    boundedBy = boundary.maxMinutes.scope;
+  }
+  return {
+    kind: "profile",
+    profile: {
+      machine: preset.machine,
+      identity: preset.identity,
+      minutes,
+      ...boundedBy !== void 0 ? { boundedBy } : {}
+    }
+  };
+}
+var IDENTITY_ORDER, MACHINE_ORDER;
+var init_profile = __esm({
+  "../../src/config/profile.ts"() {
+    "use strict";
+    IDENTITY_ORDER = { none: 0, read: 1, write: 2 };
+    MACHINE_ORDER = { none: 0, blank: 1, "repo-cold": 2, "repo-resident": 3 };
   }
 });
 
@@ -2590,6 +2794,7 @@ function formatConfigDescription(d) {
   const orgMcp = d.org?.mcpServers && Object.keys(d.org.mcpServers).length > 0 ? `, mcp ${Object.keys(d.org.mcpServers).map((n2) => `\`${n2}\``).join(" ")}` : "";
   const lines = [
     `*Effective for you in this channel:* ${effective}`,
+    ...d.effective.boundary ? [`*Effective boundary:* ${fmtEffectiveBoundary(d.effective.boundary)}`] : [],
     `*Defaults:* ${defaults}${orgMcp}`,
     `*Channel scope:* ${fmtScope(d.channel)}`,
     `*Your scope:* ${fmtScope(d.user)}`
@@ -2614,8 +2819,26 @@ function fmtScope(s) {
     parts.push(
       `mcp ${Object.keys(s.mcpServers).map((n2) => `\`${n2}\``).join(" ")}`
     );
+  if (s.boundary) parts.push(`boundary ${fmtBoundary(s.boundary)}`);
   return parts.length > 0 ? parts.join(", ") : "_none_";
 }
+function fmtBoundary(b) {
+  const parts = [];
+  if (b.maxMinutes !== void 0) parts.push(`maxMinutes=${b.maxMinutes}`);
+  if (b.maxIdentity !== void 0) parts.push(`maxIdentity=${b.maxIdentity}`);
+  if (b.machines !== void 0) parts.push(`machines=${b.machines.join(",")}`);
+  return parts.length > 0 ? parts.join(" ") : "(caps nothing)";
+}
+function fmtEffectiveBoundary(b) {
+  const parts = [];
+  if (b.maxMinutes) parts.push(`maxMinutes ${b.maxMinutes.value} (${b.maxMinutes.scope})`);
+  if (b.maxIdentity) parts.push(`maxIdentity \`${b.maxIdentity.value}\` (${b.maxIdentity.scope})`);
+  if (b.machines)
+    parts.push(
+      `machines ${b.machines.value.map((m) => `\`${m}\``).join(", ")} (${b.machines.by.map((l) => l.scope).join(", ")})`
+    );
+  return parts.join(", ");
+}
 function fmtModels(m) {
   return Object.entries(m).map(([k, v]) => `\`${k}=${v}\``).join(" ");
 }
@@ -2632,6 +2855,7 @@ var init_config = __esm({
     init_schedules();
     init_registry();
     init_validate();
+    init_profile();
     FileOverridesBacking = class {
       path;
       constructor(path) {
@@ -2752,6 +2976,7 @@ var init_config = __esm({
         doc.users ??= {};
         validateInstructions(doc, `overrides (${this.backing.describe()})`);
         validateScopeEfforts(doc, `overrides (${this.backing.describe()})`);
+        validateBoundaries(doc, `overrides (${this.backing.describe()})`);
         validateMcpServers(
           { channels: doc.channels, users: doc.users, defaults: doc.org },
           `overrides (${this.backing.describe()})`
@@ -2843,22 +3068,43 @@ var init_config = __esm({
         return { channel: this.channelScope(channelId), user: this.userScope(userId) };
       }
       /**
-       * Resolve which agent, model, and effort serve a request.
-       * Agent:  request directive > user scope > channel scope > default.
-       * Model:  request directive > (user > channel) forced model
-       *         > (user > channel > defaults) per-agent model.
-       * Effort: the same ladder as model; unset at every layer → undefined.
+       * Resolve which agent, model, and effort serve a request, and the boundary
+       * every run on this path meets.
+       * Agent:    request directive > user scope > channel scope > default.
+       * Model:    request directive > (user > channel) forced model
+       *           > (user > channel > defaults) per-agent model.
+       * Effort:   the same ladder as model; unset at every layer → undefined.
+       * Boundary: NOT a ladder — the defaults', the channel's and the user's
+       *           boundaries intersect (the smallest budget, the lowest identity,
+       *           the classes every layer allows), so a scope can only tighten what
+       *           the layers below it allow; no layer set → absent.
        */
       resolve(opts) {
         const ch = this.channelScope(opts.channelId);
         const us = this.userScope(opts.userId);
         const agentName = opts.request.agent ?? us.agent ?? ch.agent ?? this.config.defaults.agent;
+        const boundary = intersectBoundaries(this.boundaryLayers(ch, us));
         const modelRef2 = opts.request.model ?? us.model ?? ch.model ?? us.models?.[agentName] ?? ch.models?.[agentName] ?? this.config.defaults.models[agentName] ?? this.config.defaults.models["general"];
         if (!modelRef2) {
           throw new Error(`No model configured for agent "${agentName}" \u2014 set defaults.models.${agentName} in config.yaml`);
         }
         const effort2 = opts.request.effort ?? us.effort ?? ch.effort ?? us.efforts?.[agentName] ?? ch.efforts?.[agentName] ?? this.config.defaults.efforts?.[agentName];
-        return { agentName, modelRef: modelRef2, ...effort2 !== void 0 ? { effort: effort2 } : {} };
+        return {
+          agentName,
+          modelRef: modelRef2,
+          ...effort2 !== void 0 ? { effort: effort2 } : {},
+          ...boundary !== void 0 ? { boundary } : {}
+        };
+      }
+      /** The boundary layers on a path, in resolution order, keeping only the
+       *  scopes that set one — `intersectBoundaries` names each axis's scope from it. */
+      boundaryLayers(channel, user) {
+        const layers = [
+          ["defaults", this.config.defaults.boundary],
+          ["channel", channel.boundary],
+          ["user", user.boundary]
+        ];
+        return layers.flatMap(([scope, boundary]) => boundary ? [{ scope, boundary }] : []);
       }
       // ---- authorization gates ----------------------------------------------------
       // Every gate reads the grants table (authorization.md item 9): what an actor
@@ -2983,7 +3229,8 @@ var init_config = __esm({
           effective: {
             agent: resolved.agentName,
             model: resolved.modelRef,
-            ...resolved.effort ? { effort: resolved.effort } : {}
+            ...resolved.effort ? { effort: resolved.effort } : {},
+            ...resolved.boundary ? { boundary: resolved.boundary } : {}
           },
           defaults: {
             agent: this.config.defaults.agent,
@@ -3967,8 +4214,8 @@ var init_tracer = __esm({
           delete this.rec.errorMessage;
           return;
         }
-        const message = err2 instanceof Error ? err2.message : String(err2);
-        this.rec.errorMessage = redactAndCap(message, ERROR_MESSAGE_CAP);
+        const message2 = err2 instanceof Error ? err2.message : String(err2);
+        this.rec.errorMessage = redactAndCap(message2, ERROR_MESSAGE_CAP);
       }
       setAttrs(attrs) {
         this.rec.attrs = { ...this.rec.attrs, ...attrs };
@@ -4187,7 +4434,7 @@ function isExampleProfile(p) {
   return p.account === EXAMPLE_ACCOUNT;
 }
 var WORKER_KINDS, PROFILE_PATH, PROFILE_EXAMPLE_PATH, PROFILE_ENV, hostname, endpoint, source, IMAGE_MODES, profileSchema, EXAMPLE_ACCOUNT;
-var init_profile = __esm({
+var init_profile2 = __esm({
   "../../src/deploy/profile.ts"() {
     "use strict";
     WORKER_KINDS = ["memory", "bot", "resident", "sandbox"];
@@ -4452,7 +4699,7 @@ var init_plan = __esm({
     init_configDocument();
     init_images();
     init_operatorRoot();
-    init_profile();
+    init_profile2();
     UNSET_ENV = ["CLOUDFLARE_ACCOUNT_ID"];
     SANDBOX_CONTAINER_CLASS = "SwitchboardSandbox";
     SANDBOX_BEARER_ENV = "SANDBOX_TOKEN";
@@ -5203,7 +5450,7 @@ var init_wranglerTemplate = __esm({
     "use strict";
     init_images();
     init_plan();
-    init_profile();
+    init_profile2();
     init_images();
     TEMPLATE_FILE = "wrangler.template.jsonc";
     RENDERED_FILE = "wrangler.jsonc";
@@ -5402,7 +5649,7 @@ var init_restart = __esm({
     init_ingressTokens();
     init_authorize();
     init_liveGate();
-    init_profile();
+    init_profile2();
     RESTART_TOKEN_ENV = "SWITCHBOARD_DEPLOY_TOKEN";
     RESTART_SCOPE = "deploy:write";
     RESTART_AUTHORIZE_PATH = "/admin/restart/authorize";
@@ -6383,7 +6630,7 @@ var init_run = __esm({
     init_wranglerTemplate();
     init_configSource();
     init_images();
-    init_profile();
+    init_profile2();
     init_restart();
     init_wranglerTemplate();
     init_sandboxLiveGate();
@@ -6865,8 +7112,8 @@ var init_registryTransferHost = __esm({
     SHORT_MS = 6e4;
     LONG_MS = 30 * 6e4;
     TransferProblem = class extends Error {
-      constructor(message, unauthorized = false) {
-        super(message);
+      constructor(message2, unauthorized = false) {
+        super(message2);
         this.unauthorized = unauthorized;
       }
       unauthorized;
@@ -7493,7 +7740,7 @@ var TEMPLATE_PATHS;
 var init_host3 = __esm({
   "../../src/setup/host.ts"() {
     "use strict";
-    init_profile();
+    init_profile2();
     init_packageRoot();
     init_host();
     init_meatProcess();
@@ -7505,42 +7752,6 @@ var init_host3 = __esm({
   }
 });
 
-// ../../src/execution/bashTimeout.ts
-function clampBashTimeout(requested) {
-  if (typeof requested !== "number" || !Number.isFinite(requested)) return BASH_TIMEOUT_MS;
-  return Math.min(Math.max(Math.trunc(requested), BASH_TIMEOUT_MIN_MS), BASH_TIMEOUT_MAX_MS);
-}
-function bashBudgetWithinRun(wantedMs, remainingMs) {
-  const secs = (ms) => Math.max(0, Math.round(ms / 1e3));
-  const cap = Math.trunc(remainingMs - RUN_DEADLINE_RESERVE_MS);
-  if (cap < BASH_TIMEOUT_MIN_MS) {
-    return {
-      kind: "exhausted",
-      note: `run budget exhausted \u2014 ${secs(remainingMs)}s of wall clock left, inside the ${secs(RUN_DEADLINE_RESERVE_MS)}s write-up reserve, so the command was not run; write up what you have now`
-    };
-  }
-  if (cap >= wantedMs) return { kind: "unchanged" };
-  return {
-    kind: "clipped",
-    timeoutMs: cap,
-    note: `[timeout clipped to ${secs(cap)}s \u2014 the run's wall clock ends in ${secs(remainingMs)}s]`
-  };
-}
-function bashTimeoutNote(timeoutMs) {
-  return `aborted at the ${Math.round(timeoutMs / 1e3)}s command timeout (pass the bash tool's timeoutMs for longer commands, max ${BASH_TIMEOUT_MAX_MS} ms)`;
-}
-var BASH_TIMEOUT_MS, BASH_TIMEOUT_MIN_MS, BASH_TIMEOUT_MAX_MS, RUN_DEADLINE_RESERVE_MS, EXEC_CALL_MARGIN_MS;
-var init_bashTimeout = __esm({
-  "../../src/execution/bashTimeout.ts"() {
-    "use strict";
-    BASH_TIMEOUT_MS = 5 * 6e4;
-    BASH_TIMEOUT_MIN_MS = 1e3;
-    BASH_TIMEOUT_MAX_MS = 20 * 6e4;
-    RUN_DEADLINE_RESERVE_MS = 6e4;
-    EXEC_CALL_MARGIN_MS = 3e4;
-  }
-});
-
 // ../../src/execution/executor.ts
 import { execFile } from "node:child_process";
 import { existsSync as existsSync8, mkdirSync as mkdirSync5, readFileSync as readFileSync9, writeFileSync as writeFileSync5 } from "node:fs";
@@ -7598,15 +7809,15 @@ var init_executor = __esm({
     init_bashTimeout();
     ExecInfraError = class extends Error {
       infra = true;
-      constructor(message) {
-        super(message);
+      constructor(message2) {
+        super(message2);
         this.name = "ExecInfraError";
       }
     };
     ExecCapacityError = class extends Error {
       capacity = true;
-      constructor(message) {
-        super(message);
+      constructor(message2) {
+        super(message2);
         this.name = "ExecCapacityError";
       }
     };
@@ -8901,9 +9112,19 @@ var init_residentState = __esm({
 import { resolve as resolve7 } from "node:path";
 import { mkdirSync as mkdirSync7 } from "node:fs";
 async function makeExecutor(opts, ctx, span) {
-  if (ctx.agent.resources?.repo !== "required") {
+  const machine = ctx.profile.machine;
+  if (machine === "none") {
     return { executor: new NullExecutor(ctx.agent.name), backend: "local" };
   }
+  if (machine === "blank") {
+    return {
+      executor: await makePerThreadExecutor(opts, { threadKey: ctx.threadKey, resolveEnvs: async () => ({}) }),
+      backend: perThreadBackend(opts)
+    };
+  }
+  if (machine === "repo-cold") {
+    return { executor: await makePerThreadExecutor(opts, perThreadCheckout(ctx)), backend: perThreadBackend(opts) };
+  }
   let note;
   let failedAttach;
   if (ctx.repo && opts.execution?.resident) {
@@ -8916,7 +9137,7 @@ async function makeExecutor(opts, ctx, span) {
     if (probe.kind === "status" && isServiceable(probe.state, probe.reason)) {
       try {
         const nonWarm = probe.state === "warm" ? void 0 : oneLine(`${probe.state}${probe.reason ? ` (${probe.reason})` : ""}`);
-        const readonly = ctx.agent.toolset === "readonly" ? true : void 0;
+        const readonly = ctx.profile.identity === "read" ? true : void 0;
         return await openResident(
           {
             baseUrl: resident.baseUrl,
@@ -8946,7 +9167,7 @@ async function makeExecutor(opts, ctx, span) {
     }
   }
   return {
-    executor: await makePerThreadExecutor(opts, ctx),
+    executor: await makePerThreadExecutor(opts, perThreadCheckout(ctx)),
     note,
     backend: perThreadBackend(opts),
     ...failedAttach ? { trace: failedAttach.steps } : {}
@@ -9041,8 +9262,16 @@ function localWorkspaceDir(baseDir, threadKey) {
   const safe = threadKey.replace(/[^a-zA-Z0-9_.-]/g, "_");
   return resolve7(baseDir, safe);
 }
-async function makePerThreadExecutor(opts, ctx) {
-  const { threadKey } = ctx;
+function perThreadCheckout(ctx) {
+  return {
+    threadKey: ctx.threadKey,
+    repo: ctx.repo,
+    ref: ctx.ref,
+    resolveEnvs: () => githubEnvs(ctx.profile.identity)
+  };
+}
+async function makePerThreadExecutor(opts, input) {
+  const { threadKey } = input;
   const type = opts.execution?.type ?? "local";
   if (type === "local") {
     const dir = localWorkspaceDir(opts.workspaceDir, threadKey);
@@ -9058,9 +9287,9 @@ async function makePerThreadExecutor(opts, ctx) {
       threadKey,
       timeoutMs: (opts.execution?.timeoutMinutes ?? 30) * 6e4,
       statePath: resolve7(opts.dataDir, "sandboxes.json"),
-      resolveEnvs: () => githubEnvs(ctx.agent),
-      repo: ctx.repo,
-      ref: ctx.ref
+      resolveEnvs: input.resolveEnvs,
+      repo: input.repo,
+      ref: input.ref
     });
   }
   if (type === "cloudflare") {
@@ -9074,15 +9303,19 @@ async function makePerThreadExecutor(opts, ctx) {
       url: opts.execution.url,
       token: token.reveal(),
       threadKey,
-      resolveEnvs: () => githubEnvs(ctx.agent),
-      repo: ctx.repo,
-      ref: ctx.ref
+      resolveEnvs: input.resolveEnvs,
+      repo: input.repo,
+      ref: input.ref
     });
   }
   throw new Error(`Unknown execution.type "${type}" (valid: local, e2b, cloudflare)`);
 }
-async function githubEnvs(agent) {
-  const scope = agent.toolset === "readonly" ? "read" : "write";
+function githubTokenScopeFor(identity2) {
+  return identity2 === "none" ? void 0 : identity2;
+}
+async function githubEnvs(identity2) {
+  const scope = githubTokenScopeFor(identity2);
+  if (scope === void 0) return {};
   const token = await resolveGithubToken(scope);
   return token ? { GH_TOKEN: token } : {};
 }
@@ -9113,7 +9346,7 @@ var init_factory = __esm({
       agentName;
       fail() {
         throw new Error(
-          `Agent "${this.agentName}" declares no repo resource, so it has no execution workspace. Declare resources: { repo: "required" } on the agent if its tools need one.`
+          `Agent "${this.agentName}" runs on machine class "none", so it has no execution workspace. Declare a machine class that provisions one (\`repo-resident\`, \`repo-cold\` or \`blank\`) if its tools need one.`
         );
       }
       async exec() {
@@ -9151,9 +9384,9 @@ function parseFindings(body) {
 function isAgentLogin(login, identities) {
   return login.endsWith("[bot]") || identities.agentLogins.includes(login);
 }
-function coauthorsOf(message) {
+function coauthorsOf(message2) {
   const out = [];
-  for (const line3 of message.split("\n")) {
+  for (const line3 of message2.split("\n")) {
     const m = /^\s*co-authored-by:\s*(.+?)\s*$/i.exec(line3);
     if (m) out.push(m[1]);
   }
@@ -9346,9 +9579,25 @@ function indicatorLines(x) {
     `agent runs: ${x.agentRuns.count} \xB7 ${x.agentRuns.minutes.toFixed(1)} min`
   ];
 }
-function renderDeliveryReport(report2) {
+function snapshotAgeText(snapshotAt, nowMs) {
+  const minutes = Math.max(0, Math.floor((nowMs - Date.parse(snapshotAt)) / 6e4));
+  if (!Number.isFinite(minutes)) return "";
+  const unit = (n2, word) => `${n2} ${word}${n2 === 1 ? "" : "s"} ago`;
+  if (minutes < 1) return "just now";
+  if (minutes < 90) return unit(minutes, "minute");
+  const hours2 = Math.round(minutes / 60);
+  if (hours2 < 48) return unit(hours2, "hour");
+  return unit(Math.round(hours2 / 24), "day");
+}
+function asOf(snapshotAt, nowMs) {
+  return `as of ${snapshotAt.slice(0, 10)} ${snapshotAt.slice(11, 16)} UTC, ${snapshotAgeText(snapshotAt, nowMs)}`;
+}
+function renderDeliveryReport(report2, nowMs = systemClock()) {
   const lines = [
-    `${report2.repo} \xB7 ${report2.range.since} \u2192 ${report2.range.until} \xB7 ${report2.range.weeks} week${report2.range.weeks === 1 ? "" : "s"}`
+    [
+      `${report2.repo} \xB7 ${report2.range.since} \u2192 ${report2.range.until} \xB7 ${report2.range.weeks} week${report2.range.weeks === 1 ? "" : "s"}`,
+      ...report2.snapshotAt !== void 0 ? [asOf(report2.snapshotAt, nowMs)] : []
+    ].join(" \xB7 ")
   ];
   if (report2.truncated) lines.push("(the newest pull requests only \u2014 the fetch stopped before the range's start)");
   for (const w of report2.weeks) {
@@ -9390,6 +9639,18 @@ function stringList(raw, what, valid = () => true) {
     throw new Error(`${what} must be a list of ${what.endsWith("repos") ? "owner/name repositories" : "names"}`);
   return raw;
 }
+function snapshotConfig(raw) {
+  if (raw === void 0) return { everyMinutes: SNAPSHOT_EVERY_MINUTES.default };
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw))
+    throw new Error("delivery.snapshot must be a mapping");
+  const every = raw.everyMinutes;
+  if (every === void 0) return { everyMinutes: SNAPSHOT_EVERY_MINUTES.default };
+  if (typeof every !== "number" || !Number.isInteger(every) || every < SNAPSHOT_EVERY_MINUTES.min || every > SNAPSHOT_EVERY_MINUTES.max)
+    throw new Error(
+      `delivery.snapshot.everyMinutes must be a whole number of minutes between ${SNAPSHOT_EVERY_MINUTES.min} and ${SNAPSHOT_EVERY_MINUTES.max}`
+    );
+  return { everyMinutes: every };
+}
 function parseDeliveryConfig(raw) {
   if (raw === void 0 || raw === null) return void 0;
   if (typeof raw !== "object" || Array.isArray(raw)) throw new Error("delivery: must be a mapping");
@@ -9398,7 +9659,8 @@ function parseDeliveryConfig(raw) {
     repos: stringList(r.repos, "delivery.repos", (s) => REPO_SLUG.test(s)),
     reviewers: stringList(r.reviewers, "delivery.reviewers"),
     agentLogins: stringList(r.agentLogins, "delivery.agentLogins"),
-    agentCoauthors: stringList(r.agentCoauthors, "delivery.agentCoauthors")
+    agentCoauthors: stringList(r.agentCoauthors, "delivery.agentCoauthors"),
+    snapshot: snapshotConfig(r.snapshot)
   };
 }
 function createDeliveryService(cfg, source2, opts = {}) {
@@ -9408,9 +9670,10 @@ function createDeliveryService(cfg, source2, opts = {}) {
     repos: () => [...cfg?.repos ?? []],
     async report(repo, o) {
       if (!REPO_SLUG.test(repo)) throw new Error(`repository must be owner/name, got ${JSON.stringify(repo)}`);
-      const range = resolveDeliveryRange({ since: o.since, weeks: o.weeks }, now());
+      const at = now();
+      const range = resolveDeliveryRange({ since: o.since, weeks: o.weeks }, at);
       const [fetched, process2, runs] = await Promise.all([
-        source2.fetchPullRequests(repo, range),
+        source2.fetchPullRequests(repo, range, o.fresh ? { fresh: true } : void 0),
         opts.identities?.() ?? Promise.resolve({}),
         o.runs?.(range) ?? Promise.resolve([])
       ]);
@@ -9419,18 +9682,22 @@ function createDeliveryService(cfg, source2, opts = {}) {
         agentLogins: [.../* @__PURE__ */ new Set([...cfg?.agentLogins ?? [], ...process2.agentLogins ?? []])],
         agentCoauthors: [.../* @__PURE__ */ new Set([...cfg?.agentCoauthors ?? [], ...process2.agentCoauthors ?? []])]
       };
-      return buildDeliveryReport({
-        repo,
-        range,
-        prs: fetched.prs,
-        runs,
-        identities,
-        truncated: fetched.truncated
-      });
+      return {
+        ...buildDeliveryReport({
+          repo,
+          range,
+          prs: fetched.prs,
+          runs,
+          identities,
+          truncated: fetched.truncated
+        }),
+        // A source behind a snapshot says when it read; a bare one read just now.
+        snapshotAt: fetched.fetchedAt ?? at.toISOString()
+      };
     }
   };
 }
-var FINDING_SEVERITIES, DAY_MS, HOUR_MS, emptyCounts, CI_TRIGGERS, CI_DECISIVE, byTime, EMPTY_IDENTITIES, DEFAULT_WEEKS, MAX_WEEKS, ISO_DAY, pct, hours, REPO_SLUG, DELIVERY_OFF_MESSAGE, NullDeliveryService;
+var FINDING_SEVERITIES, DAY_MS, HOUR_MS, emptyCounts, CI_TRIGGERS, CI_DECISIVE, byTime, EMPTY_IDENTITIES, DEFAULT_WEEKS, MAX_WEEKS, ISO_DAY, pct, hours, SNAPSHOT_EVERY_MINUTES, REPO_SLUG, DELIVERY_OFF_MESSAGE, NullDeliveryService;
 var init_delivery = __esm({
   "../../src/core/delivery.ts"() {
     "use strict";
@@ -9458,6 +9725,7 @@ var init_delivery = __esm({
     ISO_DAY = /^\d{4}-\d{2}-\d{2}$/;
     pct = (share) => share === null ? "\u2014" : `${Math.round(share * 100)}%`;
     hours = (h, digits2 = 1) => h === null ? "\u2014" : `${h.toFixed(digits2)} h`;
+    SNAPSHOT_EVERY_MINUTES = Object.freeze({ default: 60, min: 5, max: 1440 });
     REPO_SLUG = /^(?!\.+\/)[\w.-]+\/(?!\.+$)[\w.-]+$/;
     DELIVERY_OFF_MESSAGE = "Delivery indicators aren't available \u2014 this process has no GitHub credential (the GitHub App triple or GH_TOKEN); set one, then name repositories under delivery.repos.";
     NullDeliveryService = class {
@@ -9711,12 +9979,16 @@ var init_githubDelivery = __esm({
         const json = async (res) => res.status === 404 ? void 0 : res.json();
         const merged = [];
         let truncated = false;
+        let oldestUpdated;
         for (let page2 = 1; ; page2++) {
           const res = await get(
             "pulls",
             `/repos/${repo}/pulls?state=closed&sort=updated&direction=desc&per_page=${PAGE_SIZE}&page=${page2}`
           );
           const items = parsePullListPage(await json(res));
+          for (const item of items) {
+            if (!oldestUpdated || Date.parse(item.updatedAt) < Date.parse(oldestUpdated.updatedAt)) oldestUpdated = item;
+          }
           const selected = selectMerged(items, range);
           merged.push(...selected.merged);
           if (selected.olderSeen || items.length < PAGE_SIZE) break;
@@ -9725,6 +9997,7 @@ var init_githubDelivery = __esm({
             break;
           }
         }
+        const completeFrom = truncated && oldestUpdated ? oldestUpdated.updatedAt : `${range.since}T00:00:00Z`;
         const issues = /* @__PURE__ */ new Map();
         const issueOf = (n2) => {
           let p = issues.get(n2);
@@ -9771,12 +10044,257 @@ var init_githubDelivery = __esm({
             ...issue ? { issue } : {}
           };
         });
-        return { prs, truncated };
+        return { prs, truncated, completeFrom };
+      }
+    };
+  }
+});
+
+// ../../src/core/deliverySnapshot.ts
+function snapshotAgeMinutes(snapshotAt, nowMs) {
+  return Math.max(0, Math.floor((nowMs - Date.parse(snapshotAt)) / 6e4));
+}
+function serve(snapshot, range) {
+  return {
+    prs: snapshot.prs,
+    truncated: dayStart(range.since) < Date.parse(snapshot.completeFrom),
+    fetchedAt: snapshot.snapshotAt
+  };
+}
+var SNAPSHOT_WEEKS, SNAPSHOT_TICK_MS, dayStart, message, SnapshottingDeliverySource;
+var init_deliverySnapshot = __esm({
+  "../../src/core/deliverySnapshot.ts"() {
+    "use strict";
+    init_delivery();
+    init_clock();
+    SNAPSHOT_WEEKS = 13;
+    SNAPSHOT_TICK_MS = 6e4;
+    dayStart = (day) => Date.parse(`${day}T00:00:00Z`);
+    message = (err2) => err2 instanceof Error ? err2.message : String(err2);
+    SnapshottingDeliverySource = class {
+      constructor(inner, store, opts = {}) {
+        this.inner = inner;
+        this.store = store;
+        this.now = opts.now ?? (() => new Date(systemClock()));
+        this.warn = opts.warn ?? (() => void 0);
+        this.weeks = opts.weeks ?? SNAPSHOT_WEEKS;
+      }
+      inner;
+      store;
+      memory = /* @__PURE__ */ new Map();
+      /** Store reads in flight, one per repository. */
+      loading = /* @__PURE__ */ new Map();
+      /** GitHub reads in flight, one per repository: concurrent callers share it. */
+      refreshing = /* @__PURE__ */ new Map();
+      now;
+      warn;
+      weeks;
+      async fetchPullRequests(repo, range, opts) {
+        const snapshot = opts?.fresh ? void 0 : await this.current(repo);
+        if (snapshot && range.since >= snapshot.range.since) return serve(snapshot, range);
+        if (range.since < this.window().since) return this.live(repo, range);
+        return serve(await this.refresh(repo), range);
+      }
+      /** The repository's snapshot as this process knows it: memory, else the store, read once. */
+      current(repo) {
+        const known = this.memory.get(repo);
+        if (known) return Promise.resolve(known);
+        let loading = this.loading.get(repo);
+        if (!loading) {
+          loading = this.store.get(repo).then((stored) => {
+            if (stored) this.memory.set(repo, stored);
+            return stored;
+          }).catch((err2) => {
+            this.warn(`delivery snapshot for ${repo} not read from the store: ${message(err2)}`);
+            return void 0;
+          }).finally(() => this.loading.delete(repo));
+          this.loading.set(repo, loading);
+        }
+        return loading;
+      }
+      /** Read the window from GitHub now, keep it in memory and store it. One read at a time per repository. */
+      refresh(repo) {
+        let refreshing = this.refreshing.get(repo);
+        if (!refreshing) {
+          refreshing = this.read(repo).finally(() => this.refreshing.delete(repo));
+          this.refreshing.set(repo, refreshing);
+        }
+        return refreshing;
+      }
+      /**
+       * Keep every named repository's snapshot within `everyMinutes`: a tick a
+       * minute (unref'd — it never holds the process open) refreshes the ones
+       * missing or older than the interval, one repository at a time, and runs
+       * once at start so a stale snapshot after a restart is refreshed at once
+       * and a young one is left alone. A failing refresh is a warning; the next
+       * tick tries again. `tick()` is the pass itself, for tests.
+       */
+      startRefreshLoop(opts) {
+        let running;
+        const pass = async () => {
+          for (const repo of opts.repos) {
+            try {
+              const current = await this.current(repo);
+              if (current && snapshotAgeMinutes(current.snapshotAt, this.now().getTime()) < opts.everyMinutes) continue;
+              await this.refresh(repo);
+            } catch (err2) {
+              this.warn(`delivery snapshot for ${repo} not refreshed: ${message(err2)}`);
+            }
+          }
+        };
+        const tick = () => running ??= pass().finally(() => {
+          running = void 0;
+        });
+        const start2 = opts.setInterval ?? ((fn, ms) => {
+          const t = setInterval(fn, ms);
+          t.unref?.();
+          return t;
+        });
+        const stop = opts.clearInterval ?? ((t) => clearInterval(t));
+        const timer = start2(() => void tick(), SNAPSHOT_TICK_MS);
+        timer.unref?.();
+        void tick();
+        return { stop: () => stop(timer), tick };
+      }
+      window() {
+        return resolveDeliveryRange({ weeks: this.weeks }, this.now());
+      }
+      async live(repo, range) {
+        const startedAt = this.now();
+        const fetched = await this.inner.fetchPullRequests(repo, range);
+        return { prs: fetched.prs, truncated: fetched.truncated, fetchedAt: startedAt.toISOString() };
+      }
+      async read(repo) {
+        const startedAt = this.now();
+        const range = resolveDeliveryRange({ weeks: this.weeks }, startedAt);
+        const fetched = await this.inner.fetchPullRequests(repo, range);
+        const snapshot = {
+          repo,
+          snapshotAt: startedAt.toISOString(),
+          range,
+          prs: fetched.prs,
+          truncated: fetched.truncated,
+          completeFrom: fetched.completeFrom ?? `${range.since}T00:00:00Z`
+        };
+        this.memory.set(repo, snapshot);
+        try {
+          await this.store.put(snapshot);
+        } catch (err2) {
+          this.warn(`delivery snapshot for ${repo} not stored: ${message(err2)}`);
+        }
+        return snapshot;
       }
     };
   }
 });
 
+// ../../src/core/workerError.ts
+async function errorSuffix(res) {
+  const text = await res.text().catch(() => "");
+  try {
+    const parsed = JSON.parse(text);
+    return parsed?.error ? `: ${String(parsed.error)}` : "";
+  } catch {
+    return "";
+  }
+}
+var init_workerError = __esm({
+  "../../src/core/workerError.ts"() {
+    "use strict";
+  }
+});
+
+// ../../src/core/deliverySnapshotStore.ts
+function isPullRequestFacts(v) {
+  if (typeof v !== "object" || v === null) return false;
+  const p = v;
+  return typeof p.number === "number" && Number.isFinite(p.number) && typeof p.title === "string" && typeof p.author === "string" && isInstant(p.createdAt) && isInstant(p.mergedAt) && (p.firstHeadSha === void 0 || typeof p.firstHeadSha === "string") && Array.isArray(p.ci) && Array.isArray(p.reviews) && Array.isArray(p.pushes) && (p.issue === void 0 || typeof p.issue === "object" && p.issue !== null);
+}
+function isDeliverySnapshot(v) {
+  if (typeof v !== "object" || v === null) return false;
+  const s = v;
+  if (typeof s.repo !== "string" || !REPO_SLUG.test(s.repo)) return false;
+  if (!isInstant(s.snapshotAt) || !isInstant(s.completeFrom)) return false;
+  if (typeof s.truncated !== "boolean") return false;
+  const range = s.range;
+  if (typeof range !== "object" || range === null || typeof range.since !== "string" || !ISO_DAY2.test(range.since) || typeof range.until !== "string" || !ISO_DAY2.test(range.until) || typeof range.weeks !== "number" || !Number.isFinite(range.weeks))
+    return false;
+  return Array.isArray(s.prs) && s.prs.every(isPullRequestFacts);
+}
+function buildDeliverySnapshotStore(config, secrets, warn) {
+  const worker = [config.runtimeOverrides, config.runHistory, config.schedules, config.memory].find(
+    (block) => block?.worker?.baseUrl
+  )?.worker;
+  if (!worker) {
+    warn(
+      "delivery snapshots are kept in memory \u2014 a restart loses them and the first request after one reads GitHub live. Name the state Worker (runHistory.worker, runtimeOverrides.worker, schedules.worker or memory.worker) to keep them on it."
+    );
+    return new InMemoryDeliverySnapshotStore();
+  }
+  const tokenEnv = worker.tokenEnv ?? DEFAULT_TOKEN_ENV;
+  const token = secrets.named(tokenEnv);
+  if (!token) {
+    warn(
+      `the state Worker is configured but ${tokenEnv} is unset \u2014 delivery snapshots are kept in memory and a restart loses them. Set ${tokenEnv} to the state Worker's bearer.`
+    );
+    return new InMemoryDeliverySnapshotStore();
+  }
+  return new WorkerDeliverySnapshotStore({ baseUrl: worker.baseUrl, token: token.reveal() });
+}
+var ISO_DAY2, isInstant, InMemoryDeliverySnapshotStore, SNAPSHOT_WORKER_TIMEOUT_MS, WorkerDeliverySnapshotStore, DEFAULT_TOKEN_ENV;
+var init_deliverySnapshotStore = __esm({
+  "../../src/core/deliverySnapshotStore.ts"() {
+    "use strict";
+    init_delivery();
+    init_workerError();
+    ISO_DAY2 = /^\d{4}-\d{2}-\d{2}$/;
+    isInstant = (v) => typeof v === "string" && Number.isFinite(Date.parse(v));
+    InMemoryDeliverySnapshotStore = class {
+      byRepo = /* @__PURE__ */ new Map();
+      async get(repo) {
+        const s = this.byRepo.get(repo);
+        return s ? structuredClone(s) : void 0;
+      }
+      async put(snapshot) {
+        this.byRepo.set(snapshot.repo, structuredClone(snapshot));
+      }
+    };
+    SNAPSHOT_WORKER_TIMEOUT_MS = 3e4;
+    WorkerDeliverySnapshotStore = class {
+      constructor(opts) {
+        this.opts = opts;
+        this.baseUrl = opts.baseUrl.replace(/\/+$/, "");
+        this.fetchImpl = opts.fetch ?? fetch;
+      }
+      opts;
+      baseUrl;
+      fetchImpl;
+      async get(repo) {
+        const res = await this.post("/delivery/get", { repo });
+        if (!res.ok) throw new Error(`state Worker /delivery/get HTTP ${res.status}${await errorSuffix(res)}`);
+        const data = await res.json().catch(() => ({}));
+        if (data.snapshot === null || data.snapshot === void 0) return void 0;
+        if (!isDeliverySnapshot(data.snapshot))
+          throw new Error(`state Worker /delivery/get: the answer for ${repo} is not a delivery snapshot`);
+        return data.snapshot;
+      }
+      async put(snapshot) {
+        const res = await this.post("/delivery/put", { snapshot });
+        if (!res.ok) throw new Error(`state Worker /delivery/put HTTP ${res.status}${await errorSuffix(res)}`);
+      }
+      post(path, body) {
+        return this.fetchImpl(`${this.baseUrl}${path}`, {
+          method: "POST",
+          headers: { "content-type": "application/json", authorization: `Bearer ${this.opts.token}` },
+          body: JSON.stringify(body),
+          signal: AbortSignal.timeout(SNAPSHOT_WORKER_TIMEOUT_MS)
+        });
+      }
+    };
+    DEFAULT_TOKEN_ENV = "MEMORY_TOKEN";
+  }
+});
+
 // ../../src/core/runDuration.ts
 function runDurationMs(stamps, now) {
   const end = stamps.finishedAt ?? now;
@@ -10659,8 +11177,8 @@ function bindCommands(registry, deps) {
     settle: (id, value, caller) => registry.settle(id, value, caller, deps)
   };
 }
-function fail(error, message, decidedBy = "registry") {
-  return { ok: false, error, status: ERROR_STATUS[error], message, decidedBy };
+function fail(error, message2, decidedBy = "registry") {
+  return { ok: false, error, status: ERROR_STATUS[error], message: message2, decidedBy };
 }
 function rawInput(input) {
   const args = typeof input === "object" && input !== null && Array.isArray(input.args) ? input.args : [];
@@ -10779,8 +11297,8 @@ var init_commandRegistry = __esm({
     CAMEL_KEY = /^[a-z][A-Za-z0-9]*$/;
     flag = z4.union([z4.boolean(), z4.enum(["true", "false"]).transform((v) => v === "true")]);
     CommandError = class extends Error {
-      constructor(code, message) {
-        super(message);
+      constructor(code, message2) {
+        super(message2);
         this.code = code;
         this.name = "CommandError";
       }
@@ -10934,12 +11452,13 @@ function summarizeScope(s) {
 function registerConfigCommands(registry) {
   for (const cmd of configCommands) registry.register(cmd);
 }
-var defineCommand2, scopeArg, channelOption, effort, effortLevels, modelRef, who, configShow, configSet, configClear, quote, configInstructions, configCommands;
+var defineCommand2, scopeArg, channelOption, effort, effortLevels, modelRef, boundaryOption, who, configShow, configSet, configClear, quote, configInstructions, configCommands;
 var init_config3 = __esm({
   "../../src/core/commands/config.ts"() {
     "use strict";
     init_config();
     init_validate();
+    init_registry();
     init_effort();
     init_authorize();
     init_commandRegistry();
@@ -10953,6 +11472,11 @@ var init_config3 = __esm({
     effort = z5.enum(EFFORT_LEVELS);
     effortLevels = `<${EFFORT_LEVELS.join("|")}>`;
     modelRef = z5.string().min(1);
+    boundaryOption = z5.object({
+      maxMinutes: z5.coerce.number().int().min(MIN_BOUNDARY_MINUTES).optional().describe(`cap the wall-clock budget of every run in this scope (minutes, >= ${MIN_BOUNDARY_MINUTES})`),
+      maxIdentity: z5.enum(IDENTITIES).optional().describe(`cap the identity runs may act as <${IDENTITIES.join("|")}> \u2014 a preset above it is refused`),
+      machines: z5.string().optional().describe(`the machine classes runs may execute on, comma-separated from ${MACHINE_CLASSES.join(", ")}`)
+    }).optional();
     who = (scope) => scope === "channel" ? "channel" : "your";
     configShow = defineCommand2({
       id: "config.show",
@@ -10979,11 +11503,12 @@ var init_config3 = __esm({
         models: z5.record(z5.string(), modelRef).optional().describe("per-agent model: --models.<agent> provider/model"),
         effort: effort.optional().describe(`force a model effort ${effortLevels}`),
         efforts: z5.record(z5.string(), effort).optional().describe(`per-agent effort: --efforts.<agent> ${effortLevels}`),
+        boundary: boundaryOption,
         channel: channelOption
       }),
       action: "config:write",
       effect: "write",
-      describe: "Set the agent, model, or effort for a channel (gated) or for yourself; per-agent forms take --models.<agent> / --efforts.<agent>.",
+      describe: "Set the agent, model, effort or boundary for a channel (gated) or for yourself; per-agent forms take --models.<agent> / --efforts.<agent>, the boundary's axes --boundary.<axis> (a boundary caps every run in the scope and never grants).",
       render: (output) => {
         const o = output;
         return `Updated ${who(o.scope)} scope. Now: ${JSON.stringify(o.effective)}`;
@@ -11012,10 +11537,26 @@ var init_config3 = __esm({
         if (options.models) patch.models = options.models;
         if (options.effort !== void 0) patch.effort = options.effort;
         if (options.efforts) patch.efforts = options.efforts;
+        if (options.boundary) {
+          const { machines, ...axes } = options.boundary;
+          const boundary = { ...axes };
+          if (machines !== void 0) {
+            const classes = machines.split(",").map((m) => m.trim());
+            if (classes.length === 0 || classes.some((m) => !MACHINE_CLASSES.includes(m)))
+              throw new CommandError(
+                "invalid_input",
+                `boundary.machines: expected a comma-separated list of ${MACHINE_CLASSES.join(", ")}`
+              );
+            boundary.machines = classes;
+          }
+          const problem = boundaryProblem("boundary", boundary);
+          if (problem) throw new CommandError("invalid_input", problem);
+          if (Object.keys(boundary).length > 0) patch.boundary = boundary;
+        }
         if (Object.keys(patch).length === 0)
           throw new CommandError(
             "invalid_input",
-            "nothing to set: pass --agent, --model, --models.<agent>, --effort, or --efforts.<agent>"
+            "nothing to set: pass --agent, --model, --models.<agent>, --effort, --efforts.<agent>, or --boundary.<maxMinutes|maxIdentity|machines>"
           );
         let effective;
         if (args.scope === "channel") {
@@ -12225,6 +12766,17 @@ var init_runFriction = __esm({
 });
 
 // ../../src/core/runRecord.ts
+function isRunProfileRecord(v) {
+  if (typeof v !== "object" || v === null) return false;
+  const p = v;
+  if (typeof p.preset !== "string") return false;
+  if (typeof p.machine !== "string" || !Object.hasOwn(MACHINE_CLASSES_IN_RECORD, p.machine)) return false;
+  if (typeof p.identity !== "string" || !Object.hasOwn(IDENTITIES_IN_RECORD, p.identity)) return false;
+  if (!isFiniteNumber(p.minutes) || p.minutes <= 0) return false;
+  if (p.boundedBy !== void 0 && (typeof p.boundedBy !== "string" || !Object.hasOwn(BOUNDARY_SCOPES_IN_RECORD, p.boundedBy)))
+    return false;
+  return true;
+}
 function storedEventSeqs(events) {
   let prev = 0;
   for (const e of events) {
@@ -12350,6 +12902,7 @@ function isRunRecord(v) {
     return false;
   if (!isOptionalString(r.activity) || !isOptionalString(r.sourceUrl) || !isOptionalString(r.userName)) return false;
   if (r.handoff !== void 0 && !isHandoffShape(r.handoff)) return false;
+  if (r.profile !== void 0 && !isRunProfileRecord(r.profile)) return false;
   if (typeof r.channelId !== "string" || typeof r.userId !== "string" || typeof r.threadKey !== "string") return false;
   if (r.channelVisibility !== void 0 && !CHANNEL_VISIBILITIES2.includes(r.channelVisibility))
     return false;
@@ -12476,7 +13029,7 @@ function dropSpanPairsFromTheMiddle(events, eventBudget) {
   }
   return events.filter((_, k) => !dropped.has(k));
 }
-var RUN_STATUSES, RUN_ID_PATTERN, RUN_LIST_DEFAULT_LIMIT, RUN_LIST_MAX_LIMIT, RUN_EVENTS_DEFAULT_PAGE, RUN_EVENTS_MAX_PAGE, CHANNEL_VISIBILITIES2, KIB, MIB, GIB2, DEFAULT_RETENTION_POLICY, RETENTION_BOUNDS, MAX_RECORD_BYTES, MAX_EVENT_BYTES, ELLIPSIS, encoder;
+var RUN_STATUSES, RUN_ID_PATTERN, MACHINE_CLASSES_IN_RECORD, IDENTITIES_IN_RECORD, BOUNDARY_SCOPES_IN_RECORD, RUN_LIST_DEFAULT_LIMIT, RUN_LIST_MAX_LIMIT, RUN_EVENTS_DEFAULT_PAGE, RUN_EVENTS_MAX_PAGE, CHANNEL_VISIBILITIES2, KIB, MIB, GIB2, DEFAULT_RETENTION_POLICY, RETENTION_BOUNDS, MAX_RECORD_BYTES, MAX_EVENT_BYTES, ELLIPSIS, encoder;
 var init_runRecord = __esm({
   "../../src/core/runRecord.ts"() {
     "use strict";
@@ -12485,6 +13038,19 @@ var init_runRecord = __esm({
     init_runFriction();
     RUN_STATUSES = ["completed", "stopped_soft", "stopped_hard", "failed", "interrupted"];
     RUN_ID_PATTERN = /^[A-Za-z0-9_-]{1,64}$/;
+    MACHINE_CLASSES_IN_RECORD = {
+      none: true,
+      blank: true,
+      "repo-cold": true,
+      "repo-resident": true
+    };
+    IDENTITIES_IN_RECORD = { none: true, read: true, write: true };
+    BOUNDARY_SCOPES_IN_RECORD = {
+      defaults: true,
+      channel: true,
+      user: true,
+      directive: true
+    };
     RUN_LIST_DEFAULT_LIMIT = 50;
     RUN_LIST_MAX_LIMIT = 200;
     RUN_EVENTS_DEFAULT_PAGE = 1e3;
@@ -12515,7 +13081,7 @@ import { z as z7 } from "zod";
 function registerDeliveryCommands(registry) {
   for (const cmd of deliveryCommands) registry.register(cmd);
 }
-var defineCommand4, REPO_SLUG2, ISO_DAY2, asJson, deliveryReport, deliveryCommands;
+var defineCommand4, REPO_SLUG2, ISO_DAY3, asJson, deliveryReport, deliveryCommands;
 var init_delivery2 = __esm({
   "../../src/core/commands/delivery.ts"() {
     "use strict";
@@ -12525,21 +13091,22 @@ var init_delivery2 = __esm({
     init_runRecord();
     defineCommand4 = commandDefiner();
     REPO_SLUG2 = /^(?!\.+\/)[\w.-]+\/(?!\.+$)[\w.-]+$/;
-    ISO_DAY2 = /^\d{4}-\d{2}-\d{2}$/;
+    ISO_DAY3 = /^\d{4}-\d{2}-\d{2}$/;
     asJson = (v) => v;
     deliveryReport = defineCommand4({
       id: "delivery.report",
       options: z7.object({
         repo: z7.string().regex(REPO_SLUG2).optional().describe("the repository (`owner/name`); default: the first under `delivery.repos`"),
-        since: z7.string().regex(ISO_DAY2).optional().describe("the first day of the range (`YYYY-MM-DD`, UTC); the range ends today"),
+        since: z7.string().regex(ISO_DAY3).optional().describe("the first day of the range (`YYYY-MM-DD`, UTC); the range ends today"),
         weeks: z7.coerce.number().int().min(1).max(MAX_WEEKS).optional().describe(
           `Monday-start weeks back from this one (default 4, at most ${MAX_WEEKS}); --since, when given, decides instead`
-        )
+        ),
+        fresh: flag.optional().describe("read GitHub now instead of the repository's snapshot, and refresh the snapshot")
       }),
       action: "delivery:read",
       effect: "read",
       enabledWhen: (caps) => caps.github,
-      describe: "Delivery indicators per week and per unit \u2014 issue-to-merge time, first-pass CI, review rounds, findings and the share resolved with no human edit \u2014 read from GitHub and the run history; nothing written.",
+      describe: "Delivery indicators per week and per unit \u2014 issue-to-merge time, first-pass CI, review rounds, findings and the share resolved with no human edit \u2014 from the repository's snapshot of GitHub's facts (--fresh reads GitHub now) and the run history; nothing written.",
       render: (output) => renderDeliveryReport(output),
       handler: async ({ options, caller, deps }) => {
         const service = await deps.delivery.service();
@@ -12559,11 +13126,13 @@ var init_delivery2 = __esm({
           return runFactsOf(page2.runs, repo);
         };
         try {
-          return asJson(await service.report(repo, { since: options.since, weeks: options.weeks, runs }));
+          return asJson(
+            await service.report(repo, { since: options.since, weeks: options.weeks, fresh: options.fresh, runs })
+          );
         } catch (err2) {
-          const message = err2 instanceof Error ? err2.message : String(err2);
-          if (message === DELIVERY_OFF_MESSAGE) throw new CommandError("unavailable", message);
-          throw new CommandError("unavailable", `delivery indicators unavailable: ${message}`);
+          const message2 = err2 instanceof Error ? err2.message : String(err2);
+          if (message2 === DELIVERY_OFF_MESSAGE) throw new CommandError("unavailable", message2);
+          throw new CommandError("unavailable", `delivery indicators unavailable: ${message2}`);
         }
       }
     });
@@ -12693,7 +13262,7 @@ var init_deploy = __esm({
     init_operatorRoot();
     init_restart();
     init_run();
-    init_profile();
+    init_profile2();
     init_wranglerTemplate();
     init_secrets();
     init_commandRegistry();
@@ -14288,7 +14857,7 @@ var init_help = __esm({
     init_commandRegistry();
     init_commandSurface();
     defineCommand8 = commandDefiner();
-    DIRECTIVES_HELP = "`agent:review model:anthropic/claude-opus-5 effort:low look at PR 42` (effort: low | medium | high \u2014 lower = faster turns)";
+    DIRECTIVES_HELP = "`agent:review model:anthropic/claude-opus-5 effort:low budget:20 look at PR 42` (effort: low | medium | high \u2014 lower = faster turns; budget: whole minutes, at least 2 \u2014 narrows this run's wall clock, never widens it)";
     helpShow = defineCommand8({
       id: "help.show",
       action: "help:read",
@@ -14427,8 +14996,8 @@ var init_types2 = __esm({
   "../../src/mcp/types.ts"() {
     "use strict";
     McpError = class extends Error {
-      constructor(code, message) {
-        super(message);
+      constructor(code, message2) {
+        super(message2);
         this.code = code;
         this.name = "McpError";
       }
@@ -14611,12 +15180,12 @@ var init_client = __esm({
         const res = await this.post({ jsonrpc: "2.0", id, method, params }, signal, o);
         const session = res.headers.get("mcp-session-id");
         if (session && o?.initializing) this.sessionId = session;
-        const message = await this.readResponse(res, id, signal);
-        if (message.error) {
-          const code = typeof message.error.code === "number" ? message.error.code : "protocol";
-          throw new McpError(code, `${method}: ${String(message.error.message ?? "error")}`);
+        const message2 = await this.readResponse(res, id, signal);
+        if (message2.error) {
+          const code = typeof message2.error.code === "number" ? message2.error.code : "protocol";
+          throw new McpError(code, `${method}: ${String(message2.error.message ?? "error")}`);
         }
-        return message.result;
+        return message2.result;
       }
       async post(body, signal, o) {
         const headers = {
@@ -15023,8 +15592,8 @@ var init_oauth = __esm({
     init_web();
     init_client();
     OAuthError = class extends Error {
-      constructor(message) {
-        super(message);
+      constructor(message2) {
+        super(message2);
         this.name = "OAuthError";
       }
     };
@@ -15167,9 +15736,9 @@ function bridgeMcpTools(server, client, tools, opts) {
           try {
             result = await client.callTool(t.name, input ?? {}, { signal: ctx.signal });
           } catch (err2) {
-            const message = err2 instanceof McpError ? err2.message : err2 instanceof Error ? err2.message : String(err2);
+            const message2 = err2 instanceof McpError ? err2.message : err2 instanceof Error ? err2.message : String(err2);
             const failed = classifyError(
-              new Error(`MCP ${server.name}/${t.name} failed: ${message}`, { cause: err2 }),
+              new Error(`MCP ${server.name}/${t.name} failed: ${message2}`, { cause: err2 }),
               mcpClass(err2)
             );
             span?.fail(failed);
@@ -15376,8 +15945,8 @@ var init_service = __esm({
     init_source();
     MCP_OFF_MESSAGE = "External MCP servers are not enabled in this deployment (no `mcp` block in config.yaml).";
     McpServiceError = class extends Error {
-      constructor(code, message) {
-        super(message);
+      constructor(code, message2) {
+        super(message2);
         this.code = code;
         this.name = "McpServiceError";
       }
@@ -15985,12 +16554,12 @@ var init_service = __esm({
           const tools = await this.opts.factory(spec).listTools();
           return { kind: "ok", toolCount: tools.length };
         } catch (err2) {
-          const message = err2 instanceof Error ? err2.message : String(err2);
-          if (/HTTP 40[13]\b/.test(message))
-            return { kind: "rejected", error: `the server rejected the token (${message})` };
+          const message2 = err2 instanceof Error ? err2.message : String(err2);
+          if (/HTTP 40[13]\b/.test(message2))
+            return { kind: "rejected", error: `the server rejected the token (${message2})` };
           return {
             kind: "error",
-            error: `stored, but the server could not be reached to verify it: ${message.slice(0, 200)}`
+            error: `stored, but the server could not be reached to verify it: ${message2.slice(0, 200)}`
           };
         }
       }
@@ -17880,8 +18449,8 @@ var init_githubApi = __esm({
     MAX_FILE_CHARS = 2e5;
     COMPARE_DIFF_MAX_CHARS = 12e5;
     GithubApiError = class extends Error {
-      constructor(status3, message) {
-        super(message);
+      constructor(status3, message2) {
+        super(message2);
         this.status = status3;
         this.name = "GithubApiError";
       }
@@ -18203,8 +18772,8 @@ var init_reviewAbridge = __esm({
     init_clock();
     isReadingDiff = (e) => e.type === "review_artifact" && e.artifact === "reading_diff";
     AbridgeRefusal = class extends Error {
-      constructor(code, message) {
-        super(message);
+      constructor(code, message2) {
+        super(message2);
         this.code = code;
         this.name = "AbridgeRefusal";
       }
@@ -19249,7 +19818,7 @@ var init_plan2 = __esm({
     init_config();
     init_capabilities();
     init_secrets2();
-    init_profile();
+    init_profile2();
     ENV_PATH = ".env";
     CONFIG_PATH = "config/config.yaml";
     PROFILE_PATH2 = "deploy/profile.json";
@@ -19262,7 +19831,7 @@ var init_plan2 = __esm({
     ];
     OPENAI_PROVIDER = "openai";
     OPENAI_KEY_ENV = "OPENAI_API_KEY";
-    DEFAULT_MODEL_AGENTS = ["general", "coding", "review"];
+    DEFAULT_MODEL_AGENTS = ["general", "coding", "review", "explore"];
     ENV_LINE = /^(#\s*)?([A-Z][A-Z0-9_]*)=(.*)$/;
   }
 });
@@ -19753,7 +20322,12 @@ function buildCoreCommands(config, store, wiring) {
   const delivery = once(async () => {
     if (wiring.delivery) return wiring.delivery();
     if (wiring.capabilities && !wiring.capabilities.github) return new NullDeliveryService();
-    return deliveryServiceFromConfig(parseDeliveryConfig((await cfg()).config.delivery));
+    const config2 = (await cfg()).config;
+    const warn = (m) => wiring.warn(`[delivery] ${m}`);
+    return deliveryFromConfig(parseDeliveryConfig(config2.delivery), {
+      snapshots: buildDeliverySnapshotStore(config2, wiring.secrets, warn),
+      warn
+    }).service;
   });
   const deps = {
     help: {
@@ -19818,13 +20392,19 @@ function buildCoreCommands(config, store, wiring) {
   };
   return bindCommands(registry, deps);
 }
-function deliveryServiceFromConfig(cfg) {
-  return createDeliveryService(cfg, new GithubDeliverySource(), {
+function deliveryFromConfig(cfg, opts = {}) {
+  const source2 = new SnapshottingDeliverySource(
+    new GithubDeliverySource(),
+    opts.snapshots ?? new InMemoryDeliverySnapshotStore(),
+    { ...opts.warn ? { warn: opts.warn } : {} }
+  );
+  const service = createDeliveryService(cfg, source2, {
     identities: async () => {
       const identity2 = await resolveGithubIdentity();
       return identity2 ? { reviewers: [identity2.login] } : {};
     }
   });
+  return { service, source: source2 };
 }
 var init_commandCatalogue = __esm({
   "../../src/core/commandCatalogue.ts"() {
@@ -19843,6 +20423,8 @@ var init_commandCatalogue = __esm({
     init_githubDelivery();
     init_resident();
     init_delivery();
+    init_deliverySnapshot();
+    init_deliverySnapshotStore();
     init_commandRegistry();
     init_secrets2();
     init_all();
@@ -20442,10 +21024,10 @@ function safePredicate(isResident, slug) {
     return false;
   }
 }
-async function safeProbe(isResident, slug) {
-  if (!isResident) return true;
+async function safeProbe(probe, slug) {
+  if (!probe) return true;
   try {
-    const answer = await isResident(slug);
+    const answer = await probe(slug);
     return answer === true || answer === "unreachable" ? answer : false;
   } catch {
     return "unreachable";
@@ -20454,7 +21036,7 @@ async function safeProbe(isResident, slug) {
 function repoFromThread(history, isResident) {
   return threadSignals(history, isResident).repo;
 }
-async function resolveRepoContext(msg, history = [], isResident, residentSlugs) {
+async function resolveRepoContext(msg, history = [], probe, residentSlugs) {
   const s = extractSignals(msg.text);
   const thread = threadSignals(history);
   let rejected;
@@ -20463,7 +21045,7 @@ async function resolveRepoContext(msg, history = [], isResident, residentSlugs)
   const vet = async (cand) => {
     let p = vetted.get(cand);
     if (!p) {
-      p = safeProbe(isResident, cand);
+      p = safeProbe(probe, cand);
       vetted.set(cand, p);
     }
     const answer = await p;
@@ -20479,7 +21061,7 @@ async function resolveRepoContext(msg, history = [], isResident, residentSlugs)
     return slugsOnce;
   };
   const resolveAddressed = async (a) => {
-    if (a.slug !== void 0) return isResident && await vet(a.slug) ? a.slug : void 0;
+    if (a.slug !== void 0) return probe && await vet(a.slug) ? a.slug : void 0;
     const matches = (await listSlugs() ?? []).filter((slug) => slug.split("/")[1] === a.name);
     return matches.length === 1 ? matches[0] : void 0;
   };
@@ -22301,6 +22883,21 @@ ${raw.trim()}`;
        *  and URL reading, so a plain mention can answer from the repos and act on
        *  issues without being re-sent to another agent. */
       assistant: [webFetchTool, updateStatusTool, ...GITHUB_READ_TOOLS, ...GITHUB_ISSUE_WRITE_TOOLS],
+      /** The explore agent (docs/reference/specs/agent-explore.md): a shell and
+       *  file reads in a cold sandbox, the web with search, the skills and the
+       *  GitHub reads — and nothing that writes: no `write_file`, no `submit_*`,
+       *  no issue writes. Read-only is a toolset-and-prompt contract; the wall is
+       *  the read-scoped credential its machine holds. */
+      explore: [
+        bashTool,
+        readFileTool,
+        updateStatusTool,
+        webFetchTool,
+        webSearchTool,
+        listSkillsTool,
+        useSkillTool,
+        ...GITHUB_READ_TOOLS
+      ],
       none: []
     };
   }
@@ -22505,9 +23102,9 @@ async function runLoop(opts, now, note, emit, agentSpan) {
           );
           throw err2;
         }
-        const message = err2 instanceof Error ? err2.message : String(err2);
+        const message2 = err2 instanceof Error ? err2.message : String(err2);
         if (err2 instanceof ExecCapacityError) {
-          const text2 = `\u23F3 Sandbox fleet busy \u2014 ${message}. Retry the command in a minute or finish with what you have.`;
+          const text2 = `\u23F3 Sandbox fleet busy \u2014 ${message2}. Retry the command in a minute or finish with what you have.`;
           emit({ type: "tool_result", tool: tu.name, ok: false, callId: tu.id, ...prepareToolResult(text2), ...spanId });
           note("fleet_busy", text2);
           settle2(false, { infra: true });
@@ -22519,7 +23116,7 @@ async function runLoop(opts, now, note, emit, agentSpan) {
           tool: tu.name,
           ok: false,
           callId: tu.id,
-          ...prepareToolResult(message),
+          ...prepareToolResult(message2),
           ...infra ? { infra: true } : {},
           ...spanId
         });
@@ -22528,7 +23125,7 @@ async function runLoop(opts, now, note, emit, agentSpan) {
         return {
           type: "tool_result",
           toolUseId: tu.id,
-          content: capToolResultContent(`Error: ${message}`),
+          content: capToolResultContent(`Error: ${message2}`),
           isError: true
         };
       }
@@ -22897,8 +23494,8 @@ function rereviewFollowUp(input) {
     `Re-review at ${c}: focus on what changed since ${r} (\`git diff ${r} HEAD\` if ${r} is still present, otherwise diff against the base), re-check any finding above that the new commits address, and report the complete updated review \u2014 same format, verdict line first. Then call \`submit_verdict\` again with \`head\` = \`${input.current}\`; the earlier verdict is void.`
   ].join("\n");
 }
-function subject(message) {
-  return message.trim().split(/\r?\n/, 1)[0]?.trim() ?? "";
+function subject(message2) {
+  return message2.trim().split(/\r?\n/, 1)[0]?.trim() ?? "";
 }
 function short3(sha) {
   return sha.trim().toLowerCase().slice(0, 7);
@@ -23024,16 +23621,17 @@ var init_digestCoverage = __esm({
 });
 
 // ../../src/core/reviewRound.ts
-function releaseModeFor(agent, opts) {
-  return agent.toolset === "readonly" || opts.hardStopped ? "always" : "if-clean";
+function releaseModeFor(identity2, opts) {
+  return identity2 === "read" || opts.hardStopped ? "always" : "if-clean";
 }
 async function attachRoundWorkspace(input) {
-  const { agent } = input.round;
+  const { agent, profile } = input.round;
   const selection = await makeExecutor(
     input.factory,
     {
       threadKey: input.round.threadKey,
       agent,
+      profile,
       repo: input.round.repo,
       ref: input.round.ref,
       headSha: input.round.headSha
@@ -23043,7 +23641,7 @@ async function attachRoundWorkspace(input) {
   const release = async (opts) => {
     const { executor } = selection;
     if (!executor.release) return;
-    const mode = releaseModeFor(agent, opts);
+    const mode = releaseModeFor(profile.identity, opts);
     try {
       const r = await executor.release(mode, opts.span ? { span: opts.span } : void 0);
       console.log(`[release] ${input.logKey} ${r.released ? "released" : "kept"}${r.reason ? ` (${r.reason})` : ""}`);
@@ -23757,6 +24355,9 @@ function reclaimedRunRecord(input) {
     },
     channelVisibility: row.meta.channelVisibility ?? "unknown",
     repo: row.meta.repo,
+    // The row carries the profile the run was admitted with (a clipped budget
+    // included); a row from before profiles existed leaves the record without one.
+    ...row.meta.profile && row.meta.agent ? { profile: { preset: row.meta.agent, ...row.meta.profile } } : {},
     finishedAt,
     status: status3,
     diagnosis: analyzeRunFriction(events, {
@@ -23815,12 +24416,16 @@ function assembleRunRecord(input) {
     ...activityOfEvents(events) !== void 0 ? { activity: activityOfEvents(events) } : {},
     ...msg.sourceUrl !== void 0 ? { sourceUrl: msg.sourceUrl } : {},
     ...msg.userName !== void 0 ? { userName: msg.userName } : {},
-    ...input.handoff !== void 0 ? { handoff: redactHandoff(input.handoff) } : {}
+    ...input.handoff !== void 0 ? { handoff: redactHandoff(input.handoff) } : {},
+    ...input.profile !== void 0 ? { profile: input.profile } : {}
   });
   return fitted.eventCount !== fitted.storedEventCount ? { ...fitted, truncated: true } : fitted;
 }
+function profileRecordOf(agent, profile) {
+  return { preset: agent.name, ...profile };
+}
 function writeTombstone(deps, ctx) {
-  const { msg, agent, resolved, repoCtx, channelVisibility, run: run2, registry, resume } = ctx;
+  const { msg, agent, profile, resolved, repoCtx, channelVisibility, run: run2, registry, resume } = ctx;
   if (!resume) {
     const startSnap = registry.snapshot(run2.id, run2.token);
     if (startSnap) {
@@ -23833,6 +24438,7 @@ function writeTombstone(deps, ctx) {
           msg,
           channelVisibility,
           repo: repoCtx.repo,
+          profile: profileRecordOf(agent, profile),
           finishedAt: startSnap.startedAt,
           status: "interrupted",
           diagnosis: analyzeRunFriction(startSnap.events, {
@@ -23851,6 +24457,7 @@ function registerFinishRecord(deps, ctx) {
     run: run2,
     snap,
     agent,
+    profile,
     resolved,
     msg,
     channelVisibility,
@@ -23874,6 +24481,7 @@ function registerFinishRecord(deps, ctx) {
         msg,
         channelVisibility,
         repo: repoCtx.repo,
+        profile: profileRecordOf(agent, profile),
         finishedAt,
         status: failedAfterFinish && status3 === "completed" ? "failed" : status3,
         diagnosis,
@@ -24225,10 +24833,10 @@ ${chatCatalogueText(inGroup)}` };
   const id = `${group}.${verb}`;
   const cmd = exposed.find((c) => c.id === id);
   if (!cmd) return null;
-  const rejected = (message) => ({
+  const rejected = (message2) => ({
     kind: "reply",
     error: "invalid_input",
-    text: `\u26A0\uFE0F \`${chatForm(id)}\`: ${message}`
+    text: `\u26A0\uFE0F \`${chatForm(id)}\`: ${message2}`
   });
   const tokens = tokenize(text);
   if (!tokens.ok) return rejected(tokens.error);
@@ -24250,15 +24858,15 @@ function chatCallerFor(msg, config, resolveRepo) {
     origin: { channelId: msg.channelId, threadKey: msg.threadKey, ...resolveRepo ? { repo: resolveRepo } : {} }
   };
 }
-function chatErrorLine(id, error, message, config, decidedBy = "registry") {
+function chatErrorLine(id, error, message2, config, decidedBy = "registry") {
   const name = chatForm(id);
   switch (error) {
     case "unauthorized":
-      return decidedBy === "handler" ? `\u{1F6AB} \`${name}\`: ${message} Ask ${config.adminsHint()}.` : `\u{1F6AB} \`${name}\` is restricted. Ask ${config.adminsHint()}.`;
+      return decidedBy === "handler" ? `\u{1F6AB} \`${name}\`: ${message2} Ask ${config.adminsHint()}.` : `\u{1F6AB} \`${name}\` is restricted. Ask ${config.adminsHint()}.`;
     case "internal":
-      return `\u26A0\uFE0F \`${name}\` failed: ${message}`;
+      return `\u26A0\uFE0F \`${name}\` failed: ${message2}`;
     default:
-      return `\u26A0\uFE0F \`${name}\`: ${message}`;
+      return `\u26A0\uFE0F \`${name}\`: ${message2}`;
   }
 }
 async function invokeChatCommand({
@@ -25063,6 +25671,11 @@ var init_fastPath = __esm({
 });
 
 // ../../src/directives.ts
+function parseBudgetMinutes(value) {
+  if (!/^\d+$/.test(value)) return void 0;
+  const minutes = Number(value);
+  return minutes >= MIN_BOUNDARY_MINUTES ? minutes : void 0;
+}
 function lastThreadDirectives(history) {
   const out = {};
   for (const h of history) {
@@ -25095,6 +25708,14 @@ function parseDirectives(input) {
         throw new Error(`Unknown effort "${f.value}". Valid: ${EFFORT_LEVELS_HINT}`);
       }
       out.effort = f.value;
+    } else if (f.key === "budget") {
+      const minutes = parseBudgetMinutes(f.value);
+      if (minutes === void 0) {
+        throw new Error(
+          `Invalid budget "${f.value}": budget:<minutes> takes a whole number of minutes, at least ${MIN_BOUNDARY_MINUTES} (e.g. budget:30). It narrows this run's wall clock and never widens it.`
+        );
+      }
+      out.budget = minutes;
     }
     text = text.replace(f.match, " ");
   }
@@ -25106,8 +25727,47 @@ var init_directives = __esm({
   "../../src/directives.ts"() {
     "use strict";
     init_registry();
+    init_validate();
     init_effort();
-    DIRECTIVE_RE = /(?:^|\s)(agent|model|effort)[:=](\S+)/g;
+    DIRECTIVE_RE = /(?:^|\s)(agent|model|effort|budget)[:=](\S+)/g;
+  }
+});
+
+// ../../src/execution/githubRepoProbe.ts
+function githubRepoProbe(opts) {
+  const fetchImpl = opts.fetch ?? fetch;
+  const token = opts.token ?? ((scope) => resolveGithubToken(scope));
+  return async (slug) => {
+    if (!SLUG.test(slug)) return false;
+    let bearer;
+    try {
+      bearer = opts.scope === void 0 ? null : await token(opts.scope);
+    } catch {
+      return "unreachable";
+    }
+    const headers = { accept: "application/vnd.github+json", "user-agent": "switchboard" };
+    if (bearer) headers.authorization = `Bearer ${bearer}`;
+    let res;
+    try {
+      res = await fetchImpl(`https://api.github.com/repos/${slug}`, {
+        headers,
+        signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS6)
+      });
+    } catch {
+      return "unreachable";
+    }
+    if (res.ok) return true;
+    if (res.status === 404) return false;
+    return "unreachable";
+  };
+}
+var REQUEST_TIMEOUT_MS6, SLUG;
+var init_githubRepoProbe = __esm({
+  "../../src/execution/githubRepoProbe.ts"() {
+    "use strict";
+    init_githubApp();
+    REQUEST_TIMEOUT_MS6 = 1e4;
+    SLUG = /^[A-Za-z0-9][A-Za-z0-9-]*\/[A-Za-z0-9._-]+$/;
   }
 });
 
@@ -25132,32 +25792,48 @@ function resolveRun(deps, ctx) {
   });
   return { sticky, resolved };
 }
+function resolveProfile(ctx) {
+  const carried = ctx.resume?.row.meta.profile;
+  const declared = carried ? { machine: carried.machine, identity: carried.identity, maxMinutes: carried.minutes } : ctx.agent;
+  const resolution = effectiveProfile(
+    declared,
+    ctx.budget !== void 0 ? { budget: ctx.budget } : {},
+    ctx.resolved.boundary
+  );
+  if (resolution.kind === "profile" && carried?.boundedBy && !resolution.profile.boundedBy) {
+    return { kind: "profile", profile: { ...resolution.profile, boundedBy: carried.boundedBy } };
+  }
+  return resolution;
+}
 function resolveTarget(deps, ctx) {
-  const { msg, history, agent, resolved, resume, root } = ctx;
+  const { msg, history, profile, resolved, resume, root } = ctx;
   const { provider: providerName, model } = parseModelRef(resolved.modelRef);
   const provider = deps.providers.get(providerName);
-  const needsRepo = agent.resources?.repo === "required";
+  const needsRepo = machineNeedsRepo(profile.machine);
   const repoCtxP = root.span(
     "dispatch.repo_context",
     () => resume ? Promise.resolve(resume.repoCtx) : needsRepo ? Promise.resolve(
-      deps.resolveRepoContext ? deps.resolveRepoContext(msg, history) : resolveRepoContext(
-        msg,
-        history,
-        residentOnboardedProbe(deps.config.config.execution?.resident),
-        residentSlugsLister(deps.config.config.execution?.resident)
-      )
+      deps.resolveRepoContext ? deps.resolveRepoContext(msg, history) : resolveRepoContext(msg, history, ...repoVetFor(profile, deps.config.config.execution?.resident))
     ).then((ctx2) => ctx2 ?? {}) : Promise.resolve({})
   );
   repoCtxP.catch(() => {
   });
   return { provider, model, needsRepo, repoCtxP };
 }
+function repoVetFor(profile, resident) {
+  if (profile.machine === "repo-cold")
+    return [githubRepoProbe({ scope: githubTokenScopeFor(profile.identity) }), void 0];
+  return [residentOnboardedProbe(resident), residentSlugsLister(resident)];
+}
 var init_resolve = __esm({
   "../../src/core/dispatch/resolve.ts"() {
     "use strict";
+    init_registry();
+    init_profile();
     init_directives();
     init_types3();
     init_factory();
+    init_githubRepoProbe();
     init_repoContext();
   }
 });
@@ -25176,8 +25852,97 @@ async function authorizeAgent(deps, ctx) {
   }
   return { kind: "allowed" };
 }
+async function authorizeProfile(deps, ctx) {
+  const { msg, io, refuse: refuse3, agent, resolution } = ctx;
+  if (resolution.kind === "profile") return { kind: "allowed", profile: resolution.profile };
+  const { refusal } = resolution;
+  console.log(`[dispatch] ${msg.threadKey} not started: profile bounded (${agent.name}: ${refusalSummary(refusal)})`);
+  await refuse3("profile_bounded", () => io.reply(profileRefusalReply(agent.name, refusal, deps.config.adminsHint())));
+  return { kind: "refused", reason: "profile_bounded" };
+}
+function refusalSummary(refusal) {
+  return refusal.axis === "identity" ? `identity ${refusal.needs} > ${refusal.cap} (${refusal.scope})` : `machine ${refusal.needs} not in ${refusal.allowed.join(",")} (${refusal.scopes.join(",")})`;
+}
+function boundaryOf(scope) {
+  switch (scope) {
+    case "channel":
+      return "this channel's boundary";
+    case "user":
+      return "your own boundary";
+    case "defaults":
+      return "the installation's default boundary";
+    case "directive":
+      return "this message's own budget";
+  }
+}
+function wayForward(scope, axis, needs, adminsHint) {
+  switch (scope) {
+    case "channel":
+      return `run it in a channel that allows \`${needs}\`, or ask ${adminsHint} to raise this channel's boundary`;
+    case "user":
+      return `raise your own boundary with \`config set me --boundary.${axis} ${needs}\`, or drop your overrides with \`config clear me\``;
+    case "defaults":
+      return `ask ${adminsHint} to raise \`defaults.boundary\` in the configuration`;
+    case "directive":
+      return "send the message again without the budget directive";
+  }
+}
+function profileRefusalReply(agentName, refusal, adminsHint) {
+  const capitalize = (s) => s.charAt(0).toUpperCase() + s.slice(1);
+  if (refusal.axis === "identity") {
+    const how2 = wayForward(refusal.scope, "maxIdentity", refusal.needs, adminsHint);
+    return `\u{1F6AB} \`${agentName}\` needs a \`${refusal.needs}\` credential; ${boundaryOf(refusal.scope)} caps runs at \`${refusal.cap}\`. ${capitalize(how2)}.`;
+  }
+  const scopes = refusal.scopes.map(boundaryOf);
+  const who2 = scopes.length > 1 ? `${scopes.join(" and ")} allow` : `${scopes[0] ?? "the boundary"} allows`;
+  const allowed = refusal.allowed.map((m) => `\`${m}\``).join(", ");
+  const how = refusal.scopes.map(
+    (scope) => wayForward(
+      scope,
+      "machines",
+      scope === "user" ? `<classes including ${refusal.needs}>` : refusal.needs,
+      adminsHint
+    )
+  ).join("; ");
+  return `\u{1F6AB} \`${agentName}\` runs on a \`${refusal.needs}\` machine; ${who2} only ${allowed}. ${capitalize(how)}.`;
+}
 async function authorizeRepo(deps, ctx) {
-  const { msg, io, refuse: refuse3, card, shell, closeLines, clock: clock2, agent, needsRepo, repoCtx } = ctx;
+  const { msg, io, refuse: refuse3, card, shell, closeLines, clock: clock2, agent, profile, needsRepo, repoCtx } = ctx;
+  if (profile.machine === "repo-cold" && needsRepo && !repoCtx.repo) {
+    if (repoCtx.rejectedRepo) {
+      const slug = repoCtx.rejectedRepo;
+      console.log(`[dispatch] ${msg.threadKey} not started: repo not visible (${slug}: GitHub answered 404)`);
+      await refuse3("repo_not_visible", async () => {
+        await card.done(
+          shell.close({ kind: "not_started", icon: "\u{1F4E6}", reason: "repo not visible", ...closeLines(clock2(), false) })
+        );
+        await io.reply(
+          `\u{1F4E6} \`${slug}\` is not a repository this installation can see \u2014 GitHub answered 404 \u2014 so I did not start ${aRun(agent.name)} for it. The repository is outside the Switchboard GitHub App installation (\`github_repos\` lists the reachable ones), or the name is wrong.`
+        );
+      });
+      return { kind: "refused", reason: "repo_not_visible" };
+    }
+    if (repoCtx.unverifiedRepo) {
+      const slug = repoCtx.unverifiedRepo;
+      console.log(
+        `[dispatch] ${msg.threadKey} not started: repo could not be verified (${slug}: GitHub did not answer)`
+      );
+      await refuse3("repo_unverified", async () => {
+        await card.done(
+          shell.close({
+            kind: "not_started",
+            icon: "\u{1F4E6}",
+            reason: "repo could not be verified",
+            ...closeLines(clock2(), false)
+          })
+        );
+        await io.reply(
+          `\u26A0\uFE0F I couldn't verify \`${slug}\` against GitHub \u2014 it didn't answer \u2014 so I did not start ${aRun(agent.name)} rather than guess which repository you meant. Try again in a minute.`
+        );
+      });
+      return { kind: "refused", reason: "repo_unverified" };
+    }
+  }
   if (deps.capabilities.residents && needsRepo && !repoCtx.repo && repoCtx.rejectedRepo) {
     const slug = repoCtx.rejectedRepo;
     console.log(`[dispatch] ${msg.threadKey} not started: repo not onboarded (${slug})`);
@@ -25226,6 +25991,9 @@ async function authorizeRepo(deps, ctx) {
   }
   return { kind: "allowed" };
 }
+function aRun(agentName) {
+  return `${/^[aeiou]/i.test(agentName) ? "an" : "a"} *${agentName}* run`;
+}
 async function authorizePrHead(ctx) {
   const { msg, io, refuse: refuse3, card, shell, closeLines, clock: clock2, agent, directives, repoCtx } = ctx;
   const preflight = checkPrHeadPreflight({ agent, requestText: directives.text, repoCtx });
@@ -25551,10 +26319,24 @@ function configAwarenessBlock(i) {
       );
     }
   }
+  if (i.boundary) {
+    lines.push(
+      `Boundary in force: ${fmtEffectiveBoundary(i.boundary)} \u2014 a boundary caps what any run in its scope may have and never grants; a preset above a cap is refused, a budget above it clipped. Users set their own with \`config set me --boundary.maxMinutes <n> --boundary.maxIdentity <none|read|write> --boundary.machines <a,b>\` (it can only tighten the channel's and the defaults'); \`config set channel --boundary.\u2026\` caps a channel.`
+    );
+  }
+  if (i.budget?.boundedBy !== void 0) {
+    lines.push(
+      `Budget: ${i.budget.minutes} min (clipped by the ${clipSourceLabel(i.budget.boundedBy)}; the preset asks ${i.budget.presetMinutes}).`
+    );
+  }
+  if (i.budget?.directive !== void 0 && i.budget.boundedBy !== "directive") {
+    const stands = i.budget.boundedBy === void 0 ? `the preset's ${i.budget.presetMinutes} min` : `${i.budget.minutes} min`;
+    lines.push(`This message's \`budget:${i.budget.directive}\` narrowed nothing: the run's budget is ${stands}.`);
+  }
   const channelGate = i.canEditChannelConfig ? "per-channel" : "per-channel; restricted for this user \u2014 ask an admin";
   const levels = `<${EFFORT_LEVELS.join("|")}>`;
   lines.push(
-    `Users inspect and tune settings: \`config show\`, \`config set me --agent <name> --model <provider>/<model> --effort ${levels}\` (per-user; \`--models.<agent>\` / \`--efforts.<agent>\` per agent), \`config set channel \u2026\` (${channelGate}), \`config instructions me "<free text>"\` (custom instructions; \`config instructions channel \u2026\` channel-wide), \`config clear me|channel\`, and per-message \`agent:<name>\` / \`model:<provider>/<model>\` / \`effort:<level>\` directives.`,
+    `Users inspect and tune settings: \`config show\`, \`config set me --agent <name> --model <provider>/<model> --effort ${levels}\` (per-user; \`--models.<agent>\` / \`--efforts.<agent>\` per agent), \`config set channel \u2026\` (${channelGate}), \`config instructions me|channel "<free text>"\` (custom instructions), \`config clear me|channel\`, and per-message \`agent:<name>\` / \`model:<provider>/<model>\` / \`effort:<level>\` / \`budget:<minutes>\` directives.`,
     "When asked about your settings or tuning, answer from this block \u2014 you are not stateless or untunable."
   );
   return lines.join("\n");
@@ -25579,12 +26361,15 @@ function fmtDirective(d) {
   if (d.agent) parts.push(`agent:${d.agent}`);
   if (d.model) parts.push(`model:${d.model}`);
   if (d.effort) parts.push(`effort:${d.effort}`);
+  if (d.budget !== void 0) parts.push(`budget:${d.budget}`);
   return parts.length > 0 ? parts.join(" ") : void 0;
 }
 var CONFIG_AWARENESS_HEADER;
 var init_configAwareness = __esm({
   "../../src/core/configAwareness.ts"() {
     "use strict";
+    init_config();
+    init_profile();
     init_effort();
     CONFIG_AWARENESS_HEADER = "Switchboard runtime config for this run:";
   }
@@ -25795,6 +26580,15 @@ async function openAckCard(deps, ctx) {
   const heartbeat = setInterval(() => card.update(shell.live()), 5e3);
   return { shell, card, heartbeat };
 }
+function budgetClipLabel(agent, profile, budgetDirective) {
+  const idle = budgetDirective !== void 0 && profile.boundedBy !== "directive";
+  if (profile.boundedBy === void 0) {
+    return idle ? `budget:${budgetDirective} narrowed nothing (preset asks ${agent.maxMinutes})` : void 0;
+  }
+  const facts = [`${clipSourceLabel(profile.boundedBy)}; preset asks ${agent.maxMinutes}`];
+  if (idle) facts.push(`budget:${budgetDirective} narrowed nothing`);
+  return `budget ${profile.minutes} min (${facts.join("; ")})`;
+}
 async function registerRun(deps, ctx) {
   const {
     msg,
@@ -25897,6 +26691,7 @@ async function reserveRun(deps, ctx) {
   const {
     msg,
     agent,
+    profile,
     resolved,
     repoCtx,
     channelVisibility,
@@ -25932,7 +26727,8 @@ async function reserveRun(deps, ctx) {
           ...repoCtx.ref !== void 0 ? { ref: repoCtx.ref } : {},
           ...repoCtx.headSha !== void 0 ? { headSha: repoCtx.headSha } : {},
           ...repoCtx.pr !== void 0 ? { pr: repoCtx.pr } : {},
-          readonly: agent.toolset === "readonly",
+          readonly: profile.identity === "read",
+          profile,
           request: requestRow
         },
         card: card.handle ?? null,
@@ -25945,7 +26741,7 @@ async function reserveRun(deps, ctx) {
   return void 0;
 }
 async function attachWorkspace(deps, ctx) {
-  const { msg, io, refuse: refuse3, card, shell, closeLines, clock: clock2, agent, repoCtx, root } = ctx;
+  const { msg, io, refuse: refuse3, card, shell, closeLines, clock: clock2, agent, profile, repoCtx, root } = ctx;
   let round;
   try {
     round = await root.span("dispatch.workspace.attach", async (span) => {
@@ -25964,7 +26760,14 @@ async function attachWorkspace(deps, ctx) {
             workspaceDir: deps.config.config.workspaceDir ?? "./workspaces",
             dataDir: deps.dataDir ?? "./data"
           },
-          round: { threadKey: msg.threadKey, agent, repo: repoCtx.repo, ref: repoCtx.ref, headSha: repoCtx.headSha },
+          round: {
+            threadKey: msg.threadKey,
+            agent,
+            profile,
+            repo: repoCtx.repo,
+            ref: repoCtx.ref,
+            headSha: repoCtx.headSha
+          },
           logKey: msg.threadKey,
           span
         });
@@ -25998,6 +26801,7 @@ async function composePrompt(deps, ctx) {
   const {
     msg,
     agent,
+    profile,
     resolved,
     directives,
     sticky,
@@ -26023,9 +26827,23 @@ async function composePrompt(deps, ctx) {
     effort: resolved.effort,
     channel: scopes.channel,
     user: scopes.user,
-    messageDirective: { agent: directives.agent, model: directives.model, effort: directives.effort },
+    messageDirective: {
+      agent: directives.agent,
+      model: directives.model,
+      effort: directives.effort,
+      budget: directives.budget
+    },
     threadDirective: { agent: sticky.agent, model: sticky.model, effort: sticky.effort },
     canEditChannelConfig: deps.config.canEditChannelConfig(msg.userId),
+    // The boundary in force and the budget this run actually has — the same
+    // values the gate judged, so "how long do you have?" is answered from fact.
+    ...resolved.boundary ? { boundary: resolved.boundary } : {},
+    budget: {
+      minutes: profile.minutes,
+      presetMinutes: agent.maxMinutes,
+      ...profile.boundedBy !== void 0 ? { boundedBy: profile.boundedBy } : {},
+      ...directives.budget !== void 0 ? { directive: directives.budget } : {}
+    },
     mcp: {
       registryOn: deps.capabilities.mcp,
       served: mcpForRun.servers.filter((s) => s.toolCount !== void 0).map((s) => s.server),
@@ -26071,6 +26889,7 @@ var init_provision = __esm({
   "../../src/core/dispatch/provision.ts"() {
     "use strict";
     init_registry();
+    init_profile();
     init_residentTrace();
     init_resident();
     init_memory();
@@ -26102,6 +26921,7 @@ async function claimRun(deps, ctx) {
     channelVisibility,
     run: run2,
     registry,
+    profile,
     selection,
     requestRow,
     reserved,
@@ -26137,7 +26957,8 @@ async function claimRun(deps, ctx) {
           ...repoCtx.ref !== void 0 ? { ref: repoCtx.ref } : {},
           ...repoCtx.headSha !== void 0 ? { headSha: repoCtx.headSha } : {},
           ...repoCtx.pr !== void 0 ? { pr: repoCtx.pr } : {},
-          readonly: agent.toolset === "readonly",
+          readonly: profile.identity === "read",
+          profile,
           selection: resident === true ? "resident" : "sandbox",
           ...binding?.workspace !== void 0 ? { workspace: binding.workspace } : {},
           ...requestRow !== void 0 ? { request: requestRow } : {}
@@ -26150,7 +26971,9 @@ async function claimRun(deps, ctx) {
         tools: mergeTools(TOOLSETS[agent.toolset] ?? [], mcpForRun?.tools).map(
           ({ name, description, inputSchema }) => ({ name, description, inputSchema })
         ),
-        seed: { messages, budgetMs: agent.maxMinutes * 6e4 },
+        // The seed carries the EFFECTIVE budget, so a resume runs on what
+        // this run was admitted with, not on the preset's own number.
+        seed: { messages, budgetMs: profile.minutes * 6e4 },
         // A stop asked of another container (`/runs/stop` there) reaches this
         // run through its heartbeat and is honored like a local one; a fence
         // (another generation took the run) is a hard stop — nothing more may
@@ -26642,7 +27465,7 @@ async function runLoop2(deps, ctx) {
   const {
     msg,
     io,
-    agent,
+    profile,
     resolved,
     provider,
     model,
@@ -26669,6 +27492,7 @@ async function runLoop2(deps, ctx) {
     publishText,
     ending
   } = ctx;
+  const agent = budgetedAgent(ctx.agent, profile);
   const { executor, binding } = round.selection;
   let reviewHead = ctx.reviewHead;
   let lastActivityAt = ctx.loopStartedAt;
@@ -26996,6 +27820,7 @@ async function runLoop2(deps, ctx) {
       run: run2,
       snap,
       agent,
+      profile,
       resolved,
       msg,
       channelVisibility,
@@ -27032,6 +27857,7 @@ async function runLoop2(deps, ctx) {
 var init_runLoop = __esm({
   "../../src/core/dispatch/runLoop.ts"() {
     "use strict";
+    init_profile();
     init_runner();
     init_githubPulls();
     init_repoContext();
@@ -27087,6 +27913,7 @@ async function runShipCodingChild(input, ctx, opts, roundSpan) {
     round: {
       threadKey: input.threadKey,
       agent: spec.agent,
+      profile: declaredProfile(spec.agent),
       repo: entry.repo,
       ref: entry.branch,
       headSha: opts.attachHeadSha
@@ -27275,6 +28102,7 @@ var init_codingChild = __esm({
   "../../src/core/ship/codingChild.ts"() {
     "use strict";
     init_runner();
+    init_profile();
     init_descriptionTurn();
     init_reviewVerdict();
     init_codingPrPostStep();
@@ -27316,7 +28144,14 @@ async function runShipReviewChild(input, ctx, round, roundSpan) {
   if (!pf.ok) return { refusal: pf.reply };
   const ws = await attachRoundWorkspace({
     factory: input.factory,
-    round: { threadKey: input.threadKey, agent: spec.agent, repo: entry.repo, ref: entry.branch, headSha: pinned },
+    round: {
+      threadKey: input.threadKey,
+      agent: spec.agent,
+      profile: declaredProfile(spec.agent),
+      repo: entry.repo,
+      ref: entry.branch,
+      headSha: pinned
+    },
     logKey
   });
   const { executor, resident, binding, note } = ws.selection;
@@ -27450,6 +28285,7 @@ var init_reviewChild = __esm({
   "../../src/core/ship/reviewChild.ts"() {
     "use strict";
     init_runner();
+    init_profile();
     init_reviewVerdict();
     init_reviewedHead();
     init_reviewRound();
@@ -27464,6 +28300,9 @@ function resolveShipCaps(cfg) {
     maxMinutes: cfg?.maxMinutes ?? SHIP_DEFAULT_MAX_MINUTES
   };
 }
+function shipPresetFor(cfg) {
+  return { ...AGENTS.ship, maxMinutes: resolveShipCaps(cfg).maxMinutes };
+}
 function shipInterruptedNote(prUrl) {
   const stands = prUrl ? `Its work stands on GitHub: ${prUrl}.` : "Whatever it pushed stands on its pipeline branch; no PR was opened yet.";
   const reissue = prUrl ? `To continue the review loop, re-issue \`agent:ship\` in this thread with only the PR URL (${prUrl}).` : "To continue, re-issue `agent:ship` in this thread with the task \u2014 round 0 runs again on the same branch.";
@@ -27785,12 +28624,13 @@ var SHIP_DEFAULT_MAX_ROUNDS, SHIP_DEFAULT_MAX_MINUTES, SHIP_ROUND_RESERVE_MS;
 var init_shipPipeline = __esm({
   "../../src/core/shipPipeline.ts"() {
     "use strict";
+    init_registry();
     init_reviewVerdict();
     init_reviewedHead();
     init_codingChild();
     init_reviewChild();
     SHIP_DEFAULT_MAX_ROUNDS = 3;
-    SHIP_DEFAULT_MAX_MINUTES = 120;
+    SHIP_DEFAULT_MAX_MINUTES = AGENTS.ship.maxMinutes;
     SHIP_ROUND_RESERVE_MS = 3 * 6e4;
   }
 });
@@ -27948,7 +28788,7 @@ var init_preflight = __esm({
 
 // ../../src/core/dispatch/ship.ts
 async function runShipBranch(deps, msg, io, ctx) {
-  const { agent, card, directives, history, repoCtx, label, ending, trace, closeLines, refuse: refuse3, doneLines } = ctx;
+  const { agent, profile, card, directives, history, repoCtx, label, ending, trace, closeLines, refuse: refuse3, doneLines } = ctx;
   const root = trace.root;
   const clock2 = deps.clock ?? systemClock;
   const shell = createCardShell({ label, startedAt: ctx.startedAt, now: clock2 });
@@ -28050,7 +28890,8 @@ async function runShipBranch(deps, msg, io, ctx) {
         diagnosis: analyzeRunFriction(startSnap.events, {
           finished: false,
           truncated: startSnap.truncated
-        })
+        }),
+        profile: profileRecordOf(agent, profile)
       }),
       { provisional: true }
     );
@@ -28071,7 +28912,8 @@ async function runShipBranch(deps, msg, io, ctx) {
         ...repoCtx.repo !== void 0 ? { repo: repoCtx.repo } : {},
         ...msg.sourceUrl !== void 0 ? { sourceUrl: msg.sourceUrl } : {},
         ...msg.userName !== void 0 ? { userName: msg.userName } : {},
-        ...entry.resume !== void 0 ? { pr: entry.resume.pr } : {}
+        ...entry.resume !== void 0 ? { pr: entry.resume.pr } : {},
+        profile
       },
       card: card.handle ?? null,
       system: "",
@@ -28146,7 +28988,12 @@ async function runShipBranch(deps, msg, io, ctx) {
       effort: spec.effort,
       channel: scopes.channel,
       user: scopes.user,
-      messageDirective: { agent: directives.agent, model: directives.model, effort: directives.effort },
+      messageDirective: {
+        agent: directives.agent,
+        model: directives.model,
+        effort: directives.effort,
+        budget: directives.budget
+      },
       threadDirective: { agent: ctx.sticky.agent, model: ctx.sticky.model, effort: ctx.sticky.effort },
       canEditChannelConfig: deps.config.canEditChannelConfig(msg.userId)
       // No `mcp` here: ship rounds receive no MCP tools yet (docs/reference/specs/mcp-tools.md
@@ -28185,7 +29032,11 @@ async function runShipBranch(deps, msg, io, ctx) {
         dataDir: deps.dataDir ?? "./data"
       },
       threadKey: msg.threadKey,
-      caps: resolveShipCaps(deps.config.config.ship),
+      // The rounds cap is the config block's; the wall clock is the parent's
+      // effective budget — the preset's declared `ship.maxMinutes` as a
+      // boundary or a `budget:` directive clipped it (agent-ship.md item 8) —
+      // so every child round is clipped to what remains of THAT.
+      caps: { ...resolveShipCaps(deps.config.config.ship), maxMinutes: profile.minutes },
       control: run2.control,
       inbox: ctx.live.inbox,
       // thread follow-ups steered into this run reach the child round in flight (thread-admission item 2)
@@ -28251,7 +29102,8 @@ async function runShipBranch(deps, msg, io, ctx) {
           seal,
           // The last coding round's handoff (agent-ship.md item 14) — the
           // pipeline's, so the ship record carries what its child handed back.
-          ...outcome?.handoff !== void 0 ? { handoff: outcome.handoff } : {}
+          ...outcome?.handoff !== void 0 ? { handoff: outcome.handoff } : {},
+          profile: profileRecordOf(agent, profile)
         }),
         { span: root, ...ledgerRun ? { via: ledgerRun.sink } : {} }
       )
@@ -28505,7 +29357,16 @@ async function dispatch(deps, msg, io, opts = {}) {
     if (await answerOperation(deps, { msg, io, ending, trace, directives, history })) return;
     const { sticky, resolved } = resolveRun(deps, { msg, directives, history });
     if ((await authorizeAgent(deps, { msg, io, refuse: refuse3, agentName: resolved.agentName })).kind === "refused") return;
-    const agent = getAgent(resolved.agentName);
+    const agent = resolved.agentName === "ship" ? shipPresetFor(deps.config.config.ship) : getAgent(resolved.agentName);
+    const profileGate = await authorizeProfile(deps, {
+      msg,
+      io,
+      refuse: refuse3,
+      agent,
+      resolution: resolveProfile({ agent, resolved, resume, budget: directives.budget })
+    });
+    if (profileGate.kind === "refused") return;
+    const { profile } = profileGate;
     const carriedRow = resume?.row ?? restart?.row;
     const admissionCtx = {
       msg,
@@ -28540,6 +29401,7 @@ async function dispatch(deps, msg, io, opts = {}) {
       msg,
       history,
       agent,
+      profile,
       resolved,
       resume,
       root
@@ -28561,15 +29423,19 @@ async function dispatch(deps, msg, io, opts = {}) {
       closeLines,
       clock: clock2,
       agent,
+      profile,
       needsRepo,
       repoCtx
     });
     if (repoGate.kind === "refused") return;
+    const clip3 = budgetClipLabel(agent, profile, directives.budget);
+    if (clip3) shell.setLabel(`${shell.label} \xB7 ${clip3}`);
     if (agent.name === "ship") {
       setupCard = void 0;
       clearInterval(setupHeartbeat);
       await runShipBranch(deps, msg, io, {
         agent,
+        profile,
         modelRef: resolved.modelRef,
         label: shell.label,
         startedAt,
@@ -28626,6 +29492,7 @@ async function dispatch(deps, msg, io, opts = {}) {
     const reservation = await reserveRun(deps, {
       msg,
       agent,
+      profile,
       resolved,
       repoCtx,
       channelVisibility,
@@ -28652,6 +29519,7 @@ async function dispatch(deps, msg, io, opts = {}) {
       closeLines,
       clock: clock2,
       agent,
+      profile,
       repoCtx,
       root
     });
@@ -28689,6 +29557,7 @@ async function dispatch(deps, msg, io, opts = {}) {
     const prompt = await composePrompt(deps, {
       msg,
       agent,
+      profile,
       resolved,
       directives,
       sticky,
@@ -28716,10 +29585,11 @@ async function dispatch(deps, msg, io, opts = {}) {
         `[resume] ${msg.threadKey} run ${run2.id} continues under ${deps.runLedger.gen}: from step ${resume.plan.step}, ${resume.plan.settlements.length} call(s) to settle, ${resume.events.length} event(s) replayed`
       );
     }
-    writeTombstone(deps, { msg, agent, resolved, repoCtx, channelVisibility, run: run2, registry, resume });
+    writeTombstone(deps, { msg, agent, profile, resolved, repoCtx, channelVisibility, run: run2, registry, resume });
     ledgerRun = await claimRun(deps, {
       msg,
       agent,
+      profile,
       resolved,
       repoCtx,
       channelVisibility,
@@ -28741,6 +29611,7 @@ async function dispatch(deps, msg, io, opts = {}) {
       msg,
       io,
       agent,
+      profile,
       resolved,
       provider,
       model,
@@ -28904,6 +29775,7 @@ var init_dispatcher = __esm({
     init_reply();
     init_record();
     init_ship();
+    init_shipPipeline();
     init_settle();
     init_runRegistry();
     init_runEnding();
@@ -28911,22 +29783,6 @@ var init_dispatcher = __esm({
   }
 });
 
-// ../../src/core/workerError.ts
-async function errorSuffix(res) {
-  const text = await res.text().catch(() => "");
-  try {
-    const parsed = JSON.parse(text);
-    return parsed?.error ? `: ${String(parsed.error)}` : "";
-  } catch {
-    return "";
-  }
-}
-var init_workerError = __esm({
-  "../../src/core/workerError.ts"() {
-    "use strict";
-  }
-});
-
 // ../../src/core/runStoreWorker.ts
 function describeError2(err2, depth = 0) {
   if (!(err2 instanceof Error)) return String(err2);
@@ -29041,10 +29897,10 @@ var init_runStoreWorker = __esm({
           throw new TransientStoreError(`run store ${path}: ${describeError2(err2)}`);
         }
         if (!res.ok) {
-          const message = `run store ${path} HTTP ${res.status}${await errorSuffix(res)}`;
-          if (res.status === 404) throw new RouteMissingError(message);
-          if (res.status >= 500 || res.status === 408 || res.status === 429) throw new TransientStoreError(message);
-          throw new PermanentStoreError(message);
+          const message2 = `run store ${path} HTTP ${res.status}${await errorSuffix(res)}`;
+          if (res.status === 404) throw new RouteMissingError(message2);
+          if (res.status >= 500 || res.status === 408 || res.status === 429) throw new TransientStoreError(message2);
+          throw new PermanentStoreError(message2);
         }
         const data = await res.json().catch(() => null);
         if (typeof data !== "object" || data === null)
@@ -29614,7 +30470,7 @@ function createLedgerWriteThrough(opts) {
      *  no record at all was killed before its conversation was stored and
      *  closes `interrupted`. */
     async seed(messages, budgetMs) {
-      const turns = messages.map((message, idx) => ({ idx, message }));
+      const turns = messages.map((message2, idx) => ({ idx, message: message2 }));
       try {
         const seeded = await ledger.seed(this.runId, gen, turns);
         if (!seeded.ok) {
@@ -29644,7 +30500,7 @@ function createLedgerWriteThrough(opts) {
     }
     async step(report2) {
       if (this.detached) return;
-      const turns = report2.turns.map((message, i) => ({ idx: report2.firstIdx + i, message }));
+      const turns = report2.turns.map((message2, i) => ({ idx: report2.firstIdx + i, message: message2 }));
       const record = {
         step: ++this.stepNo,
         seq: this.lastSeq,
@@ -29809,9 +30665,9 @@ function createLedgerWriteThrough(opts) {
       return run2;
     },
     liveRuns: () => [...live],
-    async pushInbox(runId3, message) {
+    async pushInbox(runId3, message2) {
       try {
-        const result = await ledger.pushInbox(runId3, message);
+        const result = await ledger.pushInbox(runId3, message2);
         if (result.ok && result.seq !== void 0) return result.seq;
         warn(`[ledger] inbox push refused for run ${runId3}: no live row \u2014 the follow-up rides in memory only`);
         return void 0;
@@ -31352,8 +32208,8 @@ function createSlackApp(deps) {
       }
     );
   });
-  app.message(async ({ message, client }) => {
-    const m = message;
+  app.message(async ({ message: message2, client }) => {
+    const m = message2;
     if (classifyMessage(m) === "skip") return;
     botUserId ??= (await client.auth.test()).user_id ?? void 0;
     const decision = classifyMessage(m, botUserId);
@@ -32042,8 +32898,8 @@ function toIncomingMessage2(identity2, args) {
 function ok(id, result) {
   return { jsonrpc: "2.0", id, result };
 }
-function err(id, code, message, data) {
-  return { jsonrpc: "2.0", id, error: data ? { code, message, data } : { code, message } };
+function err(id, code, message2, data) {
+  return { jsonrpc: "2.0", id, error: data ? { code, message: message2, data } : { code, message: message2 } };
 }
 function readId(msg) {
   const id = msg.id;
@@ -32999,7 +33855,7 @@ function loadWebAssets(distDir) {
     const full = join13(assetsDir, name);
     if (statSync3(full).isFile()) files.set(`/assets/${name}`, readFileSync16(full));
   }
-  const serve = (req, res) => {
+  const serve2 = (req, res) => {
     const path = (req.url ?? "/").split("?")[0];
     if (!path.startsWith("/assets/")) return false;
     const method = (req.method ?? "GET").toUpperCase();
@@ -33023,7 +33879,7 @@ function loadWebAssets(distDir) {
     else res.end(body);
     return true;
   };
-  return { entry, serve };
+  return { entry, serve: serve2 };
 }
 var CONTENT_TYPES, WEB_DIST_DIR;
 var init_webAssets = __esm({
@@ -33227,6 +34083,7 @@ function createDeliveryViewHandler(deps, shell) {
     }
     const weeksParam = url.searchParams.get("weeks");
     const sinceParam = url.searchParams.get("since");
+    const fresh = url.searchParams.get("fresh") === "1";
     const runs = async (range) => {
       if (!deps.runs) return [];
       const page2 = await deps.runs.listRuns({
@@ -33240,6 +34097,7 @@ function createDeliveryViewHandler(deps, shell) {
     deps.service.report(repo, {
       ...weeksParam !== null ? { weeks: Number(weeksParam) } : {},
       ...sinceParam !== null ? { since: sinceParam } : {},
+      ...fresh ? { fresh } : {},
       runs
     }).then((report2) => {
       if (route2.kind === "json") {
@@ -33623,14 +34481,14 @@ function createMcpConnectViewHandler(deps) {
 async function complete(svc, nonce, identity2, token, res) {
   const { decision, verified, toolCount, warning, server } = await svc.completeTicket(nonce, identity2, token);
   if (!decision.ok) {
-    const message = refusalMessage(decision.refusal);
+    const message2 = refusalMessage(decision.refusal);
     if (decision.refusal.kind === "bad_token" && server)
-      return page(res, 400, "Token not accepted", `<p class="err">${esc(message)}</p>${entryForm(server, nonce)}`);
+      return page(res, 400, "Token not accepted", `<p class="err">${esc(message2)}</p>${entryForm(server, nonce)}`);
     return page(
       res,
       statusFor(decision.refusal.kind),
       "Connect link unavailable",
-      `<p class="err">${esc(message)}</p>`
+      `<p class="err">${esc(message2)}</p>`
     );
   }
   if (verified === false) {
@@ -33646,15 +34504,15 @@ async function complete(svc, nonce, identity2, token, res) {
 async function start(svc, nonce, identity2, res) {
   const result = await svc.startOAuth(nonce, identity2);
   if (!result.ok) {
-    const message = refusalMessage(result.refusal);
+    const message2 = refusalMessage(result.refusal);
     if (result.refusal.kind === "oauth_failed" && result.server)
       return page(
         res,
         502,
         "Sign-in could not start",
-        `<p class="err">${esc(message)}</p><p>Nothing was stored.</p>${entryForm(result.server, nonce)}`
+        `<p class="err">${esc(message2)}</p><p>Nothing was stored.</p>${entryForm(result.server, nonce)}`
       );
-    return page(res, statusFor(result.refusal.kind), "Connect link unavailable", `<p class="err">${esc(message)}</p>`);
+    return page(res, statusFor(result.refusal.kind), "Connect link unavailable", `<p class="err">${esc(message2)}</p>`);
   }
   const host = hostOf(result.redirectUrl);
   page(
@@ -33688,13 +34546,13 @@ function callback(svc, params, identity2, res) {
   }).then((result) => {
     if (!result.ok) {
       const refusal = result.refusal ?? { kind: "not_found" };
-      const message = refusalMessage(refusal);
+      const message2 = refusalMessage(refusal);
       const retry = result.server && refusal.kind === "oauth_failed" ? `<p>Nothing was stored. Open the connect link again to retry.</p>` : "";
       return page(
         res,
         refusal.kind === "oauth_failed" ? 502 : statusFor(refusal.kind),
         "Sign-in did not complete",
-        `<p class="err">${esc(message)}</p>${retry}`
+        `<p class="err">${esc(message2)}</p>${retry}`
       );
     }
     return connected(res, result.server, result.toolCount, result.warning);
@@ -33893,19 +34751,19 @@ var init_processMetrics = __esm({
 function hasData(part) {
   return (part.type === "image" || part.type === "document") && typeof part.data === "string";
 }
-function turnRows(idx, message, opts = {}) {
+function turnRows(idx, message2, opts = {}) {
   const partBytes = opts.partBytes ?? TRANSCRIPT_PART_BYTES;
   const refBytes = opts.attachmentRefBytes ?? ATTACHMENT_REF_BYTES;
   const rows = [];
   const attachments = [];
-  message.content.forEach((part, i) => {
+  message2.content.forEach((part, i) => {
     let stored = part;
     if (hasData(part) && part.data.length > refBytes) {
       const ref = attachmentRef(idx, i);
       attachments.push({ ref, mediaType: part.mediaType, data: part.data });
       stored = { ...part, data: "", dataRef: ref };
     }
-    const json = JSON.stringify({ role: message.role, part: stored });
+    const json = JSON.stringify({ role: message2.role, part: stored });
     const bytes = utf8ByteLength(json);
     if (bytes > partBytes) {
       throw new Error(`transcript: part ${i} of turn ${idx} is ${bytes} bytes, over the ${partBytes} row budget`);
@@ -34114,9 +34972,9 @@ var init_runLedgerWorker = __esm({
         this.checkIds(runId3, gen);
         return this.fenceResult(await this.post("/runs/state", { storeKey: this.opts.storeKey, runId: runId3, gen, state }));
       }
-      async pushInbox(runId3, message) {
+      async pushInbox(runId3, message2) {
         this.checkIds(runId3);
-        const r = await this.post("/runs/inbox", { storeKey: this.opts.storeKey, runId: runId3, message });
+        const r = await this.post("/runs/inbox", { storeKey: this.opts.storeKey, runId: runId3, message: message2 });
         return { ok: r.data.ok === true, ...typeof r.data.seq === "number" ? { seq: r.data.seq } : {} };
       }
       async readInbox(runId3, afterSeq) {
@@ -34503,7 +35361,7 @@ var init_resume = __esm({
       "submit_handoff",
       "submit_dispositions"
     ]);
-    toolUsesOf = (message) => message?.role === "assistant" ? message.content.filter((p) => p.type === "tool_use") : [];
+    toolUsesOf = (message2) => message2?.role === "assistant" ? message2.content.filter((p) => p.type === "tool_use") : [];
   }
 });
 
@@ -35196,7 +36054,16 @@ async function runBot() {
   };
   const runsService = createRunsService({ registry: defaultRunRegistry, store: runStore, ledger: ledgerClient });
   const scheduleStore = buildScheduleStore(config.config.schedules, processSecrets, (m) => console.warn(`[schedules] ${m}`)) ?? new NullScheduleStore();
-  const deliveryService = capabilities.github ? deliveryServiceFromConfig(parseDeliveryConfig(config.config.delivery)) : new NullDeliveryService();
+  const deliveryWarn = (m) => console.warn(`[delivery] ${m}`);
+  const deliveryConfig = parseDeliveryConfig(config.config.delivery);
+  const delivery = capabilities.github ? deliveryFromConfig(deliveryConfig, {
+    snapshots: buildDeliverySnapshotStore(config.config, processSecrets, deliveryWarn),
+    warn: deliveryWarn
+  }) : void 0;
+  const deliveryService = delivery?.service ?? new NullDeliveryService();
+  const deliveryEveryMinutes = deliveryConfig?.snapshot.everyMinutes ?? SNAPSHOT_EVERY_MINUTES.default;
+  if (delivery && deliveryService.repos().length > 0)
+    delivery.source.startRefreshLoop({ repos: deliveryService.repos(), everyMinutes: deliveryEveryMinutes });
   const commands = buildCoreCommands(config, runStore, {
     registry: defaultRunRegistry,
     secrets: processSecrets,
@@ -35254,7 +36121,7 @@ async function runBot() {
     const costsView = createCostsViewHandler(costsService, shell);
     const costsState = capabilities.costs ? `GET /costs (${costsService.groups().join(",")}; LLM ${anthropicAdminKey ? "on" : "off"})` : costsCfg ? `GET /costs (503 \u2014 ${costsCfg.cloudflareTokenEnv} not set)` : "GET /costs (503 \u2014 no costs config)";
     const deliveryView = createDeliveryViewHandler({ service: deliveryService, runs: runsService }, shell);
-    const deliveryState = !capabilities.github ? "GET /delivery (503 \u2014 no GitHub credential)" : deliveryService.repos().length === 0 ? "GET /delivery (503 \u2014 no delivery.repos)" : `GET /delivery (${deliveryService.repos().join(",")})`;
+    const deliveryState = !capabilities.github ? "GET /delivery (503 \u2014 no GitHub credential)" : deliveryService.repos().length === 0 ? "GET /delivery (503 \u2014 no delivery.repos)" : `GET /delivery (${deliveryService.repos().join(",")}; snapshot every ${deliveryEveryMinutes} min)`;
     const tokenCount = Object.keys(auth.tokens).length;
     const liveViewState = process.env.PUBLIC_BASE_URL ? "GET /runs (index) + /runs/:id (live view)" : "GET /runs (index) + live view (no PUBLIC_BASE_URL \u2014 per-run links omitted)";
     const accessConfig = parseAccessConfig(publicEnv());
@@ -35580,6 +36447,7 @@ var init_index = __esm({
     init_costsView();
     init_deliveryView();
     init_delivery();
+    init_deliverySnapshotStore();
     init_costs();
     init_residentAdmin();
     init_residentFleet();
@@ -35787,8 +36655,8 @@ function exitCodeFor(error) {
   if (error === "busy") return 75;
   return 1;
 }
-function errorLine(code, message) {
-  return `error (${code}): ${message}`;
+function errorLine(code, message2) {
+  return `error (${code}): ${message2}`;
 }
 async function runCommand(commands, parsed, caller, opts = {}) {
   const cmd = commands.get(parsed.id);