@coreplane/switchboard 1.216.1 → 1.217.0

package/dist/cli.js

@@ -2167,8 +2167,8 @@ var init_effort = __esm({
 });
 
 // ../../src/core/dashboardAuthConfig.ts
-function resolveDashboardAuthMode(configured2, accessConfigured) {
-  if (configured2 !== void 0) return configured2;
+function resolveDashboardAuthMode(configured3, accessConfigured) {
+  if (configured3 !== void 0) return configured3;
   return accessConfigured ? "access" : "none";
 }
 function tokenSubjectOf(actor) {
@@ -7582,6 +7582,159 @@ var init_imagesHost = __esm({
   }
 });
 
+// ../../src/deploy/artifactsBucket.ts
+function lifecycleRulesFor(retentionDays) {
+  if (!Number.isInteger(retentionDays) || retentionDays < 1) {
+    throw new Error(`retentionDays must be an integer >= 1, got ${String(retentionDays)}`);
+  }
+  return [
+    {
+      id: EXPIRE_RULE_ID,
+      enabled: true,
+      conditions: { prefix: "" },
+      deleteObjectsTransition: { condition: { type: "Age", maxAge: retentionDays * DAY_SECONDS } }
+    },
+    {
+      id: ABORT_RULE_ID,
+      enabled: true,
+      conditions: { prefix: "" },
+      abortMultipartUploadsTransition: { condition: { type: "Age", maxAge: ABORT_MULTIPART_AFTER_DAYS * DAY_SECONDS } }
+    }
+  ];
+}
+function describeRules(rules) {
+  return rules.map((r) => {
+    const days = (s) => `${s / DAY_SECONDS} day${s === DAY_SECONDS ? "" : "s"}`;
+    if (r.deleteObjectsTransition)
+      return `${r.id}: delete every object ${days(r.deleteObjectsTransition.condition.maxAge)} after it was written`;
+    if (r.abortMultipartUploadsTransition)
+      return `${r.id}: abort an incomplete multipart upload after ${days(r.abortMultipartUploadsTransition.condition.maxAge)}`;
+    return `${r.id}: (no transition)`;
+  });
+}
+function rulesMatch(readBack, wanted) {
+  const rules = Array.isArray(readBack?.rules) ? readBack.rules : null;
+  if (!rules) return { ok: false, problem: "the read-back carries no `rules` array" };
+  const problems = [];
+  for (const want of wanted) {
+    const got = rules.find((r) => r?.id === want.id);
+    if (!got) {
+      problems.push(`rule ${want.id} is missing`);
+      continue;
+    }
+    if (got.enabled !== true) problems.push(`rule ${want.id} is not enabled`);
+    const wantAge = want.deleteObjectsTransition?.condition.maxAge ?? want.abortMultipartUploadsTransition?.condition.maxAge;
+    const gotAge = got.deleteObjectsTransition?.condition?.maxAge ?? got.abortMultipartUploadsTransition?.condition?.maxAge;
+    if (gotAge !== wantAge) problems.push(`rule ${want.id} has maxAge ${String(gotAge)}, not ${String(wantAge)}`);
+  }
+  return problems.length === 0 ? { ok: true } : { ok: false, problem: problems.join("; ") };
+}
+function privacyOf(managed, custom) {
+  const open = [];
+  if (managed.enabled) open.push(`the managed r2.dev domain ${managed.domain} is enabled`);
+  for (const d of custom) if (d.enabled) open.push(`the custom domain ${d.domain} is enabled`);
+  return open.length === 0 ? { private: true, open: [] } : { private: false, open };
+}
+function bucketTokenMissingProblem() {
+  return `${API_TOKEN_ENV} is not set \u2014 the bucket's lifecycle rules and domain settings are read and written with a Cloudflare API token holding Workers R2 Storage: Edit (Read suffices for \`artifacts check\`); the bot's ARTIFACTS_R2_* token cannot do this and is never used here`;
+}
+function bucketCallProblem(method, url, status3, text) {
+  const words = text.trim().slice(0, 300);
+  const permission = status3 === 401 || status3 === 403 ? ` \u2014 the token lacks the permission (Workers R2 Storage: ${method === "GET" ? "Read" : "Edit"} on this account)` : "";
+  return `${method} ${url} answered HTTP ${status3}${permission}${words ? `: ${words}` : ""}`;
+}
+function artifactsBucketHost(options = {}) {
+  const env = options.env ?? process.env;
+  const fetchImpl = options.fetch ?? fetch;
+  const call2 = async (method, path, body) => {
+    const token2 = env[API_TOKEN_ENV]?.trim();
+    if (!token2) return { ok: false, problem: bucketTokenMissingProblem() };
+    const url = `${API}${path}`;
+    let res;
+    try {
+      res = await fetchImpl(url, {
+        method,
+        headers: {
+          authorization: `Bearer ${token2}`,
+          ...body !== void 0 ? { "content-type": "application/json" } : {}
+        },
+        ...body !== void 0 ? { body: JSON.stringify(body) } : {}
+      });
+    } catch (err2) {
+      return { ok: false, problem: `${method} ${url} failed \u2014 ${err2 instanceof Error ? err2.message : String(err2)}` };
+    }
+    const text = await res.text().catch(() => "");
+    if (!res.ok) return { ok: false, problem: bucketCallProblem(method, url, res.status, text) };
+    let envelope;
+    try {
+      envelope = JSON.parse(text);
+    } catch {
+      return { ok: false, problem: `${method} ${url} answered HTTP ${res.status} with a body that is not JSON` };
+    }
+    if (envelope.success !== true) {
+      const errors = Array.isArray(envelope.errors) ? envelope.errors.map((e) => e?.message ?? JSON.stringify(e)).join("; ") : "no error given";
+      return { ok: false, problem: `${method} ${url} answered success: false \u2014 ${errors}` };
+    }
+    return { ok: true, value: envelope.result };
+  };
+  const bucketPath = (account2, bucket, tail) => `/accounts/${encodeURIComponent(account2)}/r2/buckets/${encodeURIComponent(bucket)}/${tail}`;
+  return {
+    async putLifecycle(account2, bucket, rules) {
+      const r = await call2("PUT", bucketPath(account2, bucket, "lifecycle"), { rules });
+      return r.ok ? { ok: true, value: void 0 } : r;
+    },
+    getLifecycle(account2, bucket) {
+      return call2("GET", bucketPath(account2, bucket, "lifecycle"));
+    },
+    async managedDomain(account2, bucket) {
+      const r = await call2("GET", bucketPath(account2, bucket, "domains/managed"));
+      if (!r.ok) return r;
+      const v = r.value;
+      if (!v || typeof v.domain !== "string" || typeof v.enabled !== "boolean") {
+        return {
+          ok: false,
+          problem: `the managed-domain answer has no domain/enabled: ${JSON.stringify(r.value).slice(0, 200)}`
+        };
+      }
+      return { ok: true, value: { domain: v.domain, enabled: v.enabled } };
+    },
+    async customDomains(account2, bucket) {
+      const r = await call2("GET", bucketPath(account2, bucket, "domains/custom"));
+      if (!r.ok) return r;
+      const list = r.value?.domains;
+      if (!Array.isArray(list)) {
+        return {
+          ok: false,
+          problem: `the custom-domains answer has no domains array: ${JSON.stringify(r.value).slice(0, 200)}`
+        };
+      }
+      const domains = [];
+      for (const d of list) {
+        if (typeof d?.domain !== "string" || typeof d.enabled !== "boolean") {
+          return {
+            ok: false,
+            problem: `a custom domain entry has no domain/enabled: ${JSON.stringify(d).slice(0, 200)}`
+          };
+        }
+        domains.push({ domain: d.domain, enabled: d.enabled });
+      }
+      return { ok: true, value: domains };
+    }
+  };
+}
+var ABORT_MULTIPART_AFTER_DAYS, DAY_SECONDS, EXPIRE_RULE_ID, ABORT_RULE_ID, API;
+var init_artifactsBucket = __esm({
+  "../../src/deploy/artifactsBucket.ts"() {
+    "use strict";
+    init_imagesHost();
+    ABORT_MULTIPART_AFTER_DAYS = 1;
+    DAY_SECONDS = 86400;
+    EXPIRE_RULE_ID = "switchboard-artifacts-expire";
+    ABORT_RULE_ID = "switchboard-artifacts-abort-multipart";
+    API = "https://api.cloudflare.com/client/v4";
+  }
+});
+
 // ../../src/deploy/secrets.ts
 import { z as z3 } from "zod";
 function isOptionalOn(secret2, worker) {
@@ -7842,6 +7995,7 @@ var init_runEvents = __esm({
       "mcp_unavailable",
       "follow_up",
       "resumed",
+      "seed",
       "description_turn",
       "cold_sandbox",
       "pr_not_opened",
@@ -9290,6 +9444,7 @@ var init_resident = __esm({
             ref: data.ref,
             sha: data.sha,
             ...typeof data.workspace === "string" && data.workspace ? { workspace: data.workspace } : {},
+            ...typeof data.user === "string" && data.user ? { user: data.user } : {},
             ...trace.length > 0 ? { trace } : {},
             ...typeof data.attachMs === "number" && Number.isFinite(data.attachMs) ? { attachMs: data.attachMs } : {}
           };
@@ -11996,8 +12151,110 @@ var init_commandRegistry = __esm({
   }
 });
 
-// ../../src/core/commands/config.ts
+// ../../src/core/commands/artifacts.ts
 import { z as z5 } from "zod";
+async function configured2(deps) {
+  const cfg = await deps.artifacts.config();
+  if (!cfg) {
+    throw new CommandError(
+      "unavailable",
+      "artifacts: is not configured \u2014 name the bucket under `artifacts.r2` in config.yaml before managing it (docs/how-to/store-run-artifacts.md)"
+    );
+  }
+  return cfg;
+}
+function registerArtifactsCommands(registry) {
+  for (const cmd of artifactsCommands) registry.register(cmd);
+}
+var defineCommand2, lifecycleOptions, artifactsLifecycle, artifactsCheck, artifactsCommands;
+var init_artifacts = __esm({
+  "../../src/core/commands/artifacts.ts"() {
+    "use strict";
+    init_config();
+    init_artifactsBucket();
+    init_commandRegistry();
+    defineCommand2 = commandDefiner();
+    lifecycleOptions = z5.object({
+      dryRun: flag.optional().describe("print the rules that would be applied and touch nothing")
+    });
+    artifactsLifecycle = defineCommand2({
+      id: "artifacts.lifecycle",
+      options: lifecycleOptions,
+      action: "deploy:write",
+      effect: "write",
+      surfaces: { chat: false, mcp: false, http: false },
+      describe: "Apply the artifacts bucket's lifecycle rules from config.yaml \u2014 objects expire after `artifacts.retentionDays` (default 30), incomplete multipart uploads abort after one day \u2014 and read them back; `--dry-run` prints the rules and touches nothing. Operator-side: CLOUDFLARE_API_TOKEN with Workers R2 Storage: Edit, never the bot's token.",
+      render: (output) => {
+        const o = output;
+        const lines = describeRules(o.rules).map((l) => `  - ${l}`);
+        const head = o.applied ? `applied ${o.rules.length} lifecycle rule(s) to ${o.bucket} (account ${o.account}) and read them back equal:` : `dry run \u2014 would apply ${o.rules.length} lifecycle rule(s) to ${o.bucket} (account ${o.account}); nothing touched:`;
+        return [head, ...lines].join("\n");
+      },
+      handler: async ({ options, deps }) => {
+        const cfg = await configured2(deps);
+        const retentionDays = cfg.retentionDays ?? ARTIFACT_DEFAULTS.retentionDays;
+        const rules = lifecycleRulesFor(retentionDays);
+        const { accountId: account2, bucket } = cfg.r2;
+        const out = { account: account2, bucket, retentionDays, rules, applied: false, readBack: false };
+        if (options.dryRun) return out;
+        const put = await deps.artifacts.bucket.putLifecycle(account2, bucket, rules);
+        if (!put.ok)
+          throw new CommandError("unavailable", `applying the lifecycle rules to ${bucket} failed \u2014 ${put.problem}`);
+        const read = await deps.artifacts.bucket.getLifecycle(account2, bucket);
+        if (!read.ok)
+          throw new CommandError(
+            "unavailable",
+            `the rules were applied to ${bucket} but reading them back failed \u2014 ${read.problem}; run \`artifacts lifecycle\` again to confirm`
+          );
+        const match = rulesMatch(read.value, rules);
+        if (!match.ok)
+          throw new CommandError(
+            "unavailable",
+            `the rules were applied to ${bucket} but the read-back differs \u2014 ${match.problem}; the bucket's configuration is not what config.yaml says`
+          );
+        return { ...out, applied: true, readBack: true };
+      }
+    });
+    artifactsCheck = defineCommand2({
+      id: "artifacts.check",
+      action: "deploy:write",
+      effect: "read",
+      surfaces: { chat: false, mcp: false, http: false },
+      describe: "Report whether the artifacts bucket is private: its managed r2.dev domain must be disabled and no custom domain enabled \u2014 the two ways R2 serves a bucket without a signature. Operator-side: CLOUDFLARE_API_TOKEN with Workers R2 Storage: Read, never the bot's token.",
+      render: (output) => {
+        const o = output;
+        if (o.private) {
+          return `${o.bucket} (account ${o.account}) is private: the managed domain ${o.managedDomain.domain} is disabled and ${o.customDomains.length === 0 ? "no custom domain is attached" : `none of its ${o.customDomains.length} custom domain(s) is enabled`}`;
+        }
+        return [`${o.bucket} (account ${o.account}) is NOT private:`, ...o.open.map((l) => `  - ${l}`)].join("\n");
+      },
+      handler: async ({ deps }) => {
+        const cfg = await configured2(deps);
+        const { accountId: account2, bucket } = cfg.r2;
+        const managed = await deps.artifacts.bucket.managedDomain(account2, bucket);
+        if (!managed.ok)
+          throw new CommandError("unavailable", `reading ${bucket}'s managed domain failed \u2014 ${managed.problem}`);
+        const custom = await deps.artifacts.bucket.customDomains(account2, bucket);
+        if (!custom.ok)
+          throw new CommandError("unavailable", `reading ${bucket}'s custom domains failed \u2014 ${custom.problem}`);
+        const verdict = privacyOf(managed.value, custom.value);
+        const out = {
+          account: account2,
+          bucket,
+          private: verdict.private,
+          open: [...verdict.open],
+          managedDomain: managed.value,
+          customDomains: custom.value
+        };
+        return out;
+      }
+    });
+    artifactsCommands = [artifactsLifecycle, artifactsCheck];
+  }
+});
+
+// ../../src/core/commands/config.ts
+import { z as z6 } from "zod";
 function targetChannel(caller, channel) {
   const target = channel ?? caller.origin?.channelId;
   if (!target) throw new CommandError("invalid_input", "channel: required on this surface \u2014 pass --channel <id>");
@@ -12017,7 +12274,7 @@ function summarizeScope(s) {
 function registerConfigCommands(registry) {
   for (const cmd of configCommands) registry.register(cmd);
 }
-var defineCommand2, scopeArg, channelOption, effort, effortLevels, modelRef, boundaryOption, who, configShow, configSet, configClear, quote, configInstructions, configCommands;
+var defineCommand3, scopeArg, channelOption, effort, effortLevels, modelRef, boundaryOption, who, configShow, configSet, configClear, quote, configInstructions, configCommands;
 var init_config4 = __esm({
   "../../src/core/commands/config.ts"() {
     "use strict";
@@ -12027,25 +12284,25 @@ var init_config4 = __esm({
     init_effort();
     init_authorize();
     init_commandRegistry();
-    defineCommand2 = commandDefiner();
+    defineCommand3 = commandDefiner();
     scopeArg = {
       name: "scope",
-      schema: z5.enum(["channel", "me"]),
+      schema: z6.enum(["channel", "me"]),
       describe: "`channel` (everyone here) or `me` (your own runs)"
     };
-    channelOption = z5.string().optional().describe("target channel (default: the channel you are speaking in)");
-    effort = z5.enum(EFFORT_LEVELS);
+    channelOption = z6.string().optional().describe("target channel (default: the channel you are speaking in)");
+    effort = z6.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(", ")}`)
+    modelRef = z6.string().min(1);
+    boundaryOption = z6.object({
+      maxMinutes: z6.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: z6.enum(IDENTITIES).optional().describe(`cap the identity runs may act as <${IDENTITIES.join("|")}> \u2014 a preset above it is refused`),
+      machines: z6.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({
+    configShow = defineCommand3({
       id: "config.show",
-      options: z5.object({ channel: channelOption }),
+      options: z6.object({ channel: channelOption }),
       action: "config:read",
       effect: "read",
       describe: "The effective agent/model/effort for you in this channel, the defaults, both scopes, and what is restricted.",
@@ -12059,15 +12316,15 @@ var init_config4 = __esm({
         return description;
       }
     });
-    configSet = defineCommand2({
+    configSet = defineCommand3({
       id: "config.set",
       args: [scopeArg],
-      options: z5.object({
-        agent: z5.string().min(1).optional().describe("force which agent handles requests in this scope"),
+      options: z6.object({
+        agent: z6.string().min(1).optional().describe("force which agent handles requests in this scope"),
         model: modelRef.optional().describe("force a model (provider/model) regardless of agent"),
-        models: z5.record(z5.string(), modelRef).optional().describe("per-agent model: --models.<agent> provider/model"),
+        models: z6.record(z6.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}`),
+        efforts: z6.record(z6.string(), effort).optional().describe(`per-agent effort: --efforts.<agent> ${effortLevels}`),
         boundary: boundaryOption,
         channel: channelOption
       }),
@@ -12134,10 +12391,10 @@ var init_config4 = __esm({
         return { scope: args.scope, effective: summarizeScope(effective) };
       }
     });
-    configClear = defineCommand2({
+    configClear = defineCommand3({
       id: "config.clear",
       args: [scopeArg],
-      options: z5.object({ channel: channelOption }),
+      options: z6.object({ channel: channelOption }),
       action: "config:write",
       effect: "write",
       describe: "Drop every runtime override of a channel (gated) or of yourself; static config.yaml values show through again.",
@@ -12154,18 +12411,18 @@ var init_config4 = __esm({
       }
     });
     quote = (text) => `> ${text.replace(/\n/g, "\n> ")}`;
-    configInstructions = defineCommand2({
+    configInstructions = defineCommand3({
       id: "config.instructions",
       args: [
         scopeArg,
         {
           name: "text",
-          schema: z5.string().optional(),
+          schema: z6.string().optional(),
           describe: 'the instructions; omit to show the current text, pass "" to clear',
           rest: true
         }
       ],
-      options: z5.object({ channel: channelOption }),
+      options: z6.object({ channel: channelOption }),
       action: "config:write",
       effect: "write",
       describe: "Custom instructions for a channel (gated) or for yourself \u2014 advisory prompt content that never changes agent, model, or permissions.",
@@ -12226,7 +12483,7 @@ ${quote(current ?? "")}`;
 
 // ../../src/core/commands/contract.ts
 import { basename, dirname as dirname8, join as join10 } from "node:path";
-import { z as z6 } from "zod";
+import { z as z7 } from "zod";
 function repoRootOfPlan(planPath) {
   const plans = dirname8(planPath);
   const docs = dirname8(plans);
@@ -12244,24 +12501,24 @@ function renderOutput(output) {
 function registerContractCommands(registry) {
   for (const cmd of contractCommands) registry.register(cmd);
 }
-var defineCommand3, SPECS_DIR, RULES_FILES, contractRender, contractCommands;
+var defineCommand4, SPECS_DIR, RULES_FILES, contractRender, contractCommands;
 var init_contract2 = __esm({
   "../../src/core/commands/contract.ts"() {
     "use strict";
     init_commandRegistry();
     init_contract();
-    defineCommand3 = commandDefiner();
+    defineCommand4 = commandDefiner();
     SPECS_DIR = join10("docs", "reference", "specs");
     RULES_FILES = ["AGENTS.md", "CLAUDE.md"];
-    contractRender = defineCommand3({
+    contractRender = defineCommand4({
       id: "contract.render",
-      options: z6.object({
-        plan: z6.string().min(1).describe("path of the plan record (docs/plans/<file>.md)"),
-        unit: z6.string().regex(/^U\d+$/, "expected a unit id like U<n>").describe("the unit to render, as its heading spells it (U<n>)"),
-        root: z6.string().min(1).optional().describe("the repository root the specs and rules are read under (default: the root the plan path implies)"),
-        branch: z6.string().min(1).optional().describe("the unit's branch, named in the first instruction"),
-        onto: z6.string().min(1).optional().describe("the merged parent the branch is rebased onto"),
-        maxChars: z6.coerce.number().int().positive().optional().describe(`the rendered block's budget in characters (default ${DEFAULT_CONTRACT_MAX_CHARS})`)
+      options: z7.object({
+        plan: z7.string().min(1).describe("path of the plan record (docs/plans/<file>.md)"),
+        unit: z7.string().regex(/^U\d+$/, "expected a unit id like U<n>").describe("the unit to render, as its heading spells it (U<n>)"),
+        root: z7.string().min(1).optional().describe("the repository root the specs and rules are read under (default: the root the plan path implies)"),
+        branch: z7.string().min(1).optional().describe("the unit's branch, named in the first instruction"),
+        onto: z7.string().min(1).optional().describe("the merged parent the branch is rebased onto"),
+        maxChars: z7.coerce.number().int().positive().optional().describe(`the rendered block's budget in characters (default ${DEFAULT_CONTRACT_MAX_CHARS})`)
       }),
       action: "contract:read",
       effect: "read",
@@ -13908,7 +14165,7 @@ var init_runRecord = __esm({
     RUN_STATUSES = ["completed", "stopped_soft", "stopped_hard", "failed", "interrupted"];
     RUN_ID_PATTERN = /^[A-Za-z0-9_-]{1,64}$/;
     REVIEW_HEAD_PATTERN = /^[0-9a-f]{7,40}$/;
-    RUN_SEEDS = ["channel", "parent"];
+    RUN_SEEDS = ["channel", "parent", "session"];
     SESSION_KEY_PATTERN = /^[A-Za-z0-9_.:@+/-]{1,512}$/;
     isIndex = (v) => typeof v === "number" && Number.isInteger(v) && v >= 0;
     MACHINE_CLASSES_IN_RECORD = {
@@ -13953,11 +14210,11 @@ var init_runRecord = __esm({
 });
 
 // ../../src/core/commands/delivery.ts
-import { z as z7 } from "zod";
+import { z as z8 } from "zod";
 function registerDeliveryCommands(registry) {
   for (const cmd of deliveryCommands) registry.register(cmd);
 }
-var defineCommand4, REPO_SLUG3, ISO_DAY3, asJson, deliveryReport, deliveryCommands;
+var defineCommand5, REPO_SLUG3, ISO_DAY3, asJson, deliveryReport, deliveryCommands;
 var init_delivery2 = __esm({
   "../../src/core/commands/delivery.ts"() {
     "use strict";
@@ -13965,16 +14222,16 @@ var init_delivery2 = __esm({
     init_commandRegistry();
     init_delivery();
     init_runRecord();
-    defineCommand4 = commandDefiner();
+    defineCommand5 = commandDefiner();
     REPO_SLUG3 = /^(?!\.+\/)[\w.-]+\/(?!\.+$)[\w.-]+$/;
     ISO_DAY3 = /^\d{4}-\d{2}-\d{2}$/;
     asJson = (v) => v;
-    deliveryReport = defineCommand4({
+    deliveryReport = defineCommand5({
       id: "delivery.report",
-      options: z7.object({
-        repo: z7.string().regex(REPO_SLUG3).optional().describe("the repository (`owner/name`); default: the first under `delivery.repos`"),
-        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(
+      options: z8.object({
+        repo: z8.string().regex(REPO_SLUG3).optional().describe("the repository (`owner/name`); default: the first under `delivery.repos`"),
+        since: z8.string().regex(ISO_DAY3).optional().describe("the first day of the range (`YYYY-MM-DD`, UTC); the range ends today"),
+        weeks: z8.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")
@@ -14019,7 +14276,7 @@ var init_delivery2 = __esm({
 });
 
 // ../../src/core/commands/deploy.ts
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 function toOptions(o, dryRun, affected) {
   return {
     only: o.only,
@@ -14129,7 +14386,7 @@ async function copyImages(copies, account2, deps) {
 function registerDeployCommands(registry) {
   for (const cmd of deployCommands) registry.register(cmd);
 }
-var defineCommand5, workerList, positiveInt, gitRef, deployOptions, planJson, deployPlan, allOptions, copiedImage, listCopies, deployAll, restartOptions, deployRestart, initOptions, deployInit, configOptions, deployConfig, secretNames, secretsOptions, deploySecrets, imagesOptions, deployImages, deployCommands;
+var defineCommand6, workerList, positiveInt, gitRef, deployOptions, planJson, deployPlan, allOptions, copiedImage, listCopies, deployAll, restartOptions, deployRestart, initOptions, deployInit, configOptions, deployConfig, secretNames, secretsOptions, deploySecrets, imagesOptions, deployImages, deployCommands;
 var init_deploy = __esm({
   "../../src/core/commands/deploy.ts"() {
     "use strict";
@@ -14142,16 +14399,16 @@ var init_deploy = __esm({
     init_wranglerTemplate();
     init_secrets();
     init_commandRegistry();
-    defineCommand5 = commandDefiner();
-    workerList = z8.string().transform(
+    defineCommand6 = commandDefiner();
+    workerList = z9.string().transform(
       (s) => s.split(",").map((x) => x.trim()).filter(Boolean)
     ).refine(
       (names) => names.every((n2) => DEPLOY_ORDER.includes(n2)),
       `expected a comma list of Workers (${DEPLOY_ORDER.join(", ")})`
     ).transform((names) => [...new Set(names)]);
-    positiveInt = z8.coerce.number().int().positive();
-    gitRef = z8.string().regex(/^[A-Za-z0-9_./^~@{}][A-Za-z0-9_./^~@{}-]{0,199}$/, "expected a git revision (a sha, tag, branch, or HEAD^)");
-    deployOptions = z8.object({
+    positiveInt = z9.coerce.number().int().positive();
+    gitRef = z9.string().regex(/^[A-Za-z0-9_./^~@{}][A-Za-z0-9_./^~@{}-]{0,199}$/, "expected a git revision (a sha, tag, branch, or HEAD^)");
+    deployOptions = z9.object({
       only: workerList.optional().describe(
         `deploy only these Workers (comma list of ${DEPLOY_ORDER.join(", ")}); with --affected, only those of them that are affected`
       ),
@@ -14170,7 +14427,7 @@ var init_deploy = __esm({
       poll: positiveInt.optional().describe("seconds between preflight retries (default 60)")
     });
     planJson = (plan3) => plan3;
-    deployPlan = defineCommand5({
+    deployPlan = defineCommand6({
       id: "deploy.plan",
       options: deployOptions,
       action: "deploy:read",
@@ -14186,7 +14443,7 @@ var init_deploy = __esm({
     });
     copiedImage = (c) => ({ kind: c.kind, source: c.source, target: c.target });
     listCopies = (copies) => copies.map((c) => `${c.kind} \u2190 ${c.source}`).join(", ");
-    deployAll = defineCommand5({
+    deployAll = defineCommand6({
       id: "deploy.all",
       options: allOptions,
       action: "deploy:write",
@@ -14237,15 +14494,15 @@ ${formatDeployResults(result.results, result.notAttempted)}`
         return output(result.results, copies, []);
       }
     });
-    restartOptions = z8.object({
-      only: z8.enum(["bot"]).optional().describe("the Worker to restart \u2014 only `bot` has a long-lived container (default bot)"),
+    restartOptions = z9.object({
+      only: z9.enum(["bot"]).optional().describe("the Worker to restart \u2014 only `bot` has a long-lived container (default bot)"),
       force: flag.optional().describe(
         "restart even when the bot cannot be consulted (no JSON on /healthz) \u2014 the fail-closed cases; runs in flight never refuse, they hand off"
       ),
       waitMax: positiveInt.optional().describe("minutes to wait out a refusal (the bot not answering with JSON) before giving up (default 10)"),
       poll: positiveInt.optional().describe("seconds between retries while refused (default 60)")
     });
-    deployRestart = defineCommand5({
+    deployRestart = defineCommand6({
       id: "deploy.restart",
       options: restartOptions,
       action: "deploy:write",
@@ -14286,12 +14543,12 @@ ${formatDeployResults(result.results, result.notAttempted)}`
         };
       }
     });
-    initOptions = z8.object({
+    initOptions = z9.object({
       check: flag.optional().describe(
         "compare only: report each rendered file that differs from the one on disk and fail when any does (the `deploy:check` gate); nothing is written"
       )
     });
-    deployInit = defineCommand5({
+    deployInit = defineCommand6({
       id: "deploy.init",
       options: initOptions,
       action: "deploy:write",
@@ -14338,12 +14595,12 @@ ${formatDeployResults(result.results, result.notAttempted)}`
         return output;
       }
     });
-    configOptions = z8.object({
-      source: z8.string().min(1).optional().describe(
+    configOptions = z9.object({
+      source: z9.string().min(1).optional().describe(
         "read the config from this source instead of the profile's configSource (a path, github://owner/repo/path@ref, or op://Vault/Item/field)"
       )
     });
-    deployConfig = defineCommand5({
+    deployConfig = defineCommand6({
       id: "deploy.config",
       options: configOptions,
       action: "deploy:write",
@@ -14378,21 +14635,21 @@ the bot reads it on its next start: \`deploy restart\``;
         return output;
       }
     });
-    secretNames = z8.string().transform(
+    secretNames = z9.string().transform(
       (s) => s.split(",").map((x) => x.trim()).filter(Boolean)
     ).refine(
       (names) => names.length > 0 && names.every((n2) => /^[A-Z][A-Z0-9_]*$/.test(n2)),
       "expected a comma list of secret names (SCREAMING_SNAKE)"
     ).transform((names) => [...new Set(names)]);
-    secretsOptions = z8.object({
+    secretsOptions = z9.object({
       only: secretNames.optional().describe("put only these secrets (comma list of names from deploy/secrets.manifest.json)")
     });
-    deploySecrets = defineCommand5({
+    deploySecrets = defineCommand6({
       id: "deploy.secrets",
       args: [
         {
           name: "worker",
-          schema: z8.enum(DEPLOY_ORDER),
+          schema: z9.enum(DEPLOY_ORDER),
           describe: `the Worker to provision (${DEPLOY_ORDER.join(", ")})`
         }
       ],
@@ -14454,12 +14711,12 @@ the bot reads it on its next start: \`deploy restart\``;
         return output;
       }
     });
-    imagesOptions = z8.object({
+    imagesOptions = z9.object({
       dryRun: flag.optional().describe(
         "say which images the account registry already holds at the version and which would be copied; nothing is copied"
       )
     });
-    deployImages = defineCommand5({
+    deployImages = defineCommand6({
       id: "deploy.images",
       options: imagesOptions,
       action: "deploy:write",
@@ -14510,25 +14767,25 @@ the bot reads it on its next start: \`deploy restart\``;
 });
 
 // ../../src/core/commands/env.ts
-import { z as z9 } from "zod";
+import { z as z10 } from "zod";
 function registerEnvCommands(registry) {
   for (const cmd of envCommands) registry.register(cmd);
 }
-var defineCommand6, envBootstrap, envCommands;
+var defineCommand7, envBootstrap, envCommands;
 var init_env = __esm({
   "../../src/core/commands/env.ts"() {
     "use strict";
     init_bootstrap();
     init_commandRegistry();
-    defineCommand6 = commandDefiner();
-    envBootstrap = defineCommand6({
+    defineCommand7 = commandDefiner();
+    envBootstrap = defineCommand7({
       id: "env.bootstrap",
-      options: z9.object({
-        env: z9.string().min(1).describe("environment to materialize (UAT only; anything else is refused)"),
-        service: z9.string().min(1).describe("which downstream service's toolchain env to fill"),
+      options: z10.object({
+        env: z10.string().min(1).describe("environment to materialize (UAT only; anything else is refused)"),
+        service: z10.string().min(1).describe("which downstream service's toolchain env to fill"),
         apply: flag.optional().describe("resolve the refs and WRITE the chmod-600 env file (default: dry-run)"),
-        out: z9.string().min(1).optional().describe("env-file path (default .agent-env/<service>.<env>.env)"),
-        manifest: z9.string().min(1).optional().describe(`manifest path (default ${DEFAULT_MANIFEST_PATH})`)
+        out: z10.string().min(1).optional().describe("env-file path (default .agent-env/<service>.<env>.env)"),
+        manifest: z10.string().min(1).optional().describe(`manifest path (default ${DEFAULT_MANIFEST_PATH})`)
       }),
       action: "env:write",
       effect: "write",
@@ -15262,7 +15519,7 @@ var init_selfImprovement = __esm({
 });
 
 // ../../src/core/commands/friction.ts
-import { z as z10 } from "zod";
+import { z as z11 } from "zod";
 async function ledgerOf(deps) {
   let ledger;
   try {
@@ -15290,7 +15547,7 @@ function inProgressHint(diagnosis, finished) {
 function registerFrictionCommands(registry) {
   for (const cmd of frictionCommands) registry.register(cmd);
 }
-var defineCommand7, positiveInt2, repoSlug, NO_LEDGER_MESSAGE, NO_REPO_MESSAGE, asJson2, render, visibleRuns, frictionReport, frictionPropose, frictionAnalyze, frictionCommands;
+var defineCommand8, positiveInt2, repoSlug, NO_LEDGER_MESSAGE, NO_REPO_MESSAGE, asJson2, render, visibleRuns, frictionReport, frictionPropose, frictionAnalyze, frictionCommands;
 var init_friction = __esm({
   "../../src/core/commands/friction.ts"() {
     "use strict";
@@ -15301,19 +15558,19 @@ var init_friction = __esm({
     init_runEventLines();
     init_runFriction();
     init_selfImprovement();
-    defineCommand7 = commandDefiner();
-    positiveInt2 = z10.coerce.number().int().positive();
-    repoSlug = z10.string().refine((s) => /^[\w.-]+\/[\w.-]+$/.test(s), "expected an owner/name slug");
+    defineCommand8 = commandDefiner();
+    positiveInt2 = z11.coerce.number().int().positive();
+    repoSlug = z11.string().refine((s) => /^[\w.-]+\/[\w.-]+$/.test(s), "expected an owner/name slug");
     NO_LEDGER_MESSAGE = "Run history is not configured in this deployment (`runHistory`), so there are no recent runs to analyze.";
     NO_REPO_MESSAGE = "Set `selfImprovement.repo` (an `owner/name`) in config.yaml to tell `friction propose` where to file issues.";
     asJson2 = (r) => r;
     render = (output) => formatSelfImprovementReport(output);
     visibleRuns = (caller) => predicateFor(caller.actor, "runs:read", "run");
-    frictionReport = defineCommand7({
+    frictionReport = defineCommand8({
       id: "friction.report",
       enabledWhen: (caps) => caps.runHistory,
-      options: z10.object({
-        sinceMs: z10.coerce.number().int().nonnegative().optional().describe("only runs finished at or after this epoch ms"),
+      options: z11.object({
+        sinceMs: z11.coerce.number().int().nonnegative().optional().describe("only runs finished at or after this epoch ms"),
         limit: positiveInt2.optional().describe("newest n runs (default: the ledger's retained window)"),
         minRuns: positiveInt2.optional().describe("distinct runs a pattern must recur in (default selfImprovement.minRuns, else 2)")
       }),
@@ -15339,10 +15596,10 @@ var init_friction = __esm({
         });
       }
     });
-    frictionPropose = defineCommand7({
+    frictionPropose = defineCommand8({
       id: "friction.propose",
       enabledWhen: (caps) => caps.runHistory,
-      options: z10.object({
+      options: z11.object({
         dryRun: flag.optional().describe("compute and report everything, file nothing"),
         top: positiveInt2.optional().describe("proposals filed per pass (default selfImprovement.top, else 3)"),
         minRuns: positiveInt2.optional().describe("distinct runs a pattern must recur in (default selfImprovement.minRuns, else 2)"),
@@ -15374,17 +15631,17 @@ var init_friction = __esm({
         }
       }
     });
-    frictionAnalyze = defineCommand7({
+    frictionAnalyze = defineCommand8({
       id: "friction.analyze",
       args: [
         {
           name: "source",
-          schema: z10.string().optional(),
+          schema: z11.string().optional(),
           describe: "a saved run stream: JSON lines of run events or a curl'ed /runs/:id/events SSE capture (default: stdin)"
         }
       ],
-      options: z10.object({
-        slowMs: z10.coerce.number().nonnegative().optional().describe("a tool call slower than this many ms is a slow-tool finding"),
+      options: z11.object({
+        slowMs: z11.coerce.number().nonnegative().optional().describe("a tool call slower than this many ms is a slow-tool finding"),
         inProgress: flag.optional().describe("the capture was taken mid-run: a trailing call without a result is still executing, not a dead run")
       }),
       action: "friction:read",
@@ -15437,7 +15694,7 @@ var init_friction = __esm({
 });
 
 // ../../src/core/commandSurface.ts
-import { z as z11 } from "zod";
+import { z as z12 } from "zod";
 function camelToKebab(s) {
   return s.replace(/[A-Z]/g, (c) => `-${c.toLowerCase()}`);
 }
@@ -15509,7 +15766,7 @@ function isBooleanSchema(schema) {
   return false;
 }
 function jsonSchemaOf(schema) {
-  const out = z11.toJSONSchema(unwrap(schema), { io: "input" });
+  const out = z12.toJSONSchema(unwrap(schema), { io: "input" });
   delete out.$schema;
   return out;
 }
@@ -15521,7 +15778,7 @@ function jsonSchemaFor(cmd) {
     if (!acceptsUndefined(arg.schema)) required.push(arg.name);
   }
   if (cmd.options) {
-    const opts = z11.toJSONSchema(cmd.options, { io: "input" });
+    const opts = z12.toJSONSchema(cmd.options, { io: "input" });
     Object.assign(properties, opts.properties ?? {});
     required.push(...opts.required ?? []);
   }
@@ -15761,17 +16018,17 @@ function chatCommandList(commands) {
 function registerHelpCommands(registry) {
   for (const cmd of helpCommands) registry.register(cmd);
 }
-var defineCommand8, COMMANDS_REFERENCE_URL, DIRECTIVES_HELP, helpShow, helpCommandsList, helpCommands;
+var defineCommand9, COMMANDS_REFERENCE_URL, DIRECTIVES_HELP, helpShow, helpCommandsList, helpCommands;
 var init_help = __esm({
   "../../src/core/commands/help.ts"() {
     "use strict";
     init_commandRegistry();
     init_commandSurface();
     init_docsLink();
-    defineCommand8 = commandDefiner();
+    defineCommand9 = commandDefiner();
     COMMANDS_REFERENCE_URL = `${PROJECT_DOCS_URL}/reference/slack-commands`;
     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({
+    helpShow = defineCommand9({
       id: "help.show",
       action: "help:read",
       effect: "read",
@@ -15782,7 +16039,7 @@ var init_help = __esm({
         commandsReference: COMMANDS_REFERENCE_URL
       })
     });
-    helpCommandsList = defineCommand8({
+    helpCommandsList = defineCommand9({
       id: "help.commands",
       action: "help:read",
       effect: "read",
@@ -17519,7 +17776,7 @@ var init_service = __esm({
 });
 
 // ../../src/core/commands/mcp.ts
-import { z as z12 } from "zod";
+import { z as z13 } from "zod";
 async function serviceOf(deps) {
   const svc = await deps.mcp.service();
   if ("unavailable" in svc) throw new CommandError("unavailable", svc.unavailable);
@@ -17613,7 +17870,7 @@ function renderShow(output) {
 function registerMcpCommands(registry) {
   for (const cmd of MCP_COMMANDS) registry.register(cmd);
 }
-var defineCommand9, serverName, serverUrl, scopeOption, channelOption2, nameArg, mcpList, mcpAdd, mcpConnect, mcpShow, mcpRemove, MCP_COMMANDS;
+var defineCommand10, serverName, serverUrl, scopeOption, channelOption2, nameArg, mcpList, mcpAdd, mcpConnect, mcpShow, mcpRemove, MCP_COMMANDS;
 var init_mcp = __esm({
   "../../src/core/commands/mcp.ts"() {
     "use strict";
@@ -17621,18 +17878,18 @@ var init_mcp = __esm({
     init_service();
     init_authorize();
     init_commandRegistry();
-    defineCommand9 = commandDefiner();
-    serverName = z12.string().refine((s) => MCP_SERVER_NAME_PATTERN.test(s), "expected a slug: lowercase letters, digits, dashes (\u2264 32 chars)");
-    serverUrl = z12.string().refine((s) => /^https?:\/\/\S+$/.test(s), "expected an http(s) URL");
-    scopeOption = z12.enum(["me", "channel", "org"]).optional().describe(
+    defineCommand10 = commandDefiner();
+    serverName = z13.string().refine((s) => MCP_SERVER_NAME_PATTERN.test(s), "expected a slug: lowercase letters, digits, dashes (\u2264 32 chars)");
+    serverUrl = z13.string().refine((s) => /^https?:\/\/\S+$/.test(s), "expected an http(s) URL");
+    scopeOption = z13.enum(["me", "channel", "org"]).optional().describe(
       "whose server: yours (`me`, default), this channel's (`channel`, channel-config rights), or org-wide (`org`, admins)"
     );
-    channelOption2 = z12.string().optional().describe("target channel for `--scope channel` and for `list` (default: the channel you are speaking in)");
+    channelOption2 = z13.string().optional().describe("target channel for `--scope channel` and for `list` (default: the channel you are speaking in)");
     nameArg = { name: "name", schema: serverName, describe: "the server's name (see `mcp list`)" };
-    mcpList = defineCommand9({
+    mcpList = defineCommand10({
       id: "mcp.list",
       enabledWhen: (caps) => caps.mcp,
-      options: z12.object({ channel: channelOption2 }),
+      options: z13.object({ channel: channelOption2 }),
       action: "mcp:read",
       effect: "read",
       describe: "External MCP servers your runs in this channel can use \u2014 org-wide, this channel's, and your own \u2014 with state and agents; never a credential.",
@@ -17644,7 +17901,7 @@ var init_mcp = __esm({
         return { servers };
       }
     });
-    mcpAdd = defineCommand9({
+    mcpAdd = defineCommand10({
       id: "mcp.add",
       enabledWhen: (caps) => caps.mcp,
       args: [
@@ -17654,15 +17911,15 @@ var init_mcp = __esm({
           describe: "a short slug for the server (becomes the tool prefix mcp__<name>__)"
         }
       ],
-      options: z12.object({
+      options: z13.object({
         url: serverUrl.describe("the server's Streamable-HTTP endpoint (https://\u2026/mcp)"),
         scope: scopeOption,
-        agents: z12.string().transform(
+        agents: z13.string().transform(
           (s) => s.split(",").map((a) => a.trim()).filter(Boolean)
         ).optional().describe(
           "comma-separated agents that may use it (default general,research; only org servers may name coding/review/ship)"
         ),
-        auth: z12.enum(["oauth", "bearer", "none"]).optional().describe(
+        auth: z13.enum(["oauth", "bearer", "none"]).optional().describe(
           "how the server authenticates: `oauth` (you sign in on a one-time link), `bearer` (you paste a token on a one-time link), or `none`; omit to detect it from the server"
         ),
         channel: channelOption2
@@ -17687,11 +17944,11 @@ var init_mcp = __esm({
         );
       }
     });
-    mcpConnect = defineCommand9({
+    mcpConnect = defineCommand10({
       id: "mcp.connect",
       enabledWhen: (caps) => caps.mcp,
       args: [nameArg],
-      options: z12.object({ scope: scopeOption, channel: channelOption2 }),
+      options: z13.object({ scope: scopeOption, channel: channelOption2 }),
       action: "mcp:write",
       effect: "write",
       describe: "A fresh one-time link to sign in to an OAuth server or enter (or replace) a bearer server's token \u2014 only you can complete it; it expires in 10 minutes.",
@@ -17705,11 +17962,11 @@ var init_mcp = __esm({
         return await via(() => svc.connect(actor, target, args.name));
       }
     });
-    mcpShow = defineCommand9({
+    mcpShow = defineCommand10({
       id: "mcp.show",
       enabledWhen: (caps) => caps.mcp,
       args: [nameArg],
-      options: z12.object({ scope: scopeOption, channel: channelOption2 }),
+      options: z13.object({ scope: scopeOption, channel: channelOption2 }),
       action: "mcp:read",
       effect: "read",
       describe: "One MCP server's entry plus a live probe of the tools it offers (names, read-only flags); never a credential.",
@@ -17725,11 +17982,11 @@ var init_mcp = __esm({
         return await via(() => svc.show(actor, target, args.name));
       }
     });
-    mcpRemove = defineCommand9({
+    mcpRemove = defineCommand10({
       id: "mcp.remove",
       enabledWhen: (caps) => caps.mcp,
       args: [nameArg],
-      options: z12.object({ scope: scopeOption, channel: channelOption2 }),
+      options: z13.object({ scope: scopeOption, channel: channelOption2 }),
       action: "mcp:write",
       effect: "write",
       describe: "Remove an MCP server you added and its stored credential (yours freely; channel ones need channel-config rights, org-wide ones admin rights).",
@@ -18167,7 +18424,7 @@ var init_llmOutput = __esm({
 });
 
 // ../../src/core/memory/reflection.ts
-import { z as z13 } from "zod";
+import { z as z14 } from "zod";
 function shouldReflect(input) {
   if (input.agentName !== void 0 && NO_REFLECT_AGENTS.has(input.agentName)) return false;
   return input.toolCalls > 0 || input.historyTurns >= REFLECT_MIN_TURNS;
@@ -18386,7 +18643,7 @@ var init_reflection = __esm({
       "Output raw JSON with no code fence and no prose."
     ].join("\n");
     SUMMARY_INHERITANCE = ["user", "repo", "channel"];
-    REFLECTION_ENVELOPE = jsonOutput(z13.object({ facts: z13.array(z13.unknown()), summary: z13.unknown().optional() }), {
+    REFLECTION_ENVELOPE = jsonOutput(z14.object({ facts: z14.array(z14.unknown()), summary: z14.unknown().optional() }), {
       name: "reflection-envelope"
     });
     SCOPE_KINDS = ["org", "user", "repo", "channel"];
@@ -18506,11 +18763,11 @@ var init_workerStore = __esm({
 });
 
 // ../../src/core/memory/buildStore.ts
-function resolveScopeCap(configured2, warn) {
-  if (configured2 === void 0) return DEFAULT_SCOPE_CAP;
-  if (Number.isInteger(configured2) && configured2 >= 1 && configured2 <= MAX_SCOPE_CAP) return configured2;
+function resolveScopeCap(configured3, warn) {
+  if (configured3 === void 0) return DEFAULT_SCOPE_CAP;
+  if (Number.isInteger(configured3) && configured3 >= 1 && configured3 <= MAX_SCOPE_CAP) return configured3;
   warn(
-    `memory.maxRecordsPerScope must be an integer between 1 and ${MAX_SCOPE_CAP} (got ${String(configured2)}) \u2014 using the default ${DEFAULT_SCOPE_CAP}.`
+    `memory.maxRecordsPerScope must be an integer between 1 and ${MAX_SCOPE_CAP} (got ${String(configured3)}) \u2014 using the default ${DEFAULT_SCOPE_CAP}.`
   );
   return DEFAULT_SCOPE_CAP;
 }
@@ -18618,7 +18875,7 @@ var init_memory = __esm({
 });
 
 // ../../src/core/commands/memory.ts
-import { z as z14 } from "zod";
+import { z as z15 } from "zod";
 function scopeKeyOfMemoryId(id) {
   const m = /^mem:(.+):\d+$/.exec(id);
   return m ? m[1] : void 0;
@@ -18672,18 +18929,18 @@ _(limit ${limit} reached \u2014 there may be more; narrow with words or raise \`
 function registerMemoryCommands(registry) {
   for (const cmd of memoryCommands) registry.register(cmd);
 }
-var defineCommand10, MEMORY_LIST_LIMIT, MEMORY_LIST_MAX_LIMIT, MEMORY_OFF_MESSAGE, memoryId, repoScopeKey, channelScopeKey, isSharedScope, LIST_SCOPES, memoryList, memoryForget, memoryCommands;
+var defineCommand11, MEMORY_LIST_LIMIT, MEMORY_LIST_MAX_LIMIT, MEMORY_OFF_MESSAGE, memoryId, repoScopeKey, channelScopeKey, isSharedScope, LIST_SCOPES, memoryList, memoryForget, memoryCommands;
 var init_memory2 = __esm({
   "../../src/core/commands/memory.ts"() {
     "use strict";
     init_authorize();
     init_commandRegistry();
     init_memory();
-    defineCommand10 = commandDefiner();
+    defineCommand11 = commandDefiner();
     MEMORY_LIST_LIMIT = 20;
     MEMORY_LIST_MAX_LIMIT = 50;
     MEMORY_OFF_MESSAGE = "Memory is off in this deployment (`memory.enabled` is not set), so there is nothing to list or forget.";
-    memoryId = z14.string().refine(
+    memoryId = z15.string().refine(
       (id) => scopeKeyOfMemoryId(id) !== void 0,
       "expected a memory id like mem:<scope>:<n> (see `memory list`)"
     );
@@ -18691,21 +18948,21 @@ var init_memory2 = __esm({
     channelScopeKey = (channelId) => deriveScopeKey("channel", { channelId });
     isSharedScope = (key, keys) => key === keys.org || key.startsWith("repo:") || key.startsWith("channel:");
     LIST_SCOPES = ["me", "org", "repo", "channel", "all"];
-    memoryList = defineCommand10({
+    memoryList = defineCommand11({
       id: "memory.list",
       enabledWhen: (caps) => caps.memory,
       args: [
         {
           name: "query",
-          schema: z14.string().optional(),
+          schema: z15.string().optional(),
           describe: "words a record must mention (whole-token match)",
           rest: true
         }
       ],
-      options: z14.object({
-        scope: z14.enum(LIST_SCOPES).optional().describe("which scopes to list (default all: yours, this repo's, this channel's, and the shared org scope)"),
-        limit: z14.coerce.number().int().min(1).max(MEMORY_LIST_MAX_LIMIT).optional().describe(`records per scope (default ${MEMORY_LIST_LIMIT}, max ${MEMORY_LIST_MAX_LIMIT})`),
-        repo: z14.string().refine((s) => /^[\w.-]+\/[\w.-]+$/.test(s), "expected an owner/name slug").optional().describe("the repo whose scope to list (default: the repo this thread is bound to)")
+      options: z15.object({
+        scope: z15.enum(LIST_SCOPES).optional().describe("which scopes to list (default all: yours, this repo's, this channel's, and the shared org scope)"),
+        limit: z15.coerce.number().int().min(1).max(MEMORY_LIST_MAX_LIMIT).optional().describe(`records per scope (default ${MEMORY_LIST_LIMIT}, max ${MEMORY_LIST_MAX_LIMIT})`),
+        repo: z15.string().refine((s) => /^[\w.-]+\/[\w.-]+$/.test(s), "expected an owner/name slug").optional().describe("the repo whose scope to list (default: the repo this thread is bound to)")
       }),
       action: "memory:read",
       effect: "read",
@@ -18759,7 +19016,7 @@ var init_memory2 = __esm({
         };
       }
     });
-    memoryForget = defineCommand10({
+    memoryForget = defineCommand11({
       id: "memory.forget",
       enabledWhen: (caps) => caps.memory,
       args: [{ name: "id", schema: memoryId, describe: "the record id (`mem:<scope>:<n>`, from `memory list`)" }],
@@ -18894,7 +19151,7 @@ var init_residentDiskBudget = __esm({
 });
 
 // ../../src/core/commands/repo.ts
-import { z as z15 } from "zod";
+import { z as z16 } from "zod";
 async function adminOf(deps, span) {
   const api = await deps.repo.admin();
   if ("unavailable" in api) throw new CommandError("unavailable", api.unavailable);
@@ -19002,7 +19259,7 @@ ${clipOpOutput(text)}
 \`\`\`` : `${icon} ${str4(o.summary)}`;
 }
 function defineOp(op) {
-  return defineCommand11({
+  return defineCommand12({
     id: `repo.${op}`,
     // The op needs a backend: the resident service, or the local workspace (`defaultOperations`).
     enabledWhen: (caps) => caps.residents || caps.execution === "local",
@@ -19060,7 +19317,7 @@ function defineOp(op) {
 function registerRepoCommands(registry) {
   for (const cmd of repoCommands) registry.register(cmd);
 }
-var defineCommand11, DEFAULT_COMMANDS, DEFAULT_REF, SETTLE_POLL_MS, SETTLE_MAX_MS, repoSlug2, gitRef2, command, slugArg, n, obj, str4, repoList, repoOnboard, COMMAND_KEYS, dryRunOptions, repoOffboard, repoRebuild, repoReconfigure, NO_OPS_BACKEND_MESSAGE, repoTest, repoBuild, repoCommands;
+var defineCommand12, DEFAULT_COMMANDS, DEFAULT_REF, SETTLE_POLL_MS, SETTLE_MAX_MS, repoSlug2, gitRef2, command, slugArg, n, obj, str4, repoList, repoOnboard, COMMAND_KEYS, dryRunOptions, repoOffboard, repoRebuild, repoReconfigure, NO_OPS_BACKEND_MESSAGE, repoTest, repoBuild, repoCommands;
 var init_repo = __esm({
   "../../src/core/commands/repo.ts"() {
     "use strict";
@@ -19068,19 +19325,19 @@ var init_repo = __esm({
     init_residentAdmin();
     init_repoToolchain();
     init_residentDiskBudget();
-    defineCommand11 = commandDefiner();
+    defineCommand12 = commandDefiner();
     DEFAULT_COMMANDS = NPM_FALLBACK_COMMANDS;
     DEFAULT_REF = "main";
     SETTLE_POLL_MS = 1e4;
     SETTLE_MAX_MS = 12 * 6e4;
-    repoSlug2 = z15.string().refine((s) => parseSlug(s) !== void 0, "expected a GitHub owner/name slug").transform((s) => parseSlug(s));
-    gitRef2 = z15.string().refine((s) => validRef(s) !== void 0, "expected a plausible git branch ref (e.g. main)");
-    command = z15.string().min(1);
+    repoSlug2 = z16.string().refine((s) => parseSlug(s) !== void 0, "expected a GitHub owner/name slug").transform((s) => parseSlug(s));
+    gitRef2 = z16.string().refine((s) => validRef(s) !== void 0, "expected a plausible git branch ref (e.g. main)");
+    command = z16.string().min(1);
     slugArg = { name: "slug", schema: repoSlug2, describe: "GitHub owner/name of the repo" };
     n = (v) => String(typeof v === "number" ? v : v ?? "?");
     obj = (v) => typeof v === "object" && v !== null && !Array.isArray(v) ? v : {};
     str4 = (v) => typeof v === "string" ? v : String(v ?? "?");
-    repoList = defineCommand11({
+    repoList = defineCommand12({
       id: "repo.list",
       enabledWhen: (caps) => caps.residents,
       action: "repo:read",
@@ -19097,11 +19354,11 @@ var init_repo = __esm({
         return res.data;
       }
     });
-    repoOnboard = defineCommand11({
+    repoOnboard = defineCommand12({
       id: "repo.onboard",
       enabledWhen: (caps) => caps.residents,
       args: [slugArg],
-      options: z15.object({
+      options: z16.object({
         ref: gitRef2.optional().describe(`default branch to keep warm (default ${DEFAULT_REF})`),
         test: command.optional().describe(
           "the repo's test command (default: detected from the repo root \u2014 `<pm> test`, or a no-op without a test script)"
@@ -19188,10 +19445,10 @@ var init_repo = __esm({
       settle: (output, { deps }) => settleProvisioning(deps, str4(output.slug))
     });
     COMMAND_KEYS = ["install", "build", "test"];
-    dryRunOptions = z15.object({
+    dryRunOptions = z16.object({
       dryRun: flag.optional().describe("compute and return the itemized plan without executing")
     });
-    repoOffboard = defineCommand11({
+    repoOffboard = defineCommand12({
       id: "repo.offboard",
       enabledWhen: (caps) => caps.residents,
       args: [slugArg],
@@ -19225,7 +19482,7 @@ var init_repo = __esm({
         return { ...r.data, slug: args.slug, dryRun };
       }
     });
-    repoRebuild = defineCommand11({
+    repoRebuild = defineCommand12({
       id: "repo.rebuild",
       enabledWhen: (caps) => caps.residents,
       args: [slugArg],
@@ -19264,11 +19521,11 @@ var init_repo = __esm({
         return { ...r.data, slug: args.slug, dryRun };
       }
     });
-    repoReconfigure = defineCommand11({
+    repoReconfigure = defineCommand12({
       id: "repo.reconfigure",
       enabledWhen: (caps) => caps.residents,
       args: [slugArg],
-      options: z15.object({
+      options: z16.object({
         ref: gitRef2.optional().describe("new default branch"),
         test: command.optional().describe("new test command"),
         build: command.optional().describe("new build command"),
@@ -20238,7 +20495,7 @@ var init_runsService = __esm({
 });
 
 // ../../src/core/commands/review.ts
-import { z as z16 } from "zod";
+import { z as z17 } from "zod";
 function artifactJson(a) {
   return {
     ...a.model !== void 0 ? { model: a.model } : {},
@@ -20307,7 +20564,7 @@ function refused2(err2) {
 function registerReviewCommands(registry) {
   for (const cmd of reviewCommands) registry.register(cmd);
 }
-var defineCommand12, runId, ABRIDGE_OFF_MESSAGE, reviewAbridge, reviewCommands;
+var defineCommand13, runId, ABRIDGE_OFF_MESSAGE, reviewAbridge, reviewCommands;
 var init_review = __esm({
   "../../src/core/commands/review.ts"() {
     "use strict";
@@ -20316,17 +20573,17 @@ var init_review = __esm({
     init_reviewAbridge();
     init_runRecord();
     init_runsService();
-    defineCommand12 = commandDefiner();
-    runId = z16.string().regex(RUN_ID_PATTERN);
+    defineCommand13 = commandDefiner();
+    runId = z17.string().regex(RUN_ID_PATTERN);
     ABRIDGE_OFF_MESSAGE = "The abridged reading diff is off in this deployment: it needs the `meat` binary on the bot host, the Anthropic provider's credential, `review.readingDiff.provider` not `off`, and run history to store it.";
-    reviewAbridge = defineCommand12({
+    reviewAbridge = defineCommand13({
       id: "review.abridge",
       // Hidden unless the abridging can happen here (the binary, the credential,
       // the switch) AND there is a record to append to.
       enabledWhen: (caps) => caps.runHistory && caps.readingDiffAbridge,
       args: [{ name: "id", schema: runId, describe: "run id of a finished PR review" }],
-      options: z16.object({
-        model: z16.string().min(1).optional().describe("meat's model (default review.readingDiff.meatModel, else claude-opus-5)"),
+      options: z17.object({
+        model: z17.string().min(1).optional().describe("meat's model (default review.readingDiff.meatModel, else claude-opus-5)"),
         force: flag.optional().describe("recompute even when an abridged diff is already stored, or retry a failed one"),
         wait: flag.optional().describe("block until the abridging finishes and answer the outcome instead of `running`")
       }),
@@ -20358,7 +20615,7 @@ var init_review = __esm({
 });
 
 // ../../src/core/commands/runs.ts
-import { z as z17 } from "zod";
+import { z as z18 } from "zod";
 function unwrap2(res) {
   if (res.ok) return res.value;
   throw new CommandError(res.error, res.error === "not_found" ? "run not found" : "run already finished");
@@ -20399,7 +20656,7 @@ function wrapEvent(e) {
 function registerRunsCommands(registry) {
   for (const cmd of runsCommands) registry.register(cmd);
 }
-var defineCommand13, runId2, positiveInt3, idArg, logDenied, asJson3, runsList, runsGet, runsEvents, runsFriction, runsStop, runsCommands;
+var defineCommand14, runId2, positiveInt3, idArg, logDenied, asJson3, runsList, runsGet, runsEvents, runsFriction, runsStop, runsCommands;
 var init_runs = __esm({
   "../../src/core/commands/runs.ts"() {
     "use strict";
@@ -20408,21 +20665,24 @@ var init_runs = __esm({
     init_commandRegistry();
     init_runRecord();
     init_runsService();
-    defineCommand13 = commandDefiner();
-    runId2 = z17.string().regex(RUN_ID_PATTERN);
-    positiveInt3 = z17.coerce.number().int().positive();
+    defineCommand14 = commandDefiner();
+    runId2 = z18.string().regex(RUN_ID_PATTERN);
+    positiveInt3 = z18.coerce.number().int().positive();
     idArg = { name: "id", schema: runId2, describe: "run id" };
     logDenied = (entry) => console.log(JSON.stringify({ audit: "authz", ...entry }));
     asJson3 = (v) => v;
-    runsList = defineCommand13({
+    runsList = defineCommand14({
       id: "runs.list",
-      options: z17.object({
-        status: z17.enum(["active", "finished", "all"]).default("active").describe("which runs: live (default), persisted, or both"),
-        agent: z17.string().min(1).optional().describe("only runs of this agent"),
-        channel: z17.string().min(1).optional().describe("only runs in this platform-namespaced channel (`slack:C0123`, `http:ops`)"),
-        sinceMs: z17.coerce.number().int().nonnegative().optional().describe("only runs started at or after this epoch ms"),
+      options: z18.object({
+        status: z18.enum(["active", "finished", "all"]).default("active").describe("which runs: live (default), persisted, or both"),
+        agent: z18.string().min(1).optional().describe("only runs of this agent"),
+        channel: z18.string().min(1).optional().describe("only runs in this platform-namespaced channel (`slack:C0123`, `http:ops`)"),
+        thread: z18.string().min(1).optional().describe(
+          "only runs in this thread, newest first (`slack:C0123:1712.34` \u2014 a thread's story, its sessions' runs)"
+        ),
+        sinceMs: z18.coerce.number().int().nonnegative().optional().describe("only runs started at or after this epoch ms"),
         limit: positiveInt3.max(RUN_LIST_MAX_LIMIT).optional().describe(`page size (max ${RUN_LIST_MAX_LIMIT})`),
-        before: z17.coerce.number().int().nonnegative().optional().describe("page cursor: runs finished before this epoch ms"),
+        before: z18.coerce.number().int().nonnegative().optional().describe("page cursor: runs finished before this epoch ms"),
         beforeId: runId2.optional().describe("page cursor tie-breaker: the last id of the previous page")
       }),
       action: "runs:read",
@@ -20430,14 +20690,17 @@ var init_runs = __esm({
       describe: "List runs (live and persisted, newest first) \u2014 metadata only, never message text.",
       handler: async ({ options, caller, deps }) => {
         const visibleTo = predicateFor(caller.actor, "runs:read", "run");
-        return asJson3(await (await deps.runs()).listRuns({ ...options, visibleTo }));
+        const { thread, ...rest } = options;
+        return asJson3(
+          await (await deps.runs()).listRuns({ ...rest, ...thread !== void 0 ? { threadKey: thread } : {}, visibleTo })
+        );
       }
     });
-    runsGet = defineCommand13({
+    runsGet = defineCommand14({
       id: "runs.get",
       args: [idArg],
-      options: z17.object({
-        include: z17.enum(["messages"]).optional().describe("add the run's events, free text wrapped as untrusted content")
+      options: z18.object({
+        include: z18.enum(["messages"]).optional().describe("add the run's events, free text wrapped as untrusted content")
       }),
       action: "runs:read",
       effect: "read",
@@ -20457,11 +20720,11 @@ var init_runs = __esm({
         return asJson3(view);
       }
     });
-    runsEvents = defineCommand13({
+    runsEvents = defineCommand14({
       id: "runs.events",
       args: [idArg],
-      options: z17.object({
-        afterSeq: z17.coerce.number().int().nonnegative().optional().describe("events with seq greater than this"),
+      options: z18.object({
+        afterSeq: z18.coerce.number().int().nonnegative().optional().describe("events with seq greater than this"),
         limit: positiveInt3.max(MAX_EVENTS_PAGE).optional().describe(`page size (max ${MAX_EVENTS_PAGE})`)
       }),
       action: "runs:read",
@@ -20475,7 +20738,7 @@ var init_runs = __esm({
         return asJson3({ ...page2, events: page2.events.map(wrapEvent) });
       }
     });
-    runsFriction = defineCommand13({
+    runsFriction = defineCommand14({
       id: "runs.friction",
       args: [idArg],
       action: "runs:read",
@@ -20488,10 +20751,10 @@ var init_runs = __esm({
         return asJson3(unwrap2(await runs.getRunFriction(args.id)));
       }
     });
-    runsStop = defineCommand13({
+    runsStop = defineCommand14({
       id: "runs.stop",
       args: [idArg],
-      options: z17.object({ mode: z17.enum(["soft", "hard"]).describe("soft = finish the current step; hard = abort now") }),
+      options: z18.object({ mode: z18.enum(["soft", "hard"]).describe("soft = finish the current step; hard = abort now") }),
       action: "runs:write",
       effect: "write",
       describe: "Request a live run to stop (`--mode soft` = finish the current step; `hard` = abort now). Records the caller as the actor.",
@@ -20515,16 +20778,16 @@ var init_runs = __esm({
 function registerScheduleCommands(registry) {
   for (const cmd of scheduleCommands) registry.register(cmd);
 }
-var defineCommand14, ACTION_LABEL, utc, scheduleList, scheduleCommands;
+var defineCommand15, ACTION_LABEL, utc, scheduleList, scheduleCommands;
 var init_schedule = __esm({
   "../../src/core/commands/schedule.ts"() {
     "use strict";
     init_commandRegistry();
     init_schedules();
-    defineCommand14 = commandDefiner();
+    defineCommand15 = commandDefiner();
     ACTION_LABEL = { healthz: "keep-alive", watchdog: "resident watchdog" };
     utc = (ms) => `${new Date(ms).toISOString().slice(0, 16).replace("T", " ")} UTC`;
-    scheduleList = defineCommand14({
+    scheduleList = defineCommand15({
       id: "schedule.list",
       enabledWhen: (caps) => caps.schedules,
       action: "schedule:read",
@@ -20788,7 +21051,7 @@ var init_plan2 = __esm({
 });
 
 // ../../src/core/commands/setup.ts
-import { z as z18 } from "zod";
+import { z as z19 } from "zod";
 async function gatherAnswers(o, setup) {
   const ask = setup.prompt;
   const given = (v) => v !== void 0;
@@ -20858,33 +21121,33 @@ function capabilityLine(c) {
 function registerSetupCommands(registry) {
   for (const cmd of setupCommands) registry.register(cmd);
 }
-var defineCommand15, secret, digits, workerName, hostname2, httpUrl, account, initOptions2, DEFAULT_NAME, setupInit, ASK, setupCommands;
+var defineCommand16, secret, digits, workerName, hostname2, httpUrl, account, initOptions2, DEFAULT_NAME, setupInit, ASK, setupCommands;
 var init_setup = __esm({
   "../../src/core/commands/setup.ts"() {
     "use strict";
     init_plan2();
     init_commandRegistry();
     init_deploy();
-    defineCommand15 = commandDefiner();
-    secret = z18.string().min(1);
-    digits = z18.string().regex(/^\d+$/, "expected a number");
-    workerName = z18.string().regex(/^[a-z0-9]([a-z0-9-]*[a-z0-9])?$/, "expected a Worker name: lowercase letters, digits, hyphens");
-    hostname2 = z18.string().regex(/^[a-z0-9]([a-z0-9-]*[a-z0-9])?(\.[a-z0-9]([a-z0-9-]*[a-z0-9])?)+$/, "expected a bare DNS name (example.com)");
-    httpUrl = z18.string().regex(/^https?:\/\/\S+$/, "expected an http(s) URL");
-    account = z18.string().regex(/^[0-9a-f]{32}$/, "expected a Cloudflare account id: 32 hex characters");
-    initOptions2 = z18.object({
-      organization: z18.string().min(1).optional().describe("the GitHub organization (or user) this installation serves \u2014 config.yaml's `organization`"),
+    defineCommand16 = commandDefiner();
+    secret = z19.string().min(1);
+    digits = z19.string().regex(/^\d+$/, "expected a number");
+    workerName = z19.string().regex(/^[a-z0-9]([a-z0-9-]*[a-z0-9])?$/, "expected a Worker name: lowercase letters, digits, hyphens");
+    hostname2 = z19.string().regex(/^[a-z0-9]([a-z0-9-]*[a-z0-9])?(\.[a-z0-9]([a-z0-9-]*[a-z0-9])?)+$/, "expected a bare DNS name (example.com)");
+    httpUrl = z19.string().regex(/^https?:\/\/\S+$/, "expected an http(s) URL");
+    account = z19.string().regex(/^[0-9a-f]{32}$/, "expected a Cloudflare account id: 32 hex characters");
+    initOptions2 = z19.object({
+      organization: z19.string().min(1).optional().describe("the GitHub organization (or user) this installation serves \u2014 config.yaml's `organization`"),
       anthropicKey: secret.optional().describe("an Anthropic API key \u2192 ANTHROPIC_API_KEY and the `anthropic` provider"),
       openaiCompatible: httpUrl.optional().describe(
         "an OpenAI-compatible endpoint's base URL (https://api.openai.com/v1, http://localhost:11434/v1) \u2192 the `openai` provider"
       ),
-      model: z18.string().min(1).optional().describe("with --openai-compatible: the model every agent runs on at that endpoint (openai/<model>)"),
+      model: z19.string().min(1).optional().describe("with --openai-compatible: the model every agent runs on at that endpoint (openai/<model>)"),
       modelKey: secret.optional().describe("with --openai-compatible: the endpoint's key \u2192 OPENAI_API_KEY (a local endpoint needs none)"),
       slackAppToken: secret.optional().describe("the Slack app-level token (xapp-\u2026) \u2192 SLACK_APP_TOKEN"),
       slackBotToken: secret.optional().describe("the Slack bot token (xoxb-\u2026) \u2192 SLACK_BOT_TOKEN"),
       githubAppId: digits.optional().describe("the GitHub App's id \u2192 GITHUB_APP_ID"),
       githubInstallationId: digits.optional().describe("the GitHub App's installation id \u2192 GITHUB_APP_INSTALLATION_ID"),
-      githubPrivateKeyFile: z18.string().min(1).optional().describe("path to the GitHub App's private key (PEM) \u2192 GITHUB_APP_PRIVATE_KEY, one quoted line"),
+      githubPrivateKeyFile: z19.string().min(1).optional().describe("path to the GitHub App's private key (PEM) \u2192 GITHUB_APP_PRIVATE_KEY, one quoted line"),
       cloudflare: account.optional().describe(
         "a Cloudflare account id: also write deploy/profile.json and render the Worker configs (needs --zone; from a checkout's root, or anywhere when this CLI is the published package)"
       ),
@@ -20894,7 +21157,7 @@ var init_setup = __esm({
       dryRun: flag.optional().describe("write nothing; print each file as it would be written, secrets masked")
     });
     DEFAULT_NAME = "switchboard";
-    setupInit = defineCommand15({
+    setupInit = defineCommand16({
       id: "setup.init",
       options: initOptions2,
       action: "setup:write",
@@ -20994,13 +21257,13 @@ function renderStatus(output) {
 function registerStatusCommands(registry) {
   for (const cmd of statusCommands) registry.register(cmd);
 }
-var defineCommand16, statusShow, statusCommands;
+var defineCommand17, statusShow, statusCommands;
 var init_status = __esm({
   "../../src/core/commands/status.ts"() {
     "use strict";
     init_commandRegistry();
-    defineCommand16 = commandDefiner();
-    statusShow = defineCommand16({
+    defineCommand17 = commandDefiner();
+    statusShow = defineCommand17({
       id: "status.show",
       action: "status:read",
       effect: "read",
@@ -21039,6 +21302,7 @@ function registerCoreCommands(registry) {
   registerSetupCommands(registry);
   registerContractCommands(registry);
   registerDeliveryCommands(registry);
+  registerArtifactsCommands(registry);
 }
 function coreCommandGroups() {
   const registry = new CommandRegistry({ audit: () => {
@@ -21050,6 +21314,7 @@ var init_all = __esm({
   "../../src/core/commands/all.ts"() {
     "use strict";
     init_commandRegistry();
+    init_artifacts();
     init_config4();
     init_contract2();
     init_delivery2();
@@ -21333,6 +21598,11 @@ function buildCoreCommands(config, store, wiring) {
       images: imagesHostIO({ log: (l) => console.log(l), now: wiring.now ?? systemClock }),
       cliVersion: cliVersionOnHost
     },
+    // `artifacts lifecycle` / `artifacts check`: the config's section and the operator's Cloudflare calls.
+    artifacts: {
+      config: async () => (await cfg()).config.artifacts,
+      bucket: artifactsBucketHost()
+    },
     env: { bootstrap: bootstrapOnHost },
     status: { snapshot: () => (wiring.status ?? unstampedStatus)() },
     // `setup init` writes the operator's working directory — the one the CLI runs in.
@@ -21366,6 +21636,7 @@ var init_commandCatalogue = __esm({
     init_clock();
     init_run();
     init_imagesHost();
+    init_artifactsBucket();
     init_secretsHost();
     init_host3();
     init_executor();
@@ -21584,6 +21855,12 @@ function runPageLink(id) {
   if (!base) return void 0;
   return `${base.replace(/\/+$/, "")}/runs/${encodeURIComponent(id)}`;
 }
+function artifactLink(id, key, token2) {
+  const page2 = runPageLink(id);
+  if (!page2) return void 0;
+  const path = key.split("/").map(encodeURIComponent).join("/");
+  return `${page2}/artifacts/${path}${token2 ? `?t=${encodeURIComponent(token2)}` : ""}`;
+}
 function stripPlatformPrefix(id) {
   const i = id.indexOf(":");
   return i === -1 ? id : id.slice(i + 1);
@@ -24256,7 +24533,8 @@ async function readRequest(ctx) {
 }
 function resolveRun(deps, ctx) {
   const { msg, directives, history } = ctx;
-  const sticky = lastThreadDirectives(history);
+  const fromTurns = lastThreadDirectives(history);
+  const sticky = ctx.stickyAgent !== void 0 ? { ...fromTurns, agent: ctx.stickyAgent } : fromTurns;
   const resolved = deps.config.resolve({
     channelId: msg.channelId,
     userId: msg.userId,
@@ -24916,9 +25194,24 @@ function providerRouteModel(provider, model, opts = {}) {
     return result.content.filter((p) => p.type === "text").map((p) => p.text).join("");
   };
 }
+function resolveRouted(deps, msg, directives, sticky, preset) {
+  return deps.config.resolve({
+    channelId: msg.channelId,
+    userId: msg.userId,
+    request: {
+      agent: preset,
+      model: directives.model ?? sticky.model,
+      effort: directives.effort ?? sticky.effort
+    }
+  });
+}
 async function routeRequest(deps, ctx) {
-  const { msg, directives, sticky, agentSource, threadLive, root } = ctx;
+  const { msg, directives, sticky, agentSource, threadLive, root, carried } = ctx;
   const cfg = deps.config.config;
+  if (carried) {
+    console.log(`[route] ${msg.threadKey} routed to ${carried.preset} as before the restart: ${carried.reason}`);
+    return { kind: "routed", resolved: resolveRouted(deps, msg, directives, sticky, carried.preset), route: carried };
+  }
   if (!routingOn(cfg) || agentSource !== "default" || threadLive) return { kind: "unrouted" };
   const modelRef2 = cfg.routing?.model ?? cfg.defaults.models["general"];
   if (!modelRef2) {
@@ -24959,15 +25252,7 @@ async function routeRequest(deps, ctx) {
     console.log(`[route] ${msg.threadKey} not routed (${decision.reason}) \u2014 running ${cfg.defaults.agent}`);
     return decision.compoundRejected ? { kind: "unrouted", rejected: { preset: cfg.defaults.agent, reason: decision.reason, model: modelRef2 } } : { kind: "unrouted" };
   }
-  const resolved = deps.config.resolve({
-    channelId: msg.channelId,
-    userId: msg.userId,
-    request: {
-      agent: decision.preset,
-      model: directives.model ?? sticky.model,
-      effort: directives.effort ?? sticky.effort
-    }
-  });
+  const resolved = resolveRouted(deps, msg, directives, sticky, decision.preset);
   const { parts, collapsed } = decision;
   console.log(
     `[route] ${msg.threadKey} routed to ${decision.preset} on ${modelRef2}${parts ? ` (${parts.length} parts)` : ""}${collapsed ? ` (compound collapsed: ${collapsed.presets.join("+")})` : ""}: ${decision.reason}`
@@ -25074,7 +25359,7 @@ var init_tracingExecutor = __esm({
 });
 
 // ../../src/core/prDescription.ts
-import { z as z19 } from "zod";
+import { z as z20 } from "zod";
 function parsePrDescription(input) {
   return PrDescriptionSchema.parse(input);
 }
@@ -25362,34 +25647,34 @@ var init_prDescription = __esm({
   "../../src/core/prDescription.ts"() {
     "use strict";
     init_redact();
-    line2 = z19.string().trim().min(1).refine((s) => !/[\r\n]/.test(s), "must be a single line (no embedded newlines)");
-    prose = z19.string().trim().min(1);
-    TourAnchorSchema = z19.object({
+    line2 = z20.string().trim().min(1).refine((s) => !/[\r\n]/.test(s), "must be a single line (no embedded newlines)");
+    prose = z20.string().trim().min(1);
+    TourAnchorSchema = z20.object({
       // Repo-relative: no leading `/`, no `..` SEGMENT (a filename like `a..b.ts` is fine).
-      path: z19.string().trim().min(1).refine((p) => !p.startsWith("/") && !p.split("/").includes(".."), "path must be repo-relative"),
-      from: z19.number().int().positive(),
-      to: z19.number().int().positive()
+      path: z20.string().trim().min(1).refine((p) => !p.startsWith("/") && !p.split("/").includes(".."), "path must be repo-relative"),
+      from: z20.number().int().positive(),
+      to: z20.number().int().positive()
     }).refine((a) => a.to >= a.from, "to must be >= from");
-    TourStepSchema = z19.object({
+    TourStepSchema = z20.object({
       title: line2,
       description: prose,
       lookFor: prose.optional(),
       anchor: TourAnchorSchema
     });
-    PrDescriptionSchema = z19.object({
+    PrDescriptionSchema = z20.object({
       /** The PR title's single source. Metadata for the PR's own title field —
        *  never rendered into the body (GitHub shows the title itself). */
       title: line2,
       tldr: prose,
       whatWhy: prose,
-      tour: z19.array(TourStepSchema).min(1),
+      tour: z20.array(TourStepSchema).min(1),
       /** Every touched file the Tour steps did not cover, one line each. */
-      remaining: z19.array(z19.object({ path: line2, note: prose })),
-      decisions: z19.array(z19.object({ title: line2, rationale: prose })).min(1),
+      remaining: z20.array(z20.object({ path: line2, note: prose })),
+      decisions: z20.array(z20.object({ title: line2, rationale: prose })).min(1),
       risks: prose,
-      validation: z19.object({
+      validation: z20.object({
         summary: prose.optional(),
-        criteria: z19.array(z19.object({ criterion: prose, proof: prose })).min(1)
+        criteria: z20.array(z20.object({ criterion: prose, proof: prose })).min(1)
       })
     });
     REPO_RE = /^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/;
@@ -26161,10 +26446,11 @@ async function attachThroughStore(path, name, lead, artifacts, ctx) {
   }
   ctx.publish?.({ type: "artifact", direction: "out", key, name, size, contentType });
   if (!ctx.uploadTicket) {
-    const where = artifacts.runUrl ? ` \u2014 ${artifacts.runUrl}` : "";
+    const link = artifacts.artifactUrl?.(key);
+    const where = link ? ` \u2014 ${link}` : ` is on the run page as ${key}`;
     await artifacts.reply(`${lead}
-\u{1F4CE} ${name} (${size} bytes) is on the run page${where}`);
-    return `attached ${name} (${size} bytes) to the run page; this conversation's channel takes no file uploads, so the lead and the page's link were posted instead`;
+\u{1F4CE} ${name} (${size} bytes)${where}`);
+    return `attached ${name} (${size} bytes) to the run page as ${key}; this conversation's channel takes no file uploads, so the lead and the file's link were posted instead`;
   }
   const kept = "the file is kept on the run page";
   let ticket;
@@ -26631,7 +26917,7 @@ var init_runs2 = __esm({
 });
 
 // ../../src/tools/workspace.ts
-import { z as z20 } from "zod";
+import { z as z21 } from "zod";
 var bashTool, readFileTool, writeFileTool, NAME_STATUS_MARK, NAME_STATUS_MARK_LINE, OUTPUT_CUT_RE, diffDigestTool, submitVerdictTool, submitDispositionsTool, submitPrDescriptionTool, handoffEntry, submitHandoffTool, updateStatusTool, TOOLSETS;
 var init_workspace = __esm({
   "../../src/tools/workspace.ts"() {
@@ -26930,7 +27216,7 @@ ${raw.trim()}`;
         try {
           desc = parsePrDescription(input);
         } catch (err2) {
-          const detail = err2 instanceof z20.ZodError ? err2.issues.map((i) => `${i.path.join(".") || "(root)"}: ${i.message}`).join("; ") : String(err2);
+          const detail = err2 instanceof z21.ZodError ? err2.issues.map((i) => `${i.path.join(".") || "(root)"}: ${i.message}`).join("; ") : String(err2);
           return `error: invalid PR description \u2014 ${detail}`;
         }
         ctx.onPrDescription?.(desc);
@@ -29213,7 +29499,8 @@ async function reserveRun(deps, ctx) {
     root,
     parentRunId,
     coordinator,
-    seed
+    seed,
+    route: route3
   } = ctx;
   if (!resume && !restart) {
     const requestRow = durableInboxMessage(msg, msg.text, receivedAt);
@@ -29242,6 +29529,7 @@ async function reserveRun(deps, ctx) {
           ...parentRunId !== void 0 ? { parentRunId } : {},
           ...coordinatorFields(coordinator),
           ...seed !== void 0 ? { seed } : {},
+          ...route3 !== void 0 ? { route: route3 } : {},
           request: requestRow
         },
         card: card.handle ?? null,
@@ -29472,7 +29760,9 @@ async function claimRun(deps, ctx) {
     root,
     parentRunId,
     coordinator,
-    seed
+    seed,
+    route: route3,
+    seedLog
   } = ctx;
   const { resident, binding } = selection;
   let ledgerRun = ctx.ledgerRun;
@@ -29503,6 +29793,7 @@ async function claimRun(deps, ctx) {
           ...parentRunId !== void 0 ? { parentRunId } : {},
           ...coordinatorFields(coordinator),
           ...seed !== void 0 ? { seed } : {},
+          ...route3 !== void 0 ? { route: route3 } : {},
           selection: resident === true ? "resident" : "sandbox",
           ...binding?.workspace !== void 0 ? { workspace: binding.workspace } : {},
           ...requestRow !== void 0 ? { request: requestRow } : {}
@@ -29516,8 +29807,9 @@ async function claimRun(deps, ctx) {
           ({ name, description, inputSchema }) => ({ name, description, inputSchema })
         ),
         // 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 },
+        // this run was admitted with, not on the preset's own number — and,
+        // for a seed read from the log, the rows it reuses (session-log item 9).
+        seed: { messages, budgetMs: profile.minutes * 6e4, ...seedLog ? { log: seedLog } : {} },
         // 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
@@ -29587,7 +29879,7 @@ function writeFileScripts(path, content) {
     chunks.push(content.slice(i, i + WRITE_CHUNK_CHARS));
   const dir = path.slice(0, path.lastIndexOf("/")) || ".";
   return chunks.map(
-    (chunk, i) => i === 0 ? `mkdir -p ${shellQuote(dir)} && umask 077 && printf '%s' ${shellQuote(chunk)} > ${shellQuote(path)}` : `printf '%s' ${shellQuote(chunk)} >> ${shellQuote(path)}`
+    (chunk, i) => i === 0 ? `umask 077 && mkdir -p ${shellQuote(dir)} && printf '%s' ${shellQuote(chunk)} > ${shellQuote(path)}` : `printf '%s' ${shellQuote(chunk)} >> ${shellQuote(path)}`
   );
 }
 function startScript(start3) {
@@ -29598,7 +29890,7 @@ function startScript(start3) {
     `pi ${args.map(shellQuote).join(" ")} <&3 2>>${shellQuote(paths.errLog)} | ${LOG_FILTER} >> ${shellQuote(paths.log)}`
   ].join("; ");
   return [
-    `mkdir -p ${shellQuote(paths.dir)} ${shellQuote(paths.sessionDir)} ${shellQuote(paths.commandDir)}`,
+    `(umask 077 && mkdir -p ${shellQuote(paths.dir)} ${shellQuote(paths.sessionDir)} ${shellQuote(paths.commandDir)})`,
     `rm -f ${shellQuote(paths.fifo)}`,
     `mkfifo -m 600 ${shellQuote(paths.fifo)}`,
     `: > ${shellQuote(paths.log)}`,
@@ -29626,6 +29918,9 @@ function killScript(pid) {
 function tailScript(path, bytes) {
   return `tail -c ${bytes} ${shellQuote(path)} 2>/dev/null || true`;
 }
+function removeScript(dir) {
+  return `rm -rf ${shellQuote(dir)}`;
+}
 function stdoutOf(operation, out) {
   const exit = parseExitPrefix(out);
   if (exit.failed) throw new PiContainerError(operation, out);
@@ -29694,6 +29989,9 @@ var init_container = __esm({
           return "";
         }
       }
+      async remove(paths) {
+        stdoutOf("remove", await this.exec(removeScript(paths.dir)));
+      }
       exec(script, env) {
         return this.executor.exec(script, { timeoutMs: OP_TIMEOUT_MS, ...env ? { env } : {} });
       }
@@ -30370,8 +30668,8 @@ function piBuiltinToolsFor(identity2) {
 function piThinkingLevel(effort2) {
   return effort2;
 }
-function piRunPaths(runId3, root = "/tmp/switchboard-pi") {
-  const dir = `${root}/${runId3}`;
+function piRunPaths(runId3) {
+  const dir = `/tmp/switchboard-pi-${runId3}`;
   return {
     dir,
     agentDir: `${dir}/agent`,
@@ -30618,7 +30916,7 @@ async function runPiHarness(deps, run2) {
     emit({ type: "run_note", kind, summary, ...mode ? { mode } : {} });
   };
   const bridge = new PiBridge({ emit, onProgress: run2.onProgress, agentSpan, clock: clock3 });
-  const paths = piRunPaths(run2.runId, deps.root);
+  const paths = piRunPaths(run2.runId);
   const remainingMs = run2.resume?.remainingMs ?? run2.agent.maxMinutes * 6e4;
   const deadline = now() + remainingMs;
   const warnAt = deadline - Math.min(3 * 6e4, run2.agent.maxMinutes * 15e3);
@@ -30890,6 +31188,8 @@ async function runPiHarness(deps, run2) {
     forget();
     if (pid !== void 0) await container.kill(pid).catch(() => {
     });
+    await container.remove(paths).catch(() => {
+    });
     agentSpan?.end(hardStopped || bypass ? "error" : "ok");
   }
 }
@@ -31564,12 +31864,11 @@ async function runLoop2(deps, ctx) {
   const uploadTicket = io.uploadTicket?.bind(io);
   const nextStagedIndex = ctx.stagingIndex ?? stagingIndex();
   let artifactSeq = 0;
-  const runUrl = runPageLink(run2.id);
   const artifacts = deps.artifacts ? {
     store: deps.artifacts,
     runId: run2.id,
     nextSeq: () => ++artifactSeq,
-    ...runUrl ? { runUrl } : {},
+    artifactUrl: (key) => artifactLink(run2.id, key, run2.token),
     reply: (text) => io.reply(text)
   } : void 0;
   const toolContext = {
@@ -33309,15 +33608,7 @@ var init_settle = __esm({
 });
 
 // ../../src/core/dispatch/lineage.ts
-async function threadLineage(service, threadKey) {
-  let newest;
-  try {
-    const page2 = await service.listRuns({ status: "all", visibleTo: { kind: "all" }, threadKey, limit: 1 });
-    newest = page2.runs[0];
-  } catch (err2) {
-    console.warn(`[lineage] ${threadKey}: thread read failed \u2014 ${err2 instanceof Error ? err2.message : String(err2)}`);
-    return void 0;
-  }
+function lineageOf(newest) {
   if (newest === void 0 || newest.parentRunId === void 0) return void 0;
   return {
     parentRunId: newest.parentRunId,
@@ -33374,6 +33665,161 @@ var init_lineage = __esm({
   }
 });
 
+// ../../src/core/runLedger/sessionLog.ts
+function sessionKey(threadKey, agent) {
+  return `${threadKey}:${agent ?? "-"}`;
+}
+function requestIndex(seed) {
+  for (let i = seed.length - 1; i >= 0; i--) if (seed[i].role === "user") return i;
+  return 0;
+}
+var DEFAULT_SESSION_LOG_MAX_BYTES;
+var init_sessionLog = __esm({
+  "../../src/core/runLedger/sessionLog.ts"() {
+    "use strict";
+    init_runRecord();
+    init_runRecord();
+    DEFAULT_SESSION_LOG_MAX_BYTES = DEFAULT_RETENTION_POLICY.sessionLogMaxBytes;
+  }
+});
+
+// ../../src/core/dispatch/thread.ts
+async function readThread(service, threadKey) {
+  try {
+    const page2 = await service.listRuns({
+      status: "all",
+      visibleTo: { kind: "all" },
+      threadKey,
+      limit: THREAD_READ_LIMIT
+    });
+    return page2.runs;
+  } catch (err2) {
+    console.warn(`[thread] ${threadKey}: thread read failed \u2014 ${err2 instanceof Error ? err2.message : String(err2)}`);
+    return void 0;
+  }
+}
+function continuable(run2) {
+  return run2.finished && run2.session !== void 0 && run2.agent !== void 0;
+}
+function stickyAgentOf(runs, onPi) {
+  const newest = runs[0];
+  if (newest === void 0 || !continuable(newest) || !onPi(newest.agent)) return void 0;
+  return newest.agent;
+}
+function previousRunOf(runs, agent) {
+  const run2 = runs.find((r) => r.agent === agent && continuable(r));
+  if (run2 === void 0) return void 0;
+  return {
+    ...run2.finishedAt !== void 0 ? { finishedAt: run2.finishedAt } : {},
+    broken: run2.session.range === "broken"
+  };
+}
+var THREAD_READ_LIMIT;
+var init_thread = __esm({
+  "../../src/core/dispatch/thread.ts"() {
+    "use strict";
+    THREAD_READ_LIMIT = 8;
+  }
+});
+
+// ../../src/core/dispatch/seed.ts
+function sessionSeed(input) {
+  const { tail, previous, history, request } = input;
+  const { from, transcript } = tail;
+  if (from === 0 && transcript.turns === 0) return void 0;
+  const notes = [];
+  const messages = [];
+  const compactions = transcript.compactions;
+  const afterCompaction = compactions.reduce((n2, c) => Math.max(n2, c.before), 0);
+  let start3 = -1;
+  for (let i = afterCompaction; i < transcript.messages.length; i++) {
+    const m = transcript.messages[i];
+    if (m.role === "user" && m.content.some((p) => p.type === "text")) {
+      start3 = i;
+      break;
+    }
+  }
+  const summary = compactions.length ? compactions[compactions.length - 1].entry.summary : void 0;
+  const logFrom = start3 < 0 ? from + transcript.turns : from + start3 + compactions.length;
+  const kept = start3 < 0 ? [] : transcript.messages.slice(start3).map(withoutThinking);
+  if (kept.length === 0) {
+    notes.push(
+      transcript.turns === 0 ? "session seed: the log's newest turn alone is over the seed budget \u2014 the run starts from the request" : "session seed: no user text turn in the tail within the seed budget \u2014 the run starts from the request"
+    );
+  }
+  messages.push(...kept);
+  const last = kept[kept.length - 1];
+  if (last?.role === "assistant") {
+    const calls = last.content.filter((p) => p.type === "tool_use");
+    if (calls.length > 0) {
+      messages.push({
+        role: "user",
+        content: calls.map((c) => ({
+          type: "tool_result",
+          toolUseId: c.id,
+          content: settledResult(c.name),
+          isError: true
+        }))
+      });
+    }
+  }
+  if (previous?.broken) messages.push({ role: "user", content: [{ type: "text", text: GAP_MARKER }] });
+  if (previous?.finishedAt === void 0) {
+    notes.push(
+      "session seed: the previous run's end is unknown, so the lines written since could not be told apart \u2014 only the request follows the tail"
+    );
+  } else {
+    const end = previous.finishedAt;
+    for (const h of history) {
+      if (h.role !== "user" || h.at === void 0 || h.at <= end) continue;
+      messages.push({ role: "user", content: turnContent(h.text, h.images, h.documents) });
+    }
+  }
+  messages.push({ role: "user", content: turnContent(request.text, request.images, request.documents) });
+  return {
+    messages,
+    log: { from: logFrom, turns: kept.length },
+    ...summary !== void 0 ? { summary } : {},
+    notes
+  };
+}
+async function sessionSeedFor(input) {
+  const key = sessionKey(input.threadKey, input.agent);
+  let tail;
+  try {
+    tail = await input.ledger.readSessionTail(key, SEED_BUDGET_BYTES);
+  } catch (err2) {
+    const why = err2 instanceof Error ? err2.message : String(err2);
+    return { notes: [`session seed: the log ${key} could not be read (${why}) \u2014 the run seeds from the channel`] };
+  }
+  const seed = sessionSeed({
+    tail,
+    previous: previousRunOf(input.thread, input.agent),
+    history: input.history,
+    request: input.request
+  });
+  return seed ? { seed, notes: seed.notes } : { notes: [] };
+}
+function withoutThinking(message2) {
+  if (message2.role !== "assistant") return message2;
+  const content = message2.content.filter((p) => p.type !== "thinking" && p.type !== "redacted_thinking");
+  if (content.length === message2.content.length) return message2;
+  return { ...message2, content: content.length ? content : [{ type: "text", text: "(reasoning omitted)" }] };
+}
+var SEED_BUDGET_TOKENS, SEED_BUDGET_BYTES, GAP_MARKER, settledResult;
+var init_seed = __esm({
+  "../../src/core/dispatch/seed.ts"() {
+    "use strict";
+    init_sessionLog();
+    init_messages();
+    init_thread();
+    SEED_BUDGET_TOKENS = 6e4;
+    SEED_BUDGET_BYTES = SEED_BUDGET_TOKENS * 4;
+    GAP_MARKER = "[The log of this conversation ends short of what the previous run saw: its connection to the ledger broke, so its later turns and its final reply are not here.]";
+    settledResult = (toolName) => `The run that made this call ended before this ${toolName} call's result was recorded; its effects are unknown \u2014 re-check them before repeating it.`;
+  }
+});
+
 // ../../src/core/runEnding.ts
 function createRunEnding(deps) {
   const log = deps.log ?? console.error;
@@ -33511,7 +33957,8 @@ async function dispatch(deps, msg, io, opts = {}) {
     const { directives, history } = await readRequest({ msg, io, root });
     if (await answerOperation(deps, { msg, io, ending, trace, directives, history })) return ended;
     const runsService = deps.runs ?? createRunsService({ registry, store: deps.runStore });
-    const lineage = opts.parent || opts.coordinator || resume || restart ? void 0 : await threadLineage(runsService, msg.threadKey);
+    const thread = opts.parent || opts.coordinator || resume || restart || history.length === 0 ? void 0 : await readThread(runsService, msg.threadKey);
+    const lineage = lineageOf(thread?.[0]);
     const parent = opts.parent ?? (lineage ? lineageParent(lineage) : void 0);
     const tellLineage = async (heard) => {
       if (!lineage) return;
@@ -33522,18 +33969,40 @@ async function dispatch(deps, msg, io, opts = {}) {
         heard
       );
     };
-    const settled = resolveRun(deps, { msg, directives, history });
+    const harnessBlock = deps.config.config.harness;
+    const onPi = (name) => {
+      const def = AGENTS[name];
+      return def !== void 0 && effectiveHarness(def, harnessBlock) === "pi";
+    };
+    const stickyAgent = thread ? stickyAgentOf(thread, onPi) : void 0;
+    const settled = resolveRun(deps, {
+      msg,
+      directives,
+      history,
+      ...stickyAgent !== void 0 ? { stickyAgent } : {}
+    });
     const { sticky } = settled;
     let { resolved, agentSource } = settled;
     let route3;
     const threadLive = admission.get(msg.threadKey) !== void 0 || !resume && !restart && deps.threadsElsewhere.get(msg.threadKey) !== void 0;
-    const routing = await routeRequest(deps, { msg, directives, sticky, agentSource, threadLive, root });
+    const routing = await routeRequest(deps, {
+      msg,
+      directives,
+      sticky,
+      agentSource,
+      threadLive,
+      root,
+      // A restart is the same run under the same card: the row's decision
+      // (run-history item 35) is the route, re-resolved, never re-asked.
+      ...restart?.row.meta.route ? { carried: restart.row.meta.route } : {}
+    });
     if (routing.kind === "routed") {
       resolved = routing.resolved;
       route3 = routing.route;
       agentSource = "route";
     }
     const routeEvent = routing.kind === "routed" ? routing.route : routing.rejected;
+    if (resume?.row.meta.route) route3 = resume.row.meta.route;
     if ((await authorizeAgent(deps, { msg, io, refuse: refuse3, agentName: resolved.agentName })).kind === "refused")
       return ended;
     const agent = resolved.agentName === "ship" ? shipPresetFor(deps.config.config.ship) : getAgent(resolved.agentName);
@@ -33649,8 +34118,23 @@ async function dispatch(deps, msg, io, opts = {}) {
     }
     const contractBlock = opts.contract ? renderContract(opts.contract, { maxChars: DEFAULT_CONTRACT_MAX_CHARS }).text : void 0;
     const requestText = route3?.parts ? compoundBrief(directives.text, route3.parts) : directives.text;
-    const seed = opts.seed ? "parent" : "channel";
-    const built = buildMessages(opts.seed ?? history, requestText, msg.images, msg.documents);
+    const fromSession = !resume && !opts.seed && thread && effectiveHarness(agent, harnessBlock) === "pi" ? await sessionSeedFor({
+      ledger: deps.runLedger,
+      threadKey: msg.threadKey,
+      agent: agent.name,
+      thread,
+      history,
+      request: {
+        text: requestText,
+        ...msg.images ? { images: msg.images } : {},
+        ...msg.documents ? { documents: msg.documents } : {}
+      }
+    }) : void 0;
+    const session = fromSession?.seed;
+    const seedNotes = fromSession?.notes ?? [];
+    const seed = opts.seed ? "parent" : session ? "session" : "channel";
+    const seedTurns = opts.seed ?? (session ? textTurnsOf(session.messages.slice(0, -1)) : void 0);
+    const built = session ? session.messages : buildMessages(opts.seed ?? history, requestText, msg.images, msg.documents);
     const messages = resume ? resume.plan.messages : contractBlock !== void 0 && agent.name !== "review" ? withContractInFirstUserTurn(built, contractBlock) : built;
     const headPreflight = await authorizePrHead({
       msg,
@@ -33688,12 +34172,14 @@ async function dispatch(deps, msg, io, opts = {}) {
       parentRunId,
       coordinator,
       seed,
-      ...opts.seed ? { seedTurns: opts.seed } : {},
+      ...seedTurns ? { seedTurns } : {},
       agentSource,
       ...routeEvent ? { route: routeEvent } : {}
     });
     const { run: run2, runId: runId3, channelVisibility, liveUrl, publishText, publishMeta } = registration;
     registered = run2;
+    for (const summary of seedNotes)
+      registry.publish(run2.id, { type: "run_note", kind: "seed", summary: oneLine(summary), at: clock3() });
     await tellLineage({ kind: "started", runId: runId3 });
     const staged = !resume && deps.artifacts && msg.staged && msg.staged.length > 0 ? msg.staged : [];
     const nextStagedIndex = stagingIndex();
@@ -33717,6 +34203,7 @@ async function dispatch(deps, msg, io, opts = {}) {
       restart,
       card,
       hooks: reservationHooks,
+      route: route3,
       admitted,
       root,
       parentRunId,
@@ -33852,11 +34339,13 @@ async function dispatch(deps, msg, io, opts = {}) {
       resume,
       ledgerRun,
       card,
+      route: route3,
       clock: clock3,
       root,
       parentRunId,
       coordinator,
-      seed
+      seed,
+      ...session ? { seedLog: session.log } : {}
     });
     const { spawn: spawn7, runs, steer, wait } = runToolCapabilities(
       { core: deps, dispatch, registry, clock: clock3 },
@@ -34037,6 +34526,9 @@ var init_dispatcher = __esm({
     init_codingChild();
     init_settle();
     init_lineage();
+    init_seed();
+    init_thread();
+    init_select();
     init_spawn();
     init_runsService();
     init_runRegistry();
@@ -34438,24 +34930,6 @@ var init_flusher = __esm({
   }
 });
 
-// ../../src/core/runLedger/sessionLog.ts
-function sessionKey(threadKey, agent) {
-  return `${threadKey}:${agent ?? "-"}`;
-}
-function requestIndex(seed) {
-  for (let i = seed.length - 1; i >= 0; i--) if (seed[i].role === "user") return i;
-  return 0;
-}
-var DEFAULT_SESSION_LOG_MAX_BYTES;
-var init_sessionLog = __esm({
-  "../../src/core/runLedger/sessionLog.ts"() {
-    "use strict";
-    init_runRecord();
-    init_runRecord();
-    DEFAULT_SESSION_LOG_MAX_BYTES = DEFAULT_RETENTION_POLICY.sessionLogMaxBytes;
-  }
-});
-
 // ../../src/core/runLedger/types.ts
 var LEASE_MS, HEARTBEAT_MS, APPEND_FLUSH_MS, APPEND_FLUSH_EVENTS, TRANSCRIPT_REQUEST_BYTES, TRANSCRIPT_PART_BYTES, ATTACHMENT_REF_BYTES, GEN_PATTERN;
 var init_types5 = __esm({
@@ -34508,7 +34982,15 @@ function createLedgerWriteThrough(opts) {
         if (opts2.seed) {
           const key = sessionKey(req.threadKey, req.meta.agent);
           const next = await ledger.sessionTail(key);
-          session = { key, seedFrom: next, request: next + requestIndex(opts2.seed), range: { from: next } };
+          let seedFrom = next;
+          if (opts2.log) {
+            if (opts2.log.from + opts2.log.turns === next) seedFrom = opts2.log.from;
+            else
+              warn(
+                `[ledger] ${req.threadKey} run ${req.runId}: the seed names log rows ${opts2.log.from}..${opts2.log.from + opts2.log.turns - 1} but the log's tail is ${next} \u2014 the whole seed is written as new rows`
+              );
+          }
+          session = { key, seedFrom, request: seedFrom + requestIndex(opts2.seed), range: { from: next } };
         }
         const result = await ledger.claim({
           runId: req.runId,
@@ -34669,7 +35151,8 @@ function createLedgerWriteThrough(opts) {
      *  closes `interrupted`. */
     async seed(messages, budgetMs) {
       const base = this.session?.seedFrom ?? 0;
-      const turns = messages.map((message2, i) => ({ idx: base + i, message: message2 }));
+      const reused = this.session && this.session.range !== "broken" ? this.session.range.from - this.session.seedFrom : 0;
+      const turns = messages.slice(reused).map((message2, i) => ({ idx: base + reused + i, message: message2 }));
       try {
         const seeded = await ledger.seed(this.runId, gen, turns, this.session?.key);
         if (!seeded.ok) {
@@ -34839,7 +35322,7 @@ function createLedgerWriteThrough(opts) {
       const seed = req.seed?.messages;
       if (reserved instanceof TrackedRun) {
         if (!reserved.tracked()) return void 0;
-        const claimed3 = await claim(req, seed ? { seed } : {});
+        const claimed3 = await claim(req, seed ? { seed, ...req.seed?.log ? { log: req.seed.log } : {} } : {});
         if (claimed3.outcome === "fenced") {
           reserved.detach("promotion refused (fenced)");
           return void 0;
@@ -34853,7 +35336,7 @@ function createLedgerWriteThrough(opts) {
         if (req.seed) await reserved.seed(req.seed.messages, req.seed.budgetMs);
         return reserved;
       }
-      const claimed2 = await claim(req, seed ? { seed } : {});
+      const claimed2 = await claim(req, seed ? { seed, ...req.seed?.log ? { log: req.seed.log } : {} } : {});
       if (claimed2.outcome === "fenced") {
         warn(`[ledger] ${req.threadKey} not tracked: run ${req.runId} is live under another generation`);
         return void 0;
@@ -34902,6 +35385,7 @@ function createLedgerWriteThrough(opts) {
         return [];
       }
     },
+    readSessionTail: (key, maxBytes) => ledger.readSessionTail(key, maxBytes),
     async handoff() {
       const candidates = [...live].filter((r) => r.resumable && r.tracked() && !r.handedOff);
       if (candidates.length === 0) return { marked: [] };
@@ -34952,6 +35436,9 @@ var init_writeThrough = __esm({
       async readInbox(_runId, _afterSeq) {
         return [];
       }
+      async readSessionTail(_key, _maxBytes) {
+        return { from: 0, transcript: { complete: true, turns: 0, messages: [], compactions: [] } };
+      }
       async handoff() {
         return { marked: [] };
       }
@@ -36865,7 +37352,8 @@ ${file.text}`));
             if (STATUS_PREFIXES.some((p) => text.startsWith(p))) continue;
             const files = mm.bot_id ? void 0 : mm.files;
             if (!text && !files?.length) continue;
-            kept.push({ role: mm.bot_id ? "assistant" : "user", text, files });
+            const at = mm.ts !== void 0 && Number.isFinite(Number(mm.ts)) ? Math.round(Number(mm.ts) * 1e3) : void 0;
+            kept.push({ role: mm.bot_id ? "assistant" : "user", text, ...at !== void 0 ? { at } : {}, files });
           }
           const imagesByIndex = [];
           const documentsByIndex = [];
@@ -36892,11 +37380,11 @@ ${file.text}`));
             }
           }
           for (let i = 0; i < kept.length; i++) {
-            const { role, text } = kept[i];
+            const { role, text, at } = kept[i];
             const images = imagesByIndex[i];
             const documents = documentsByIndex[i];
             if (!text && !images && !documents) continue;
-            items.push({ role, text, images, documents });
+            items.push({ role, text, ...at !== void 0 ? { at } : {}, images, documents });
           }
         } catch {
         }
@@ -39724,8 +40212,8 @@ function prUrlOf(events) {
   for (const e of events) if (e.type === "pr_opened" && typeof e.url === "string") url = e.url;
   return url;
 }
-function routedOf(events) {
-  return events.some((e) => e.type === "run_meta" && e.agentSource === "route");
+function routedOf(meta, events) {
+  return meta.route !== void 0 || events.some((e) => e.type === "run_meta" && e.agentSource === "route");
 }
 async function reclaimRuns(opts) {
   const { ledger, gen } = opts;
@@ -39801,7 +40289,7 @@ async function reclaimRuns(opts) {
         events: events.length,
         ...row.meta.agent !== void 0 ? { agent: row.meta.agent } : {},
         ...prUrl2 !== void 0 ? { prUrl: prUrl2 } : {},
-        ...routedOf(events) ? { routed: true } : {},
+        ...routedOf(row.meta, events) ? { routed: true } : {},
         ...status3 === "interrupted" ? { note: closureNote(row.meta.agent, prUrl2) } : {}
       });
       log(