@coreplane/switchboard 1.216.2 → 1.218.0

package/dist/cli.js

@@ -206,6 +206,9 @@ async function ensureWorkArea(at, version2, workers, deps) {
   }
   return { ok: true, copied: plan3.copy, installed: plan3.install };
 }
+function checkoutInstallHolds(root, dir, exists) {
+  return exists(join3(root, dir, "node_modules", "wrangler")) || exists(join3(root, "node_modules", "wrangler"));
+}
 function imageBuiltOutsideDir(renderedConfig) {
   const code = renderedConfig.split("\n").filter((l) => !l.trimStart().startsWith("//")).join("\n");
   for (const m of code.matchAll(/"image"\s*:\s*"([^"]+)"/g)) {
@@ -1796,7 +1799,7 @@ function getAgent(name) {
   }
   return a;
 }
-var MACHINE_CLASSES, IDENTITIES, HARNESSES, RUNAWAY_TURNS_PER_MINUTE, PR_DESCRIPTION_TEMPLATE, NEVER_MERGE, CONTRACT_HEADINGS_LIST, UNIT_CONTRACT, UNIT_HANDOFF, IMAGE_TOOLCHAIN, SANDBOX_TOOLCHAIN, RESIDENT_TOOLCHAIN, SHOW_FILES, CODING_SYSTEM, CODING_SYSTEM_RESIDENT, REVIEW_VERDICT_INSTRUCTION, REVIEW_SPEC_CHECK, REVIEW_UNIT_CONTRACT, REVIEW_WHOLE_CHANGE, REVIEW_SYSTEM, REVIEW_SYSTEM_RESIDENT, RESEARCH_SYSTEM, GENERAL_SYSTEM, EXPLORE_SYSTEM, COMPOUND_PRESET, WORK_PRESETS, AGENTS;
+var MACHINE_CLASSES, IDENTITIES, HARNESSES, RUNAWAY_TURNS_PER_MINUTE, PR_DESCRIPTION_TEMPLATE, NEVER_MERGE, CONTRACT_HEADINGS_LIST, UNIT_CONTRACT, UNIT_HANDOFF, IMAGE_TOOLCHAIN, SANDBOX_TOOLCHAIN, RESIDENT_TOOLCHAIN, SHOW_FILES, NOTEPAD, CODING_SYSTEM, CODING_SYSTEM_RESIDENT, REVIEW_VERDICT_INSTRUCTION, REVIEW_SPEC_CHECK, REVIEW_UNIT_CONTRACT, REVIEW_WHOLE_CHANGE, REVIEW_SYSTEM, REVIEW_SYSTEM_RESIDENT, RESEARCH_SYSTEM, GENERAL_SYSTEM, EXPLORE_SYSTEM, COMPOUND_PRESET, WORK_PRESETS, AGENTS;
 var init_registry = __esm({
   "../../src/agents/registry.ts"() {
     "use strict";
@@ -1827,6 +1830,8 @@ SCREENSHOTS GO TO BOTH PLACES, ALL OF THEM: when the request asks for screenshot
 Whole files: up to 1 GiB where the artifact store is configured (a recording, a large PDF), 10 MiB otherwise \u2014 the tool's result says which applies; over the limit, link to the file.
 Files the person dropped on the thread that were too large to show you inline are already in ./attachments/ in your workspace when the turn's text names them (a video for ffmpeg, a large PDF, a zip); read them from there \u2014 never ask for a re-upload.
 Text stays in your message; do not attach what you can say.`;
+    NOTEPAD = `YOUR NOTES AND YOUR REACH BACK. This thread's conversation outlives your context window and this run: every turn \u2014 yours, the person's, every tool call and its output, from this run and the runs before it in this thread \u2014 is kept in a log you can search with the \`recall\` tool (words \u2192 the matching turns with their numbers; a turn number \u2192 that turn whole). When something you need is no longer in front of you, recall it instead of redoing the work or guessing.
+Keep notes with the \`notes\` tool: one short document, replaced whole each time, at most 8 KiB \u2014 decisions and their reasons, the names of things you found (files, tests, commits, the head your tests were green at), what is not yet proven. They are the one thing sure to survive a compaction and to reach the next run in this thread: they ride your system prompt at its start and come back to you right after a compaction. Write them when you decide something worth keeping, not only at the end.`;
     CODING_SYSTEM = `You are Switchboard's coding agent, operating from a Slack request.
 
 You work inside a dedicated workspace directory with bash, read_file, and write_file tools. ${SANDBOX_TOOLCHAIN}
@@ -1856,6 +1861,8 @@ ${PR_DESCRIPTION_TEMPLATE}
 
 ${SHOW_FILES}
 
+${NOTEPAD}
+
 Maintain the user-facing status card with the update_status tool: right after you decide your plan, post it as a checklist (\u25CB pending items), then update it whenever an item starts (\u2731) or finishes (\u2713). Items are short outcomes ("Clone repo and read the diff", "Run the test suite"), never commands. Mark an item \u2713 only after it has actually happened \u2014 never pre-mark reporting/posting steps. This is the only progress the user sees while you work.
 
 If the request doesn't name a repository and you can't infer it, ask for it instead of guessing.
@@ -1890,6 +1897,8 @@ ${PR_DESCRIPTION_TEMPLATE}
 
 ${SHOW_FILES}
 
+${NOTEPAD}
+
 Maintain the user-facing status card with the update_status tool: right after you decide your plan, post it as a checklist (\u25CB pending items), then update it whenever an item starts (\u2731) or finishes (\u2713). Items are short outcomes ("Implement the fix", "Run the test suite"), never commands. Mark an item \u2713 only after it has actually happened \u2014 never pre-mark reporting/posting steps. This is the only progress the user sees while you work.
 
 Report outcomes faithfully: if tests fail or a step was skipped, say so plainly.
@@ -1922,6 +1931,8 @@ REVIEW THE PR'S OWN HEAD, NOTHING ELSE: the commit you read must be the PR's hea
 
 ${REVIEW_VERDICT_INSTRUCTION}
 
+${NOTEPAD}
+
 Maintain the user-facing status card with the update_status tool: post your plan as a checklist (\u25CB pending), update as items start (\u2731) and finish (\u2713 \u2014 only after they actually happened; never pre-mark reporting steps). Items are short outcomes, never commands.
 
 Your final message is posted to Slack. Lead with a one-line verdict, then the findings.`;
@@ -1948,6 +1959,8 @@ REVIEW THE PR'S OWN HEAD, NOTHING ELSE: the commit you read must be the PR's hea
 
 ${REVIEW_VERDICT_INSTRUCTION}
 
+${NOTEPAD}
+
 Maintain the user-facing status card with the update_status tool: post your plan as a checklist (\u25CB pending), update as items start (\u2731) and finish (\u2713 \u2014 only after they actually happened; never pre-mark reporting steps). Items are short outcomes, never commands.
 
 Your final message is posted to Slack. Lead with a one-line verdict, then the findings.`;
@@ -1981,6 +1994,8 @@ READ-ONLY: NEVER open a pull request, and never commit or push \u2014 no branch,
 
 Maintain the user-facing status card with the update_status tool: post your plan as a checklist (\u25CB pending) once you have it, and update items as they start (\u2731) and finish (\u2713 \u2014 only after they actually happened). Items are short outcomes ("Clone and install", "Time the full suite"), never commands.
 
+${NOTEPAD}
+
 Report outcomes faithfully: a check you could not run is "could not check", never a guess. Use Slack-friendly formatting (no markdown headers; *bold*, bullets, code blocks \u2014 render the claim table as aligned rows inside a code block). Your final message is posted to Slack: lead with the overall verdict in one line, then the claim table, then what a follow-up should do.`;
     COMPOUND_PRESET = "conductor";
     WORK_PRESETS = {
@@ -2167,8 +2182,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) {
@@ -2603,6 +2618,11 @@ function splitCredentialKey(key) {
   const name = key.slice(slash + 1);
   return parseMcpScopeKey(scopeKey) && MCP_SERVER_NAME_RE.test(name) ? { scopeKey, name } : void 0;
 }
+function isHeadersEnv(v) {
+  if (!v || typeof v !== "object" || Array.isArray(v)) return false;
+  const entries = Object.entries(v);
+  return entries.length > 0 && entries.length <= MCP_HEADERS_MAX && entries.every(([name, envVar]) => isStr(name, 64) && isStr(envVar, 128));
+}
 function isOutcome(v) {
   if (!v || typeof v !== "object" || Array.isArray(v)) return false;
   const o = v;
@@ -2611,7 +2631,7 @@ function isOutcome(v) {
 function isMcpServerEntry(v) {
   if (!v || typeof v !== "object" || Array.isArray(v)) return false;
   const e = v;
-  return isStr(e.url, MCP_URL_MAX) && (e.agents === void 0 || Array.isArray(e.agents) && e.agents.length > 0 && e.agents.length <= MCP_AGENTS_MAX && e.agents.every((a) => isStr(a, 32))) && (e.auth === "none" || e.auth === "bearer" || e.auth === "oauth") && (e.tokenEnv === void 0 || isStr(e.tokenEnv, 128)) && (e.addedBy === void 0 || isStr(e.addedBy, 260)) && (e.addedAt === void 0 || isNum(e.addedAt));
+  return isStr(e.url, MCP_URL_MAX) && (e.agents === void 0 || Array.isArray(e.agents) && e.agents.length > 0 && e.agents.length <= MCP_AGENTS_MAX && e.agents.every((a) => isStr(a, 32))) && (e.auth === "none" || e.auth === "bearer" || e.auth === "oauth") && (e.tokenEnv === void 0 || isStr(e.tokenEnv, 128)) && (e.headersEnv === void 0 || isHeadersEnv(e.headersEnv)) && (e.addedBy === void 0 || isStr(e.addedBy, 260)) && (e.addedAt === void 0 || isNum(e.addedAt));
 }
 function isSealedCredential(v) {
   if (!v || typeof v !== "object") return false;
@@ -2626,7 +2646,7 @@ function isMcpTicket(v) {
 }
 function serverView(scopeKey, name, entry, opts) {
   const parsed = parseMcpScopeKey(scopeKey);
-  const state = entry.auth === "none" ? "connected" : entry.tokenEnv ? "static" : opts.hasCredential ? "connected" : "awaiting_credential";
+  const state = entry.auth === "none" ? entry.headersEnv ? "static" : "connected" : entry.tokenEnv ? "static" : opts.hasCredential ? "connected" : "awaiting_credential";
   return {
     name,
     scope: parsed?.kind ?? "org",
@@ -2648,7 +2668,7 @@ function safeUrl(raw) {
     return "(invalid url)";
   }
 }
-var MCP_TICKET_STATES, MCP_TICKET_TTL_MS, MCP_SERVER_NAME_MAX, MCP_SERVER_NAME_RE, MCP_URL_MAX, MCP_AGENTS_MAX, MCP_SELF_SERVE_AGENTS, MCP_TOKEN_MAX_CHARS, MCP_SERVERS_PER_SCOPE_MAX, isStr, isNum;
+var MCP_TICKET_STATES, MCP_TICKET_TTL_MS, MCP_SERVER_NAME_MAX, MCP_SERVER_NAME_RE, MCP_URL_MAX, MCP_AGENTS_MAX, MCP_SELF_SERVE_AGENTS, MCP_TOKEN_MAX_CHARS, MCP_SERVERS_PER_SCOPE_MAX, isStr, isNum, MCP_HEADERS_MAX, MCP_HEADER_NAME_RE;
 var init_registry2 = __esm({
   "../../src/mcp/registry.ts"() {
     "use strict";
@@ -2669,6 +2689,8 @@ var init_registry2 = __esm({
     MCP_SERVERS_PER_SCOPE_MAX = 32;
     isStr = (v, max = 4096) => typeof v === "string" && v.length > 0 && v.length <= max;
     isNum = (v) => typeof v === "number" && Number.isFinite(v);
+    MCP_HEADERS_MAX = 8;
+    MCP_HEADER_NAME_RE = /^[!#$%&'*+.^_`|~0-9A-Za-z-]{1,64}$/;
   }
 });
 
@@ -2753,7 +2775,9 @@ function validateMcpServers(layer, source2) {
           `${source2}: ${path}.${name}: server names are slugs (lowercase letters, digits, dashes; \u2264 ${MCP_SERVER_NAME_MAX} chars)`
         );
       if (!isMcpServerEntry(raw))
-        throw new Error(`${source2}: ${path}.${name} must be { url, auth: none|bearer|oauth, agents?, tokenEnv? }`);
+        throw new Error(
+          `${source2}: ${path}.${name} must be { url, auth: none|bearer|oauth, agents?, tokenEnv?, headersEnv? }`
+        );
       try {
         assertUrlAllowed(raw.url);
       } catch (err2) {
@@ -2774,6 +2798,14 @@ function validateMcpServers(layer, source2) {
       }
       if (raw.tokenEnv !== void 0 && raw.auth !== "bearer")
         throw new Error(`${source2}: ${path}.${name}.tokenEnv only applies to auth: bearer`);
+      for (const header4 of Object.keys(raw.headersEnv ?? {})) {
+        if (!MCP_HEADER_NAME_RE.test(header4))
+          throw new Error(`${source2}: ${path}.${name}.headersEnv: "${header4}" is not an HTTP header name`);
+        if (header4.toLowerCase() === "authorization")
+          throw new Error(
+            `${source2}: ${path}.${name}.headersEnv: the Authorization header is \`auth\`'s \u2014 use auth: bearer with tokenEnv`
+          );
+      }
     }
   };
   check("defaults.mcpServers", "org", layer.defaults?.mcpServers);
@@ -4989,7 +5021,7 @@ function planDeploy(opts, host, loaded, images) {
 function formatPlan(plan3) {
   const missing = plan3.checks.nodeModulesMissing;
   const checkout = plan3.root.mode === "checkout";
-  const nodeModules = missing.length === 0 ? "node_modules present in every dir" : checkout ? `node_modules missing in ${missing.join(", ")} \u2014 the runner will \`npm ci\` there first` : `${missing.join(", ")} not installed under ${WORK_AREA_DIR}/ \u2014 the runner will \`npm ci\` them there first`;
+  const nodeModules = missing.length === 0 ? "node_modules present in every dir" : checkout ? `install missing for ${missing.join(", ")} \u2014 the runner will \`npm ci\` at the checkout's root first` : `${missing.join(", ")} not installed under ${WORK_AREA_DIR}/ \u2014 the runner will \`npm ci\` them there first`;
   const tree = checkout ? `${plan3.checks.cleanTree ? "clean tree" : "tree unchecked"}; ${plan3.checks.atOriginMain ? "HEAD == origin/main" : "any branch (--allow-branch)"}` : `Worker sources are the package's (version ${plan3.root.version ?? "?"}), materialised under ${WORK_AREA_DIR}/ \u2014 no git`;
   const lines = [
     ...plan3.affected ? [formatAffectedText(plan3.affected)] : [],
@@ -6241,7 +6273,7 @@ var init_sandboxLiveGate = __esm({
 // ../../src/deploy/run.ts
 import { spawn as spawn3 } from "node:child_process";
 import { existsSync as existsSync5, mkdirSync as mkdirSync4, readFileSync as readFileSync6, writeFileSync as writeFileSync4 } from "node:fs";
-import { dirname as dirname4, isAbsolute as isAbsolute3, join as join5 } from "node:path";
+import { dirname as dirname4, isAbsolute as isAbsolute3 } from "node:path";
 function run(cmd, args, opts) {
   const env = { ...process.env, ...opts.set ?? {} };
   for (const k of opts.unset ?? []) delete env[k];
@@ -6348,7 +6380,7 @@ function packageModeProblems(plan3) {
   return problems;
 }
 function hasNodeModules(dir) {
-  if (OPERATOR_ROOT.mode === "checkout") return existsSync5(join5(OPERATOR_ROOT.root, dir, "node_modules"));
+  if (OPERATOR_ROOT.mode === "checkout") return checkoutInstallHolds(OPERATOR_ROOT.root, dir, existsSync5);
   const state = readWorkAreaState(OPERATOR_ROOT.workArea);
   return state.kind === "stamped" && state.stamp.installed.includes(dir);
 }
@@ -6514,10 +6546,10 @@ async function pushConfigOnHost(opts) {
   return pushConfigDocument(read, { stateWorkerUrl: opts.stateWorkerUrl, key: opts.key, env: process.env });
 }
 async function ensureNodeModules(step, io) {
-  const dir = workerDir(step.dir);
   if (hasNodeModules(step.dir)) return true;
-  io.log(`[deploy:all] ${step.name}: node_modules missing \u2014 npm ci`);
-  const r = await run("npm", ["ci", "--silent"], { cwd: dir });
+  const cwd = OPERATOR_ROOT.mode === "checkout" ? OPERATOR_ROOT.root : workerDir(step.dir);
+  io.log(`[deploy:all] ${step.name}: install missing \u2014 npm ci in ${cwd}`);
+  const r = await run("npm", ["ci", "--silent"], { cwd });
   if (r.code !== 0) io.warn(r.output);
   return r.code === 0;
 }
@@ -7582,6 +7614,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) {
@@ -7671,9 +7856,9 @@ var init_secrets = __esm({
 import { spawn as spawn4 } from "node:child_process";
 import { existsSync as existsSync6, readFileSync as readFileSync7 } from "node:fs";
 import { homedir as homedir2 } from "node:os";
-import { isAbsolute as isAbsolute4, join as join6, resolve as resolve4 } from "node:path";
+import { isAbsolute as isAbsolute4, join as join5, resolve as resolve4 } from "node:path";
 function expandDir(path, root = OPERATOR_ROOT.root) {
-  if (path === "~" || path.startsWith("~/")) return join6(homedir2(), path.slice(1));
+  if (path === "~" || path.startsWith("~/")) return join5(homedir2(), path.slice(1));
   if (isAbsolute4(path)) return path;
   return resolve4(root, path);
 }
@@ -7717,7 +7902,7 @@ async function opFieldLabels(source2) {
 }
 function wranglerBin(dir, workspaceRoot, exists = existsSync6) {
   for (const base of [dir, workspaceRoot]) {
-    const bin = join6(base, "node_modules", ".bin", "wrangler");
+    const bin = join5(base, "node_modules", ".bin", "wrangler");
     if (exists(bin)) return bin;
   }
   return "wrangler";
@@ -7738,7 +7923,7 @@ var init_secretsHost = __esm({
         if (source2.kind === "dir") {
           const dir = expandDir(source2.path);
           if (!existsSync6(dir)) return { ok: false, problem: `secretsSource ${source2.path}: no such directory (${dir})` };
-          return { ok: true, present: new Set(names.filter((n2) => existsSync6(join6(dir, n2)))) };
+          return { ok: true, present: new Set(names.filter((n2) => existsSync6(join5(dir, n2)))) };
         }
         const labels = await opFieldLabels(source2);
         if (!labels.ok) return labels;
@@ -7747,7 +7932,7 @@ var init_secretsHost = __esm({
       put: async (source2, dir, name) => {
         let value;
         if (source2.kind === "dir") {
-          value = readFileSync7(join6(expandDir(source2.path), name), "utf8");
+          value = readFileSync7(join5(expandDir(source2.path), name), "utf8");
         } else {
           const r2 = await spawnCollect("op", ["read", `op://${source2.vault}/${source2.item}/${name}`]);
           if (r2.code !== 0) return { code: r2.code, output: `op read exited ${r2.code} \u2014 ${r2.stderr.trim()}` };
@@ -7842,6 +8027,7 @@ var init_runEvents = __esm({
       "mcp_unavailable",
       "follow_up",
       "resumed",
+      "seed",
       "description_turn",
       "cold_sandbox",
       "pr_not_opened",
@@ -7960,11 +8146,11 @@ var init_readingDiff = __esm({
 // ../../src/core/meatProcess.ts
 import { spawn as spawn5 } from "node:child_process";
 import { accessSync, constants } from "node:fs";
-import { delimiter, join as join7 } from "node:path";
+import { delimiter, join as join6 } from "node:path";
 function meatOnPath(env, binary = MEAT_BINARY) {
   return (env.PATH ?? "").split(delimiter).filter((dir) => dir !== "").some((dir) => {
     try {
-      accessSync(join7(dir, binary), constants.X_OK);
+      accessSync(join6(dir, binary), constants.X_OK);
       return true;
     } catch {
       return false;
@@ -8044,10 +8230,10 @@ import { chmod, mkdir, readFile, rename, rm, writeFile } from "node:fs/promises"
 import { randomBytes } from "node:crypto";
 import { createInterface } from "node:readline/promises";
 import { Writable } from "node:stream";
-import { dirname as dirname5, join as join8, resolve as resolve5 } from "node:path";
+import { dirname as dirname5, join as join7, resolve as resolve5 } from "node:path";
 async function readTemplates(root = PACKAGE_ROOT) {
   const read = async (key) => {
-    const path = join8(root, TEMPLATE_PATHS[key]);
+    const path = join7(root, TEMPLATE_PATHS[key]);
     if (!existsSync7(path)) throw new Error(`${TEMPLATE_PATHS[key]}: no such file under ${root}`);
     return readFile(path, "utf8");
   };
@@ -8061,7 +8247,7 @@ function isCheckoutRoot(cwd = process.cwd(), root = PACKAGE_ROOT) {
   }
 }
 async function writePlannedFile(file, cwd = process.cwd()) {
-  const path = join8(cwd, file.path);
+  const path = join7(cwd, file.path);
   await mkdir(dirname5(path), { recursive: true });
   const temp = `${path}.${randomBytes(6).toString("hex")}.tmp`;
   try {
@@ -8096,7 +8282,7 @@ function ttyPrompter(io = { stdin: process.stdin, stdout: process.stdout }) {
   };
 }
 function projectFact(name, root) {
-  const facts2 = JSON.parse(readFileSync8(join8(root, "project.json"), "utf8"));
+  const facts2 = JSON.parse(readFileSync8(join7(root, "project.json"), "utf8"));
   const value = facts2[name];
   if (typeof value !== "string") throw new Error(`project.json: no \`${name}\` fact`);
   return value;
@@ -8112,7 +8298,7 @@ function hostSetupIO(cwd = OPERATOR_ROOT.root, startedIn = process.cwd()) {
     templates: () => readTemplates(),
     // Where the files went when that is not where the operator stands — `init` prints it.
     root: () => resolve5(cwd) === resolve5(startedIn) ? void 0 : cwd,
-    exists: async (path) => existsSync7(join8(cwd, path)),
+    exists: async (path) => existsSync7(join7(cwd, path)),
     write: (file) => writePlannedFile(file, cwd),
     // A file the operator NAMED (`--github-private-key-file app.pem`) is where the operator stands,
     // not in the installation: `init` run from ~/Downloads reads ~/Downloads/app.pem.
@@ -8168,9 +8354,9 @@ var init_binaryRead = __esm({
 
 // ../../src/secrets.ts
 import { readFileSync as readFileSync9 } from "node:fs";
-import { join as join9 } from "node:path";
+import { join as join8 } from "node:path";
 function manifestNames() {
-  const raw = JSON.parse(readFileSync9(join9(PACKAGE_ROOT, MANIFEST_PATH), "utf8"));
+  const raw = JSON.parse(readFileSync9(join8(PACKAGE_ROOT, MANIFEST_PATH), "utf8"));
   const parsed = parseManifest2(raw);
   if (!parsed.ok) throw new Error(`${MANIFEST_PATH} is invalid \u2014 ${parsed.problems.join("; ")}`);
   return parsed.manifest.secrets.map((s) => s.name);
@@ -11997,8 +12183,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>");
@@ -12018,7 +12306,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";
@@ -12028,25 +12316,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.",
@@ -12060,15 +12348,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
       }),
@@ -12135,10 +12423,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.",
@@ -12155,18 +12443,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,8 +12514,8 @@ ${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 { basename, dirname as dirname8, join as join9 } from "node:path";
+import { z as z7 } from "zod";
 function repoRootOfPlan(planPath) {
   const plans = dirname8(planPath);
   const docs = dirname8(plans);
@@ -12245,24 +12533,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();
-    SPECS_DIR = join10("docs", "reference", "specs");
+    defineCommand4 = commandDefiner();
+    SPECS_DIR = join9("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",
@@ -12276,10 +12564,10 @@ var init_contract2 = __esm({
         const unit = parsePlanUnit(planMarkdown, options.unit);
         const specs = /* @__PURE__ */ new Map();
         for (const spec of new Set(unit ? specItemRefs(unit.section).map((r) => r.spec) : []))
-          specs.set(spec, await deps.contract.readFile(join10(root, SPECS_DIR, spec)));
+          specs.set(spec, await deps.contract.readFile(join9(root, SPECS_DIR, spec)));
         let agentRules;
         for (const file of RULES_FILES) {
-          const text = await deps.contract.readFile(join10(root, file));
+          const text = await deps.contract.readFile(join9(root, file));
           if (text !== void 0) {
             agentRules = { file, text };
             break;
@@ -13204,7 +13492,7 @@ function isSetupInstallCommand(summary) {
   return INSTALL_SEGMENT.test(cmd.replace(QUOTED, '""'));
 }
 function isNarrative(ev) {
-  return ev.type === "input" || ev.type === "context" || ev.type === "assistant" || ev.type === "answer" || ev.type === "run_meta";
+  return ev.type === "input" || ev.type === "context" || ev.type === "assistant" || ev.type === "answer" || ev.type === "notes" || ev.type === "run_meta";
 }
 function spanSet(events) {
   const normalized = normalizeSpans(events);
@@ -13909,7 +14197,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 = {
@@ -13954,11 +14242,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";
@@ -13966,16 +14254,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")
@@ -14020,7 +14308,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,
@@ -14130,7 +14418,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";
@@ -14143,16 +14431,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`
       ),
@@ -14171,7 +14459,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",
@@ -14187,7 +14475,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",
@@ -14238,15 +14526,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",
@@ -14287,12 +14575,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",
@@ -14339,12 +14627,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",
@@ -14379,21 +14667,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(", ")})`
         }
       ],
@@ -14455,12 +14743,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",
@@ -14511,25 +14799,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",
@@ -15127,6 +15415,7 @@ function isRunEvent(v) {
     case "input":
     case "assistant":
     case "context":
+    case "notes":
       return typeof o.text === "string";
     // the narrative events carry text, not a summary
     case "run_meta":
@@ -15263,7 +15552,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 {
@@ -15291,7 +15580,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";
@@ -15302,19 +15591,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)")
       }),
@@ -15340,10 +15629,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)"),
@@ -15375,17 +15664,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",
@@ -15438,7 +15727,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()}`);
 }
@@ -15510,7 +15799,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;
 }
@@ -15522,7 +15811,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 ?? []);
   }
@@ -15762,17 +16051,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",
@@ -15783,7 +16072,7 @@ var init_help = __esm({
         commandsReference: COMMANDS_REFERENCE_URL
       })
     });
-    helpCommandsList = defineCommand8({
+    helpCommandsList = defineCommand9({
       id: "help.commands",
       action: "help:read",
       effect: "read",
@@ -16975,7 +17264,11 @@ var init_service = __esm({
       /** A fresh connect link for a runtime bearer/oauth server (first connect, or a re-key). */
       async connect(actor, target, name) {
         const { scopeKey, entry, source: source2 } = this.owned(target, name);
-        if (entry.auth === "none") throw new McpServiceError("invalid_input", `"${name}" needs no credential (auth: none)`);
+        if (entry.auth === "none")
+          throw new McpServiceError(
+            "invalid_input",
+            entry.headersEnv ? `"${name}" is pinned in config.yaml with headersEnv \u2014 its headers are environment variables on the bot, not a stored credential` : `"${name}" needs no credential (auth: none)`
+          );
         if (entry.tokenEnv)
           throw new McpServiceError(
             "invalid_input",
@@ -17452,6 +17745,15 @@ var init_service = __esm({
           url: r.entry.url,
           agents: r.entry.agents ?? [...MCP_SELF_SERVE_AGENTS]
         };
+        if (r.entry.headersEnv) {
+          const headers = {};
+          for (const [header4, envVar] of Object.entries(r.entry.headersEnv)) {
+            const value = this.opts.bearers.named(envVar);
+            if (!value) return { name: r.name, unavailable: `${envVar} is not set on the bot` };
+            headers[header4] = value.reveal();
+          }
+          base.headers = headers;
+        }
         if (r.entry.auth === "none") return { spec: base };
         if (r.entry.tokenEnv) {
           const token2 = this.opts.bearers.named(r.entry.tokenEnv);
@@ -17520,7 +17822,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);
@@ -17571,7 +17873,7 @@ async function settleConnect(deps, output) {
   }
 }
 function renderServerLine(r) {
-  const state = r.state === "connected" ? "\u2705 connected" : r.state === "static" ? "\u2705 static (tokenEnv)" : "\u23F3 awaiting credential";
+  const state = r.state === "connected" ? "\u2705 connected" : r.state === "static" ? "\u2705 static (bot env)" : "\u23F3 awaiting credential";
   const agents = Array.isArray(r.agents) ? r.agents.join(", ") : "";
   const pinned = r.source === "config" ? " \xB7 pinned in config.yaml" : "";
   return `\u2022 \`${String(r.name)}\` (${String(r.scope)}) ${state} \u2014 ${String(r.url)} \xB7 agents: ${agents} \xB7 auth: ${String(r.auth)}${pinned}`;
@@ -17614,7 +17916,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";
@@ -17622,18 +17924,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.",
@@ -17645,7 +17947,7 @@ var init_mcp = __esm({
         return { servers };
       }
     });
-    mcpAdd = defineCommand9({
+    mcpAdd = defineCommand10({
       id: "mcp.add",
       enabledWhen: (caps) => caps.mcp,
       args: [
@@ -17655,15 +17957,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
@@ -17688,11 +17990,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.",
@@ -17706,11 +18008,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.",
@@ -17726,11 +18028,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).",
@@ -18168,7 +18470,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;
@@ -18387,7 +18689,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"];
@@ -18507,11 +18809,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;
 }
@@ -18619,7 +18921,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;
@@ -18673,18 +18975,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`)"
     );
@@ -18692,21 +18994,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",
@@ -18760,7 +19062,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`)" }],
@@ -18895,7 +19197,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);
@@ -19003,7 +19305,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",
@@ -19061,7 +19363,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";
@@ -19069,19 +19371,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",
@@ -19098,11 +19400,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)"
@@ -19189,10 +19491,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],
@@ -19226,7 +19528,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],
@@ -19265,11 +19567,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"),
@@ -20239,7 +20541,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 } : {},
@@ -20308,7 +20610,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";
@@ -20317,17 +20619,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`")
       }),
@@ -20359,7 +20661,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");
@@ -20400,7 +20702,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";
@@ -20409,21 +20711,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",
@@ -20431,14 +20736,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",
@@ -20458,11 +20766,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",
@@ -20476,7 +20784,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",
@@ -20489,10 +20797,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.",
@@ -20516,16 +20824,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",
@@ -20789,7 +21097,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;
@@ -20859,33 +21167,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)"
       ),
@@ -20895,7 +21203,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",
@@ -20995,13 +21303,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",
@@ -21040,6 +21348,7 @@ function registerCoreCommands(registry) {
   registerSetupCommands(registry);
   registerContractCommands(registry);
   registerDeliveryCommands(registry);
+  registerArtifactsCommands(registry);
 }
 function coreCommandGroups() {
   const registry = new CommandRegistry({ audit: () => {
@@ -21051,6 +21360,7 @@ var init_all = __esm({
   "../../src/core/commands/all.ts"() {
     "use strict";
     init_commandRegistry();
+    init_artifacts();
     init_config4();
     init_contract2();
     init_delivery2();
@@ -21334,6 +21644,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.
@@ -21367,6 +21682,7 @@ var init_commandCatalogue = __esm({
     init_clock();
     init_run();
     init_imagesHost();
+    init_artifactsBucket();
     init_secretsHost();
     init_host3();
     init_executor();
@@ -21585,6 +21901,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);
@@ -21653,6 +21975,8 @@ function activityLine(e) {
       return "request received";
     case "context":
       return "context recorded";
+    case "notes":
+      return "\u{1F4DD} notes saved";
     case "answer":
       return "answer ready";
     case "run_meta":
@@ -24257,7 +24581,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,
@@ -25082,7 +25407,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);
 }
@@ -25370,34 +25695,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_.-]+$/;
@@ -26169,10 +26494,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;
@@ -26638,8 +26964,136 @@ var init_runs2 = __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, NOTEPAD_MAX_BYTES, GAP_MARKER;
+var init_sessionLog = __esm({
+  "../../src/core/runLedger/sessionLog.ts"() {
+    "use strict";
+    init_runRecord();
+    init_runRecord();
+    DEFAULT_SESSION_LOG_MAX_BYTES = DEFAULT_RETENTION_POLICY.sessionLogMaxBytes;
+    NOTEPAD_MAX_BYTES = 8192;
+    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.]";
+  }
+});
+
+// ../../src/tools/session.ts
+function sessionCapabilityFor(run2, ledger) {
+  const session = run2?.session;
+  if (!session) return void 0;
+  return {
+    session,
+    search: (query, limit) => ledger.searchSession(session.key, query, limit),
+    readTurn: async (idx) => (await ledger.readSession(session.key, idx, idx)).messages[0],
+    readNotepad: () => ledger.readNotepad(session.key),
+    writeNotepad: (text) => ledger.writeNotepad(session.key, text)
+  };
+}
+async function mayRead(ctx) {
+  if (!ctx.runs?.runId) return false;
+  const res = await ctx.runs.service.getRun(ctx.runs.runId);
+  return res.ok && authorize(ctx.runs.actor, "runs:read", runResource(res.value)).allow;
+}
+var UNAVAILABLE3, DEFAULT_HITS, MAX_HITS, SNIPPET_CHARS, snippetOf, recallTool, notesTool, SESSION_TOOLS;
+var init_session = __esm({
+  "../../src/tools/session.ts"() {
+    "use strict";
+    init_authorize();
+    init_runEvents();
+    init_sessionLog();
+    init_runRecord();
+    init_runsService();
+    UNAVAILABLE3 = "the session tools are not available in this context: this run has no session log.";
+    DEFAULT_HITS = 5;
+    MAX_HITS = 50;
+    SNIPPET_CHARS = 300;
+    snippetOf = (text) => {
+      const line3 = text.replace(/\s+/g, " ").trim();
+      return line3.length > SNIPPET_CHARS ? `${line3.slice(0, SNIPPET_CHARS - 1)}\u2026` : line3;
+    };
+    recallTool = {
+      name: "recall",
+      description: "Search this conversation's whole log \u2014 every turn of this thread on this agent, earlier runs' included and everything a compaction removed from your window \u2014 for words, and get the matching turns in relevance order with their turn numbers and a snippet; or pass `turn` to read one turn whole (a tool result, a command, a message). Use it when you need something said or seen earlier that is not in front of you: a failing test's name, a command's output, a decision. `limit` defaults to 5 (at most 50).",
+      inputSchema: {
+        type: "object",
+        properties: {
+          query: { type: "string", description: "Words to search for; matching is by word, in relevance order" },
+          limit: { type: "integer", description: "How many turns to return (default 5, at most 50)" },
+          turn: {
+            type: "integer",
+            description: "A turn number from an earlier recall: returns that turn whole instead of searching"
+          }
+        }
+      },
+      sideEffectFree: true,
+      async run(input, ctx) {
+        if (!ctx.session) return UNAVAILABLE3;
+        const turn = typeof input.turn === "number" ? Math.trunc(input.turn) : void 0;
+        const query = typeof input.query === "string" ? input.query.trim() : "";
+        if (turn === void 0 && query.length === 0) return "recall needs a query or a turn number.";
+        if (!await mayRead(ctx)) return JSON.stringify(turn !== void 0 ? { turn, content: null } : { hits: [] });
+        if (turn !== void 0) {
+          const message2 = turn >= 0 ? await ctx.session.readTurn(turn) : void 0;
+          if (!message2) return `no turn ${turn} in this session's log.`;
+          return JSON.stringify({ turn, role: message2.role, content: message2.content });
+        }
+        const limit = Math.min(
+          MAX_HITS,
+          Math.max(1, typeof input.limit === "number" ? Math.trunc(input.limit) : DEFAULT_HITS)
+        );
+        const { hits, gaps } = await ctx.session.search(query, limit);
+        const notes = [];
+        if (hits.length === 0)
+          notes.push("no turn of this session's log matches; your notes (notes {}) may hold what you look for");
+        if (ctx.session.session.seedFrom === 0) notes.push("this is the first run of its session: the log begins with it");
+        return JSON.stringify({
+          hits: hits.map((h) => ({
+            turn: h.idx,
+            ...h.role !== void 0 ? { role: h.role } : {},
+            snippet: snippetOf(h.text)
+          })),
+          ...gaps.length ? {
+            gaps: `the log has a gap at ${gaps.map((g) => `turn ${g}`).join(", ")}: a run before it detached from the ledger, so turns it saw after that point are not here`
+          } : {},
+          ...notes.length ? { note: notes.join("; ") } : {}
+        });
+      }
+    };
+    notesTool = {
+      name: "notes",
+      description: "Your notes for this thread \u2014 one document, replaced whole on every write, at most 8 KiB. Keep in it what must survive a compaction and reach the next run in this thread: decisions and their reasons, the names of things you found (files, tests, commits), what is not yet proven. They ride your system prompt at the start of every later run and reach you again right after a compaction. Call with `text` to write; with nothing to read.",
+      inputSchema: {
+        type: "object",
+        properties: { text: { type: "string", description: "The whole notepad as it should read from now on" } }
+      },
+      async run(input, ctx) {
+        if (!ctx.session) return UNAVAILABLE3;
+        if (typeof input.text !== "string") {
+          const current = await ctx.session.readNotepad();
+          return current && current.text.length > 0 ? current.text : "(your notes for this thread are empty)";
+        }
+        const bytes = utf8ByteLength(input.text);
+        if (bytes > NOTEPAD_MAX_BYTES)
+          return `your notes are ${bytes} bytes; the notepad holds at most ${NOTEPAD_MAX_BYTES} \u2014 shorten them and write again.`;
+        const written = await ctx.session.writeNotepad(input.text);
+        if (!written.ok) return `notes not saved (${written.reason}): another generation drives this run now.`;
+        ctx.publish?.({ type: "notes", text: redactSecrets(input.text) });
+        return `notes saved (${bytes} bytes); they ride your system prompt at the next run in this thread and reach you again after a compaction.`;
+      }
+    };
+    SESSION_TOOLS = [recallTool, notesTool];
+  }
+});
+
 // ../../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"() {
@@ -26656,6 +27110,7 @@ var init_workspace = __esm({
     init_skills();
     init_attach();
     init_runs2();
+    init_session();
     bashTool = {
       name: "bash",
       description: "Run a bash command in the workspace directory. Use for git, gh, tests, builds, and inspecting files. Commands time out after 5 minutes (300000 ms) by default; pass timeoutMs when a command legitimately needs longer \u2014 a full test suite, a large build \u2014 up to the 1200000 ms (20 minute) maximum; a command is also clipped to the run's own remaining time, so it can never outlive the run. Output is truncated at 30k characters.",
@@ -26938,7 +27393,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);
@@ -27025,7 +27480,8 @@ ${raw.trim()}`;
         listSkillsTool,
         useSkillTool,
         ...GITHUB_READ_TOOLS,
-        ...GITHUB_ISSUE_WRITE_TOOLS
+        ...GITHUB_ISSUE_WRITE_TOOLS,
+        ...SESSION_TOOLS
       ],
       readonly: [
         bashTool,
@@ -27036,7 +27492,8 @@ ${raw.trim()}`;
         diffDigestTool,
         listSkillsTool,
         useSkillTool,
-        ...GITHUB_READ_TOOLS
+        ...GITHUB_READ_TOOLS,
+        ...SESSION_TOOLS
       ],
       web: [webFetchTool, webSearchTool, updateStatusTool, ...GITHUB_READ_TOOLS],
       /** The general agent: no workspace, no shell — GitHub reads + issue writes
@@ -27056,7 +27513,8 @@ ${raw.trim()}`;
         webSearchTool,
         listSkillsTool,
         useSkillTool,
-        ...GITHUB_READ_TOOLS
+        ...GITHUB_READ_TOOLS,
+        ...SESSION_TOOLS
       ],
       /** The conductor (docs/reference/specs/agent-conductor.md): the five run
        *  tools — the only toolset that holds them, so no other preset can start,
@@ -27934,7 +28392,7 @@ Target repository: ${input.repo}. ` + (workspace ? `Your shell starts in the wor
   const agentSystem = (head) => {
     return [residentSystem ?? agent.system, targetBlock(head), input.contract, blocks.skills, blocks.mcp].filter((b) => Boolean(b)).join("\n\n");
   };
-  return (head) => [blocks.memory, blocks.config, blocks.about, blocks.instructions, agentSystem(head)].filter((part) => Boolean(part)).join("\n\n");
+  return (head) => [blocks.memory, blocks.notes, blocks.config, blocks.about, blocks.instructions, agentSystem(head)].filter((part) => Boolean(part)).join("\n\n");
 }
 async function settleReviewedHead(input) {
   return input.span ? input.span.span("run.settle_reviewed_head", (span) => settle(input, span)) : settle(input, void 0);
@@ -28777,13 +29235,13 @@ var init_frontmatter = __esm({
 
 // ../../src/skills/stores.ts
 import { existsSync as existsSync11, readFileSync as readFileSync13, readdirSync as readdirSync2 } from "node:fs";
-import { join as join11 } from "node:path";
+import { join as join10 } from "node:path";
 function loadBundledSkills(dir) {
   if (!existsSync11(dir)) return [];
   const skills = [];
   for (const entry of readdirSync2(dir, { withFileTypes: true })) {
     if (!entry.isDirectory()) continue;
-    const file = join11(dir, entry.name, "SKILL.md");
+    const file = join10(dir, entry.name, "SKILL.md");
     if (!existsSync11(file)) continue;
     try {
       skills.push(parseSkillMarkdown(readFileSync13(file, "utf8")));
@@ -29340,6 +29798,20 @@ function mintRunBearer(deps, ctx) {
     publish: (event) => registry.publish(runId3, event)
   });
 }
+function sessionNotesBlock(session) {
+  const parts = [];
+  const notepad = session.notepad?.trim();
+  const summary = session.summary?.trim();
+  if (notepad)
+    parts.push(
+      "YOUR NOTES FOR THIS THREAD (kept with the `notes` tool \u2014 the one thing sure to survive a compaction and reach the next run here; replace them whole when they change):\n" + notepad
+    );
+  if (summary)
+    parts.push(
+      "SUMMARY OF THE EARLIER CONVERSATION (written when the context was compacted; every earlier turn is still reachable with `recall`):\n" + summary
+    );
+  return parts.length ? parts.join("\n\n") : void 0;
+}
 async function composePrompt(deps, ctx) {
   const {
     msg,
@@ -29402,6 +29874,7 @@ async function composePrompt(deps, ctx) {
   );
   const instructionsBlock = customInstructionsBlock(scopes);
   const memoryBlock = await root.span("dispatch.compose", () => memoryBlockP);
+  const notesBlock = ctx.session ? sessionNotesBlock(ctx.session) : void 0;
   const composeSystem = makeSystemComposer({
     agent,
     resident: resident === true,
@@ -29417,6 +29890,7 @@ async function composePrompt(deps, ctx) {
     ...ctx.contract !== void 0 ? { contract: ctx.contract } : {},
     blocks: {
       memory: memoryBlock,
+      notes: notesBlock,
       config: configBlock,
       about: aboutBlock,
       instructions: instructionsBlock,
@@ -29483,7 +29957,8 @@ async function claimRun(deps, ctx) {
     parentRunId,
     coordinator,
     seed,
-    route: route3
+    route: route3,
+    seedLog
   } = ctx;
   const { resident, binding } = selection;
   let ledgerRun = ctx.ledgerRun;
@@ -29528,8 +30003,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
@@ -29599,7 +30075,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) {
@@ -29610,7 +30086,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)}`,
@@ -29638,6 +30114,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);
@@ -29706,6 +30185,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 } : {} });
       }
@@ -30382,9 +30864,8 @@ function piBuiltinToolsFor(identity2) {
 function piThinkingLevel(effort2) {
   return effort2;
 }
-function piRunPaths(runId3, user) {
-  const root = user ? `/tmp/switchboard-pi-${user}` : "/tmp/switchboard-pi";
-  const dir = `${root}/${runId3}`;
+function piRunPaths(runId3) {
+  const dir = `/tmp/switchboard-pi-${runId3}`;
   return {
     dir,
     agentDir: `${dir}/agent`,
@@ -30587,6 +31068,14 @@ var init_transport = __esm({
 function relayedTools(tools) {
   return tools.filter((t) => !NATIVE_WORKSPACE_TOOLS.has(t.name));
 }
+function compactionSteer(notepad, opts = {}) {
+  const notes = notepad?.trim();
+  const reach = "Your context was just compacted: the summary now standing in for the earlier turns is pi's, and every one of those turns is still reachable with the `recall` tool (search by words, or read a turn by its number).\n\n";
+  if (opts.unavailable)
+    return reach + "Your notes for this thread could not be read just now; `notes {}` reads them on demand, and `notes { text }` still writes them.";
+  return reach + (notes ? `YOUR NOTES FOR THIS THREAD, as you last wrote them with \`notes\`:
+${notes}` : "Your notes for this thread are empty. Write them with the `notes` tool when you have decisions, the names of things you found and what is not yet proven worth keeping \u2014 they survive every compaction and reach the next run in this thread.");
+}
 function splitSeed(seed) {
   for (let i = seed.length - 1; i >= 0; i--) {
     if (seed[i].role === "user") return { session: seed.slice(0, i), prompt: seed[i] };
@@ -30631,7 +31120,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, run2.user);
+  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);
@@ -30865,7 +31354,23 @@ async function runPiHarness(deps, run2) {
         }
       }
       if (obs.message) await mirror.onMessage(obs.message, bridge.turns);
-      if (obs.compaction) await mirror.onCompaction(obs.compaction, bridge.turns);
+      if (obs.compaction) {
+        await mirror.onCompaction(obs.compaction, bridge.turns);
+        if (!writeUp && !hardStopped && !catchingUp) {
+          let notepad;
+          let unavailable = false;
+          try {
+            notepad = run2.notepad ? (await run2.notepad())?.text : void 0;
+          } catch (err2) {
+            unavailable = true;
+            note(
+              "harness_error",
+              `the notepad could not be read for the compaction steer (${err2 instanceof Error ? err2.message : String(err2)}); steered without it`
+            );
+          }
+          transport.send({ type: "steer", message: compactionSteer(notepad, { unavailable }) });
+        }
+      }
       if (obs.providerError !== void 0) {
         if (catchingUp)
           note("harness_error", `a model call failed while the bot was away (${obs.providerError}); continuing`);
@@ -30903,6 +31408,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");
   }
 }
@@ -31451,6 +31958,7 @@ async function runLoop2(deps, ctx) {
     runs,
     steer,
     wait,
+    session,
     parentRunId,
     coordinator,
     seed
@@ -31577,12 +32085,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 = {
@@ -31599,6 +32106,7 @@ async function runLoop2(deps, ctx) {
     ...runs ? { runs } : {},
     ...steer ? { steer } : {},
     ...wait ? { wait } : {},
+    ...session ? { session } : {},
     onVerdict,
     onDigest,
     onPrDescription,
@@ -31646,15 +32154,12 @@ async function runLoop2(deps, ctx) {
           messages,
           tools: relayedTools(mergeTools(TOOLSETS[agent.toolset] ?? [], mcpForRun?.tools)),
           toolContext,
+          ...session ? { notepad: () => session.readNotepad() } : {},
           rules: {
             checkout: binding?.workspace ?? "/workspace",
             ...ownBranch !== void 0 ? { branch: ownBranch } : {},
             protectedBranches
           },
-          // The resident runs this thread's commands as its pool user: pi's
-          // files go under that user's own root, never one another thread's
-          // user created (harness-pi.md item 4).
-          ...binding?.user ? { user: binding.user } : {},
           ...round2.selection.backend ? { backend: round2.selection.backend } : {},
           span: root,
           control: run2.control,
@@ -33326,15 +33831,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,
@@ -33391,6 +33888,150 @@ var init_lineage = __esm({
   }
 });
 
+// ../../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
+  });
+  if (!seed) return { notes: [] };
+  try {
+    const notepad = await input.ledger.readNotepad(key);
+    if (notepad && notepad.text.trim().length > 0) seed.notepad = notepad.text;
+  } catch (err2) {
+    const why = err2 instanceof Error ? err2.message : String(err2);
+    seed.notes.push(`session seed: the notepad of ${key} could not be read (${why}) \u2014 the run starts without it`);
+  }
+  return { seed, notes: seed.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, 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;
+    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;
@@ -33528,7 +34169,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;
@@ -33539,7 +34181,18 @@ 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;
@@ -33677,8 +34330,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,
@@ -33716,12 +34384,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();
@@ -33831,7 +34501,15 @@ async function dispatch(deps, msg, io, opts = {}) {
       verifiedAtAttach,
       resume,
       root,
-      ...contractBlock !== void 0 && agent.name === "review" ? { contract: contractBlock } : {}
+      ...contractBlock !== void 0 && agent.name === "review" ? { contract: contractBlock } : {},
+      // What the session already knows (session-log item 10): the notepad and
+      // the newest compaction's summary the seed brought back, for the prompt.
+      ...session && (session.notepad !== void 0 || session.summary !== void 0) ? {
+        session: {
+          ...session.notepad !== void 0 ? { notepad: session.notepad } : {},
+          ...session.summary !== void 0 ? { summary: session.summary } : {}
+        }
+      } : {}
     });
     const { mcpForRun, composeSystem, system } = prompt;
     const reviewHead = prompt.reviewHead;
@@ -33886,8 +34564,10 @@ async function dispatch(deps, msg, io, opts = {}) {
       root,
       parentRunId,
       coordinator,
-      seed
+      seed,
+      ...session ? { seedLog: session.log } : {}
     });
+    const sessionTools = sessionCapabilityFor(ledgerRun, deps.runLedger);
     const { spawn: spawn7, runs, steer, wait } = runToolCapabilities(
       { core: deps, dispatch, registry, clock: clock3 },
       {
@@ -33938,6 +34618,7 @@ async function dispatch(deps, msg, io, opts = {}) {
       runs,
       steer,
       wait,
+      ...sessionTools ? { session: sessionTools } : {},
       parentRunId,
       coordinator,
       seed,
@@ -34067,6 +34748,10 @@ var init_dispatcher = __esm({
     init_codingChild();
     init_settle();
     init_lineage();
+    init_seed();
+    init_session();
+    init_thread();
+    init_select();
     init_spawn();
     init_runsService();
     init_runRegistry();
@@ -34183,7 +34868,7 @@ var init_runHistoryWriter = __esm({
 
 // ../../src/core/runStore.ts
 import { chmodSync as chmodSync2, existsSync as existsSync12, mkdirSync as mkdirSync8, readFileSync as readFileSync14, renameSync as renameSync2, rmSync as rmSync3, statSync as statSync2, writeFileSync as writeFileSync7 } from "node:fs";
-import { join as join12, resolve as resolve9 } from "node:path";
+import { join as join11, resolve as resolve9 } from "node:path";
 function isValidRunId(id) {
   return typeof id === "string" && RUN_ID_PATTERN.test(id);
 }
@@ -34231,7 +34916,7 @@ function buildRunStore(cfg, secrets, deps) {
   const now = deps.now ?? Date.now;
   const policy = retentionPolicyOf(cfg);
   if (cfg.store === "file") {
-    const store = new FileRunStore(join12(deps.dataDir, RUNS_DIR), { policy, now });
+    const store = new FileRunStore(join11(deps.dataDir, RUNS_DIR), { policy, now });
     store.sweep();
     const timer = (deps.setInterval ?? setInterval)(() => store.sweep(), SWEEP_INTERVAL_MS);
     timer.unref?.();
@@ -34298,7 +34983,7 @@ var init_runStore = __esm({
         this.now = opts.now ?? Date.now;
       }
       recordPath(id) {
-        return join12(this.dir, `${id}.json`);
+        return join11(this.dir, `${id}.json`);
       }
       ensureDir() {
         mkdirSync8(this.dir, { recursive: true, mode: DIR_MODE });
@@ -34320,7 +35005,7 @@ var init_runStore = __esm({
       }
       /** Every valid index line, a repeated id resolved to its last line. */
       readIndex() {
-        const path = join12(this.dir, INDEX_FILE);
+        const path = join11(this.dir, INDEX_FILE);
         if (!existsSync12(path)) return [];
         const byId = /* @__PURE__ */ new Map();
         for (const line3 of readFileSync14(path, "utf8").split("\n")) {
@@ -34352,7 +35037,7 @@ var init_runStore = __esm({
         const keptIds = new Set(kept.map((r) => r.id));
         for (const item of index) if (!keptIds.has(item.id)) rmSync3(this.recordPath(item.id), { force: true });
         this.writeAtomic(
-          join12(this.dir, INDEX_FILE),
+          join11(this.dir, INDEX_FILE),
           kept.map((r) => JSON.stringify(r)).join("\n") + (kept.length ? "\n" : "")
         );
         return kept;
@@ -34468,24 +35153,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({
@@ -34538,7 +35205,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,
@@ -34592,7 +35267,10 @@ function createLedgerWriteThrough(opts) {
     /** The run's place in its session log (session-log item 2); undefined for
      *  a run without a conversation of its own and for an adopted row claimed
      *  before the log existed. */
-    session;
+    sessionRow;
+    get session() {
+      return this.sessionRow;
+    }
     /** Turns of the run's conversation on the ledger, counted from its seed —
      *  the last step record's `turnIndex` — so the finish can close the range. */
     turnsWritten;
@@ -34630,11 +35308,11 @@ function createLedgerWriteThrough(opts) {
       this.stepNo = from.stepNo;
       this.lastSeq = from.lastSeq;
       this.adopted = from.resumable === true;
-      this.session = from.session;
+      this.sessionRow = from.session;
     }
     /** A reservation learns its session when the prompt's claim promotes it. */
     bindSession(session) {
-      this.session = session;
+      this.sessionRow = session;
     }
     get resumable() {
       return !this.detached && (this.seeded || this.adopted);
@@ -34647,11 +35325,11 @@ function createLedgerWriteThrough(opts) {
      *  ends short of what the model saw, and the next run in the session must
      *  know. A run that wrote no turn leaves the range open. */
     sessionOnRecord() {
-      if (!this.session) return void 0;
-      if (this.broken) return { ...this.session, range: "broken" };
-      const from = this.session.range === "broken" ? this.session.seedFrom : this.session.range.from;
-      const to = this.turnsWritten !== void 0 && this.turnsWritten > 0 ? this.session.seedFrom + this.turnsWritten - 1 : void 0;
-      return { ...this.session, range: to !== void 0 && to >= from ? { from, to } : { from } };
+      if (!this.sessionRow) return void 0;
+      if (this.broken) return { ...this.sessionRow, range: "broken" };
+      const from = this.sessionRow.range === "broken" ? this.sessionRow.seedFrom : this.sessionRow.range.from;
+      const to = this.turnsWritten !== void 0 && this.turnsWritten > 0 ? this.sessionRow.seedFrom + this.turnsWritten - 1 : void 0;
+      return { ...this.sessionRow, range: to !== void 0 && to >= from ? { from, to } : { from } };
     }
     sink = {
       put: async (plain4) => {
@@ -34698,10 +35376,11 @@ function createLedgerWriteThrough(opts) {
      *  no record at all was killed before its conversation was stored and
      *  closes `interrupted`. */
     async seed(messages, budgetMs) {
-      const base = this.session?.seedFrom ?? 0;
-      const turns = messages.map((message2, i) => ({ idx: base + i, message: message2 }));
+      const base = this.sessionRow?.seedFrom ?? 0;
+      const reused = this.sessionRow && this.sessionRow.range !== "broken" ? this.sessionRow.range.from - this.sessionRow.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);
+        const seeded = await ledger.seed(this.runId, gen, turns, this.sessionRow?.key);
         if (!seeded.ok) {
           this.detach(`seed refused (${seeded.reason})`);
           return;
@@ -34721,7 +35400,7 @@ function createLedgerWriteThrough(opts) {
             iteration: 0
           },
           [],
-          this.session?.key
+          this.sessionRow?.key
         );
         if (!recorded.ok) this.detach(`seed record refused (${recorded.reason})`);
         else this.seeded = true;
@@ -34731,7 +35410,7 @@ function createLedgerWriteThrough(opts) {
     }
     async step(report2) {
       if (this.detached) return;
-      const base = this.session?.seedFrom ?? 0;
+      const base = this.sessionRow?.seedFrom ?? 0;
       const turns = report2.turns.map((message2, i) => ({ idx: base + report2.firstIdx + i, message: message2 }));
       if (report2.compaction)
         turns.push({ idx: base + report2.firstIdx + report2.turns.length, compaction: report2.compaction });
@@ -34747,7 +35426,7 @@ function createLedgerWriteThrough(opts) {
       };
       for (let attempt = 1; ; attempt++) {
         try {
-          const result = await ledger.step(this.runId, gen, record2, turns, this.session?.key);
+          const result = await ledger.step(this.runId, gen, record2, turns, this.sessionRow?.key);
           if (!result.ok) this.detach(`step ${record2.step} refused (${result.reason})`);
           else this.turnsWritten = record2.turnIndex;
           return;
@@ -34869,7 +35548,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;
@@ -34883,7 +35562,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;
@@ -34932,6 +35611,11 @@ function createLedgerWriteThrough(opts) {
         return [];
       }
     },
+    readSessionTail: (key, maxBytes) => ledger.readSessionTail(key, maxBytes),
+    readSession: (key, from, to) => ledger.readSession(key, from, to),
+    searchSession: (key, query, limit) => ledger.searchSession(key, query, limit),
+    readNotepad: (key) => ledger.readNotepad(key),
+    writeNotepad: (key, text) => ledger.writeNotepad(key, gen, text),
     async handoff() {
       const candidates = [...live].filter((r) => r.resumable && r.tracked() && !r.handedOff);
       if (candidates.length === 0) return { marked: [] };
@@ -34982,6 +35666,21 @@ var init_writeThrough = __esm({
       async readInbox(_runId, _afterSeq) {
         return [];
       }
+      async readSessionTail(_key, _maxBytes) {
+        return { from: 0, transcript: { complete: true, turns: 0, messages: [], compactions: [] } };
+      }
+      async readSession(_key, _from, _to) {
+        return { complete: true, turns: 0, messages: [], compactions: [] };
+      }
+      async searchSession(_key, _query, _limit) {
+        return { hits: [], gaps: [] };
+      }
+      async readNotepad(_key) {
+        return null;
+      }
+      async writeNotepad(_key, _text) {
+        return { ok: false, reason: "unknown-run" };
+      }
       async handoff() {
         return { marked: [] };
       }
@@ -34995,6 +35694,7 @@ var init_writeThrough = __esm({
       sink;
       resumable = false;
       handedOff = false;
+      session = void 0;
       tracked() {
         return false;
       }
@@ -35474,7 +36174,10 @@ function httpMcpClientFactory(fetchImpl) {
   return (server) => new StreamableHttpMcpClient({
     url: server.url,
     fetch: fetchImpl,
-    ...server.auth?.type === "bearer" ? { headers: { authorization: `Bearer ${server.auth.token}` } } : {}
+    headers: {
+      ...server.headers,
+      ...server.auth?.type === "bearer" ? { authorization: `Bearer ${server.auth.token}` } : {}
+    }
   });
 }
 var init_mcp2 = __esm({
@@ -36895,7 +37598,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 = [];
@@ -36922,11 +37626,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 {
         }
@@ -38302,18 +39006,18 @@ var init_liveView = __esm({
 
 // ../../src/channels/webAssets.ts
 import { readdirSync as readdirSync3, readFileSync as readFileSync16, statSync as statSync3 } from "node:fs";
-import { join as join13 } from "node:path";
+import { join as join12 } from "node:path";
 function contentTypeFor2(path) {
   const dot = path.lastIndexOf(".");
   return (dot === -1 ? void 0 : CONTENT_TYPES[path.slice(dot)]) ?? "application/octet-stream";
 }
 function webDistDir(env, packageRoot) {
-  return env.SWITCHBOARD_WEB_DIST ?? join13(packageRoot, WEB_DIST_DIR);
+  return env.SWITCHBOARD_WEB_DIST ?? join12(packageRoot, WEB_DIST_DIR);
 }
 function loadWebAssets(distDir) {
   let manifest;
   try {
-    manifest = JSON.parse(readFileSync16(join13(distDir, ".vite", "manifest.json"), "utf8"));
+    manifest = JSON.parse(readFileSync16(join12(distDir, ".vite", "manifest.json"), "utf8"));
   } catch (err2) {
     throw new Error(
       `web app manifest not found under ${distDir} \u2014 build it first (npm run build in web/): ${err2 instanceof Error ? err2.message : String(err2)}`,
@@ -38327,9 +39031,9 @@ function loadWebAssets(distDir) {
     css: (entryChunk.css ?? []).map((f) => `/${f}`)
   };
   const files = /* @__PURE__ */ new Map();
-  const assetsDir = join13(distDir, "assets");
+  const assetsDir = join12(distDir, "assets");
   for (const name of readdirSync3(assetsDir)) {
-    const full = join13(assetsDir, name);
+    const full = join12(assetsDir, name);
     if (statSync3(full).isFile()) files.set(`/assets/${name}`, readFileSync16(full));
   }
   const serve2 = (req, res) => {
@@ -39519,6 +40223,25 @@ var init_runLedgerWorker = __esm({
           )
         };
       }
+      async searchSession(key, query, limit) {
+        this.checkSessionKey(key);
+        const r = await this.post("/runs/session/search", { key, query, limit });
+        return {
+          hits: Array.isArray(r.data.hits) ? r.data.hits : [],
+          gaps: Array.isArray(r.data.gaps) ? r.data.gaps : []
+        };
+      }
+      async readNotepad(key) {
+        this.checkSessionKey(key);
+        const r = await this.post("/runs/session/notepad", { key });
+        const n2 = r.data.notepad;
+        return n2 && typeof n2.text === "string" && typeof n2.updatedAt === "number" ? { text: n2.text, updatedAt: n2.updatedAt } : null;
+      }
+      async writeNotepad(key, gen, text) {
+        this.checkSessionKey(key);
+        if (!GEN_PATTERN.test(gen)) throw new PermanentStoreError(`run ledger: malformed generation`);
+        return this.fenceResult(await this.post("/runs/session/notepad/write", { key, gen, text }));
+      }
       async heartbeat(runId3, gen, leaseMs) {
         this.checkIds(runId3, gen);
         const r = await this.post("/runs/heartbeat", { storeKey: this.opts.storeKey, runId: runId3, gen, leaseMs });
@@ -42376,7 +43099,7 @@ __export(index_exports, {
   runBot: () => runBot
 });
 import { createServer } from "node:http";
-import { join as join14 } from "node:path";
+import { join as join13 } from "node:path";
 async function runBot() {
   for (const v of ["SLACK_BOT_TOKEN", "SLACK_APP_TOKEN"]) {
     if (!processSecrets.get(v)) {
@@ -43054,7 +43777,7 @@ var init_index = __esm({
     init_secrets2();
     DATA_DIR = installationPath(OPERATOR_ROOT, "data");
     CONFIG_PATH2 = process.env.SWITCHBOARD_CONFIG ?? installationPath(OPERATOR_ROOT, "config/config.yaml");
-    OVERRIDES_PATH = process.env.SWITCHBOARD_OVERRIDES ?? join14(DATA_DIR, "overrides.json");
+    OVERRIDES_PATH = process.env.SWITCHBOARD_OVERRIDES ?? join13(DATA_DIR, "overrides.json");
     PROCESS_STARTED_AT = systemClock();
     sampleProcessMetrics = startProcessMetrics();
     INTERRUPTED_WRITE_BUDGET_MS = 1e4;
@@ -43101,7 +43824,7 @@ init_secrets2();
 import { Console } from "node:console";
 import { existsSync as existsSync14, mkdtempSync, writeFileSync as writeFileSync9 } from "node:fs";
 import { tmpdir } from "node:os";
-import { basename as basename3, join as join15 } from "node:path";
+import { basename as basename3, join as join14 } from "node:path";
 var CONFIG_PATH3 = process.env.SWITCHBOARD_CONFIG ?? installationPath(OPERATOR_ROOT, "config/config.yaml");
 var DATA_DIR2 = installationPath(OPERATOR_ROOT, "data");
 var CLI_CALLER = { kind: "cli", id: CLI_ACTOR.id, actor: CLI_ACTOR };
@@ -43275,8 +43998,8 @@ var ConsoleIO = class _ConsoleIO {
   /** The harness's file upload: the bytes written under the attachments dir,
    *  the lead printed like a reply with the path a person can open. */
   async attachFile(file) {
-    this.attachments.dir ??= mkdtempSync(join15(tmpdir(), "switchboard-attachments-"));
-    const path = join15(this.attachments.dir, basename3(file.name));
+    this.attachments.dir ??= mkdtempSync(join14(tmpdir(), "switchboard-attachments-"));
+    const path = join14(this.attachments.dir, basename3(file.name));
     writeFileSync9(path, file.bytes);
     await this.reply(`${file.lead}
 \u{1F4CE} ${file.name} (${file.bytes.byteLength} bytes) \u2192 ${path}`);
@@ -43357,7 +44080,7 @@ function cliCapabilities(configPath, env, secrets, opts = {}) {
 }
 function wireCli() {
   const warn = (m) => console.error(m);
-  const botConfig = bindBotConfig(CONFIG_PATH3, join15(DATA_DIR2, "cli-overrides.json"));
+  const botConfig = bindBotConfig(CONFIG_PATH3, join14(DATA_DIR2, "cli-overrides.json"));
   let loaded;
   const bot = () => loaded ??= botConfig().then((config) => ({
     config,