@oxagen/cli 2.1.4-383 → 2.1.4-391

package/oxagen.mjs

@@ -4767,7 +4767,8 @@ var init_envelope = __esm({
       "daemon_down",
       "http_hook_failed",
       "otel_missing",
-      "spool_overflow"
+      "spool_overflow",
+      "wal_ceiling"
     ];
     INCIDENT_KINDS = [
       "unobserved_session",
@@ -7375,8 +7376,8 @@ function candidatePaths(path2, context) {
     const base2 = fold(lib.normalize(root)).replace(/\/+$/, "");
     return resolved.startsWith(`${base2}/`) ? resolved.slice(base2.length + 1) : void 0;
   };
-  const relative8 = cwd !== void 0 ? under(cwd) : void 0;
-  if (relative8 !== void 0) out.push(relative8);
+  const relative9 = cwd !== void 0 ? under(cwd) : void 0;
+  if (relative9 !== void 0) out.push(relative9);
   const fromHome = home !== void 0 ? under(home) : void 0;
   if (fromHome !== void 0) out.push(`~/${fromHome}`);
   return out;
@@ -15346,7 +15347,7 @@ import { readFileSync as readFileSync10 } from "node:fs";
 import { dirname as dirname7, resolve as resolve2 } from "node:path";
 import { fileURLToPath } from "node:url";
 function readVersion() {
-  if (true) return "2.1.4-383";
+  if (true) return "2.1.4-391";
   try {
     const here = dirname7(fileURLToPath(import.meta.url));
     const pkg = JSON.parse(
@@ -16982,6 +16983,7 @@ import {
   appendFileSync as appendFileSync2,
   closeSync as closeSync6,
   fdatasyncSync,
+  fstatSync,
   fsyncSync as fsyncSync3,
   openSync as openSync6,
   existsSync as existsSync12,
@@ -16999,7 +17001,10 @@ function activityAt(event) {
   const at = Date.parse(event.ts);
   return Number.isFinite(at) ? at : Number.NEGATIVE_INFINITY;
 }
-var BODY_READ_SLICE, EVENT_TAIL_WINDOW, WalRecoveryConflict, Wal;
+function sizeOf(path2) {
+  return statSync7(path2, { throwIfNoEntry: false })?.size ?? 0;
+}
+var BODY_READ_SLICE, BODY_DROP_SLICE_BYTES, BODY_DROP_SCANS, NEWLINE, EVENT_TAIL_WINDOW, WalRecoveryConflict, Wal;
 var init_wal = __esm({
   "../../packages/tacho/src/host/wal.ts"() {
     "use strict";
@@ -17007,6 +17012,9 @@ var init_wal = __esm({
     init_fs();
     init_wal_index();
     BODY_READ_SLICE = 32;
+    BODY_DROP_SLICE_BYTES = 1024 * 1024;
+    BODY_DROP_SCANS = 3;
+    NEWLINE = 10;
     EVENT_TAIL_WINDOW = 16 * 1024;
     WalRecoveryConflict = class extends Error {
       constructor(sessionUuid2, seq) {
@@ -17616,10 +17624,12 @@ ${lines.join("\n")}
        * returns, and `bodiesOfSession` reports `body_index_unusable` only when
        * that read also finds its index disagreeing with the file. Reaching this
        * takes a file rewritten in place, at the same size, while each awaited
-       * build ran, which the daemon never does, since its rewrites go through a
-       * temp file and a rename. Shipping those events without bodies instead
-       * marked them shipped and lost the stored content for good, and a one-off
-       * stall on a path that needs outside tampering costs less than that.
+       * build ran. The daemon's sweeps rewrite through a temp file and a rename.
+       * `dropBodiesAsync` does write in place, but only the shipper calls it,
+       * after this read has returned, and the shipper runs one drain at a time.
+       * Shipping those events without bodies instead marked them shipped and lost
+       * the stored content for good, and a one-off stall on a path that needs
+       * outside tampering costs less than that.
        */
       async bodiesForAsync(events) {
         const found = /* @__PURE__ */ new Map();
@@ -17734,16 +17744,13 @@ ${lines.join("\n")}
        * here. A body file with a second writer would need a tombstone instead,
        * because a read-filter-rename loses a line appended between the read and
        * the rename.
+       *
+       * This reads the whole body file on the synchronous path. The shipper
+       * calls `dropBodiesAsync`, which uses this only as its last resort.
        */
       dropBodies(events) {
-        const wanted = /* @__PURE__ */ new Map();
-        for (const event of events) {
-          const idems = wanted.get(event.session_uuid) ?? /* @__PURE__ */ new Set();
-          idems.add(event.event_id_idem);
-          wanted.set(event.session_uuid, idems);
-        }
         let dropped = 0;
-        for (const [session, idems] of wanted) {
+        for (const [session, idems] of _Wal.idemsBySession(events)) {
           dropped += this.rewriteBodies(
             session,
             (stored) => stored !== void 0 && !idems.has(stored.event_id_idem)
@@ -17751,6 +17758,170 @@ ${lines.join("\n")}
         }
         return dropped;
       }
+      /**
+       * Delete the stored bytes of these events' bodies without holding the
+       * daemon's thread on a large file (ADR-231), and report how many lines
+       * went. The shipper calls this when a proven mandate withdraws a body from
+       * its batch.
+       *
+       * `dropBodies` reads the whole body file and rewrites it on the synchronous
+       * path, and a long session's file holds gigabytes. This finds the withdrawn
+       * lines with a scan that awaits every read. Then it overwrites each line in
+       * place with spaces, a slice at a time, with a turn of the event loop
+       * between slices. Every reader skips a line of spaces, so the body reads as
+       * gone. The file keeps its size until `compact` removes it, and no copy of
+       * it is written to a disk that may be nearly full.
+       *
+       * The scan's offsets can be stale by the time a slice runs. Hooks append
+       * between the scan's reads, a failed append is cut back, and a narrowing
+       * sweep can rewrite the file. So a slice reads each line again, in the same
+       * synchronous stretch as the write, and overwrites it only when it is still
+       * one whole stored body for one of these events. A line that is not is left
+       * alone, and the session is scanned again. After `BODY_DROP_SCANS` scans
+       * that each found a line out of place, the rest goes through `dropBodies`
+       * on the synchronous path. Reaching that takes a rewrite of the file during
+       * every scan.
+       *
+       * The scan finds every copy of a body, as `dropBodies` does. It does not
+       * remove a torn line, which `dropBodies` does: a line still being appended
+       * can look torn to an awaited read. `purgeBodiesOutsideMandate` removes torn
+       * lines on a narrowing.
+       */
+      async dropBodiesAsync(events) {
+        let dropped = 0;
+        for (const [session, idems] of _Wal.idemsBySession(events)) {
+          let settled2 = false;
+          for (let scan = 0; scan < BODY_DROP_SCANS && !settled2; scan += 1) {
+            const pass2 = await this.blankBodies(session, idems);
+            dropped += pass2.blanked;
+            settled2 = !pass2.moved;
+          }
+          if (!settled2)
+            dropped += this.dropBodies(
+              events.filter((event) => event.session_uuid === session)
+            );
+        }
+        return dropped;
+      }
+      /**
+       * One scan of `dropBodiesAsync` over one session: find every line that
+       * holds one of these bodies, then overwrite each line that still does.
+       * `moved` says a line the scan found held something else by the time its
+       * slice ran.
+       */
+      async blankBodies(session, idems) {
+        const path2 = this.bodyFileFor(session);
+        if (!existsSync12(path2)) return { blanked: 0, moved: false };
+        const found = [];
+        try {
+          for await (const line of readLinesFromAsync(path2)) {
+            if (!line.terminated) continue;
+            const stored = parseStoredBody(line.text);
+            if (stored !== void 0 && idems.has(stored.event_id_idem))
+              found.push({
+                offset: line.offset,
+                length: line.end - line.offset - 1
+              });
+          }
+        } catch (error) {
+          if (error.code === "ENOENT")
+            return { blanked: 0, moved: false };
+          throw error;
+        }
+        let blanked = 0;
+        let moved = false;
+        for (let next = 0; next < found.length; ) {
+          if (next > 0) await new Promise((resolve19) => setImmediate(resolve19));
+          const slice = this.blankSlice(path2, found, next, idems);
+          if (slice === void 0) break;
+          blanked += slice.blanked;
+          moved ||= slice.moved;
+          next = slice.next;
+        }
+        if (blanked > 0) this.bodyIndexes.invalidate(session);
+        return { blanked, moved };
+      }
+      /**
+       * One synchronous stretch of `blankBodies`: from `from`, overwrite each
+       * found line that still holds one of these bodies, until the slice has
+       * taken `BODY_DROP_SLICE_BYTES`. Nothing else can touch the file while it
+       * runs. Answers undefined when the file is gone.
+       */
+      blankSlice(path2, found, from, idems) {
+        let fd2;
+        try {
+          fd2 = openSync6(path2, "r+");
+        } catch (error) {
+          if (error.code === "ENOENT") return void 0;
+          throw error;
+        }
+        let blanked = 0;
+        let moved = false;
+        let next = from;
+        try {
+          const size = fstatSync(fd2).size;
+          let taken = 0;
+          while (next < found.length && taken < BODY_DROP_SLICE_BYTES) {
+            const at = found[next];
+            next += 1;
+            taken += at.length;
+            if (!_Wal.holdsBodyOf(fd2, size, at, idems)) {
+              moved = true;
+              continue;
+            }
+            _Wal.overwriteWithSpaces(fd2, at);
+            blanked += 1;
+          }
+          if (blanked > 0) fdatasyncSync(fd2);
+        } finally {
+          closeSync6(fd2);
+        }
+        return { blanked, moved, next };
+      }
+      /**
+       * Whether the bytes at `at` are still one whole stored body for one of
+       * `idems`: the start of the file or a newline before them, a newline right
+       * after them, and a line between that parses and names one of the events.
+       * Costs a read of that one line.
+       */
+      static holdsBodyOf(fd2, size, at, idems) {
+        const start = at.offset === 0 ? 0 : at.offset - 1;
+        const end = at.offset + at.length + 1;
+        if (at.length <= 0 || end > size) return false;
+        const buffer = Buffer.allocUnsafe(end - start);
+        let filled = 0;
+        while (filled < buffer.length) {
+          const read2 = readSync3(
+            fd2,
+            buffer,
+            filled,
+            buffer.length - filled,
+            start + filled
+          );
+          if (read2 <= 0) return false;
+          filled += read2;
+        }
+        if (at.offset > 0 && buffer[0] !== NEWLINE) return false;
+        if (buffer[buffer.length - 1] !== NEWLINE) return false;
+        const stored = parseStoredBody(
+          buffer.subarray(at.offset - start, buffer.length - 1).toString("utf8")
+        );
+        return stored !== void 0 && idems.has(stored.event_id_idem);
+      }
+      /** Overwrite the bytes at `at` with spaces, leaving its newline. */
+      static overwriteWithSpaces(fd2, at) {
+        const spaces = Buffer.alloc(Math.min(at.length, 64 * 1024), " ");
+        let written = 0;
+        while (written < at.length) {
+          written += writeSync4(
+            fd2,
+            spaces,
+            0,
+            Math.min(spaces.length, at.length - written),
+            at.offset + written
+          );
+        }
+      }
       /** Sessions that have a body file, whether or not they have an event file. */
       sessionsWithBodies() {
         const suffix = ".bodies.jsonl";
@@ -18134,20 +18305,75 @@ ${lines.join("\n")}
           ...oldest !== void 0 ? { oldestUnshippedAt: oldest } : {}
         };
       }
+      /**
+       * Every session with an event past its shipped cursor, and the bytes its
+       * files hold.
+       *
+       * The WAL ceiling asks for this once a minute (ADR-261). It costs two `stat`
+       * calls per session, plus the tail read `lastSeqOf` already keeps, so it
+       * reads no event or body. The byte counts are whole files, shipped lines
+       * included, because nothing this cheap says where a session's unshipped
+       * bodies start.
+       */
+      holdings() {
+        const out = [];
+        for (const session of this.sessions()) {
+          const last = this.lastSeqOf(session);
+          const through = this.shippedThrough(session);
+          if (last <= through) continue;
+          out.push({
+            sessionUuid: session,
+            shippedThrough: through,
+            lastSeq: last,
+            eventBytes: sizeOf(this.fileFor(session)),
+            bodyBytes: sizeOf(this.bodyFileFor(session)),
+            lastActivityAt: this.lastActivity.get(session) ?? Number.NEGATIVE_INFINITY
+          });
+        }
+        return out;
+      }
+      /**
+       * Remove one session's body file and its index, and answer how many bytes
+       * went. Only the WAL ceiling calls this (ADR-261).
+       *
+       * The file is removed, not rewritten. `rewriteBodies` reads every line on
+       * the daemon's only thread, and a session over the ceiling can hold
+       * gigabytes, which ADR-231 rules out. The event file stays, so the chain
+       * still verifies. Each event whose body went ships without it, and the
+       * control plane records a `body_missing` gap for it.
+       *
+       * What each reader sees afterwards:
+       *
+       * - `bodiesFor` finds no file, so a batch read after this ships its events
+       *   with no bodies. A batch already read keeps the bodies it holds.
+       * - An index build running for the session sees the generation move, and
+       *   keeps nothing.
+       * - `appendRecovered` finds no stored body, so a journaled terminal batch
+       *   writes its own few bodies again.
+       * - The session's next `append` starts a new body file.
+       *
+       * A removal that fails is reported, answers 0, and the next check tries
+       * again. On Windows that happens while another reader holds the file open.
+       */
+      dropSessionBodies(sessionUuid2) {
+        const bytes = sizeOf(this.bodyFileFor(sessionUuid2));
+        if (bytes === 0) return 0;
+        return this.removeBodies(sessionUuid2) ? bytes : 0;
+      }
       /**
        * Erase every stored body whose class `retention` does not cover, in every
        * session this host holds, and answer how many were erased.
        *
-       * Why this exists beside `dropBodies`. `dropBodies` reaches the bodies of
-       * the events in a drain's batch, which is every body the shipper still has
-       * an unshipped event for. Two kinds of body sit outside that reach: one
-       * whose event already shipped, since `markShipped` advanced the cursor past
-       * it, and one in a session the drain is not looking at. `compact` frees
-       * those only once their session is sealed, fully shipped, and older than
-       * the retention window, so a session that never seals kept them for as long
-       * as the host ran, or for ever on a host that never came back. This sweep
-       * walks every session and every stored line, so a narrowing reaches all of
-       * them.
+       * Why this exists beside `dropBodiesAsync`. The shipper's drop reaches the
+       * bodies of the events in a drain's batch, which is every body the shipper
+       * still has an unshipped event for. Two kinds of body sit outside that
+       * reach: one whose event already shipped, since `markShipped` advanced the
+       * cursor past it, and one in a session the drain is not looking at.
+       * `compact` frees those only once their session is sealed, fully shipped,
+       * and older than the retention window, so a session that never seals kept
+       * them for as long as the host ran, or for ever on a host that never came
+       * back. This sweep walks every session and every stored line, so a
+       * narrowing reaches all of them.
        *
        * The write is the one in `rewriteBodies`, which `dropBodies` uses as well:
        * atomic, and safe because these files have one writer. The module header
@@ -18682,6 +18908,252 @@ var init_policy_mode = __esm({
   }
 });
 
+// ../../packages/tacho/src/host/wal-ceiling.ts
+import { statfsSync } from "node:fs";
+import { join as join16 } from "node:path";
+function freeBytesOn(dir) {
+  try {
+    const stats2 = statfsSync(dir);
+    return stats2.bavail * stats2.bsize;
+  } catch {
+    return void 0;
+  }
+}
+function isCount(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0;
+}
+function isClock(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const clock = value;
+  const since = clock["since"];
+  return Number.isSafeInteger(clock["shipped_through"]) && typeof since === "string" && Number.isFinite(Date.parse(since));
+}
+function clocksFrom(value) {
+  const clocks = {};
+  if (typeof value !== "object" || value === null || Array.isArray(value))
+    return clocks;
+  for (const [session, clock] of Object.entries(value))
+    if (isClock(clock))
+      clocks[session] = {
+        shipped_through: clock.shipped_through,
+        since: clock.since
+      };
+  return clocks;
+}
+function sameClocks(a, b5) {
+  const keys = Object.keys(a);
+  if (keys.length !== Object.keys(b5).length) return false;
+  return keys.every((session) => {
+    const other = b5[session];
+    const clock = a[session];
+    return other !== void 0 && clock !== void 0 && other.shipped_through === clock.shipped_through && other.since === clock.since;
+  });
+}
+function isDrop(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const drop = value;
+  return typeof drop["session_uuid"] === "string" && isCount(drop["bytes"]) && typeof drop["shipped_through"] === "number" && typeof drop["last_seq"] === "number" && typeof drop["stalled_since"] === "string" && typeof drop["dropped_at"] === "string" && isCount(drop["stalled_bytes"]) && isCount(drop["ceiling_bytes"]);
+}
+function readWalCeilingState(walDir) {
+  let raw;
+  try {
+    raw = readJsonFileIfExists(join16(walDir, STATE_FILE));
+  } catch {
+    return void 0;
+  }
+  if (typeof raw !== "object" || raw === null) return void 0;
+  const state = raw;
+  const checkedAt = state["checked_at"];
+  const ceilingBytes = state["ceiling_bytes"];
+  const stallGraceMs = state["stall_grace_ms"];
+  const stalledBytes = state["stalled_bytes"];
+  const stalledSessions = state["stalled_sessions"];
+  const drops = state["drops"];
+  if (state["schema"] !== STATE_SCHEMA || typeof checkedAt !== "string" || !isCount(ceilingBytes) || !isCount(stallGraceMs) || !isCount(stalledBytes) || !isCount(stalledSessions) || !Array.isArray(drops))
+    return void 0;
+  return {
+    schema: STATE_SCHEMA,
+    checked_at: checkedAt,
+    ceiling_bytes: ceilingBytes,
+    stall_grace_ms: stallGraceMs,
+    stalled_bytes: stalledBytes,
+    stalled_sessions: stalledSessions,
+    drops: drops.filter(isDrop),
+    stall_clocks: clocksFrom(state["stall_clocks"])
+  };
+}
+function ceilingFor(fixed, free, stalled) {
+  if (free === void 0 || !Number.isFinite(free)) return fixed;
+  return Math.min(fixed, Math.floor((free + stalled) / 2));
+}
+var DEFAULT_WAL_CEILING, STATE_FILE, STATE_SCHEMA, DROPS_KEPT, WalCeiling;
+var init_wal_ceiling = __esm({
+  "../../packages/tacho/src/host/wal-ceiling.ts"() {
+    "use strict";
+    init_fs();
+    DEFAULT_WAL_CEILING = {
+      ceilingBytes: 8 * 1024 ** 3,
+      stallGraceMs: 60 * 6e4,
+      checkEveryMs: 6e4,
+      freeBytes: freeBytesOn
+    };
+    STATE_FILE = "ceiling.json";
+    STATE_SCHEMA = "tacho.wal-ceiling.v1";
+    DROPS_KEPT = 20;
+    WalCeiling = class {
+      constructor(wal, walDir, policy, keepDropsMs, log) {
+        this.wal = wal;
+        this.walDir = walDir;
+        this.policy = policy;
+        this.keepDropsMs = keepDropsMs;
+        this.log = log;
+        this.state = readWalCeilingState(walDir);
+        for (const [session, clock] of Object.entries(
+          this.state?.stall_clocks ?? {}
+        ))
+          this.progress.set(session, {
+            through: clock.shipped_through,
+            since: Date.parse(clock.since)
+          });
+      }
+      wal;
+      walDir;
+      policy;
+      keepDropsMs;
+      log;
+      /**
+       * Each waiting session's shipped cursor as the last check saw it, and when
+       * it was first seen there.
+       *
+       * A clock whose cursor stood still between two checks is also written to
+       * `ceiling.json`, and the constructor reads it back, so a restarted daemon
+       * resumes the clock. A daemon that restarted more often than `stallGraceMs`
+       * used to start every clock again each time, and never dropped anything.
+       * A clock first seen by the last check before a restart is not written yet,
+       * so a restart costs it at most one `checkEveryMs`.
+       */
+      progress = /* @__PURE__ */ new Map();
+      state;
+      /** Set when the last write of `ceiling.json` failed, so the next check writes. */
+      unsaved = false;
+      lastCheckAt = Number.NEGATIVE_INFINITY;
+      /** Whether a check is due at `now`. */
+      due(now) {
+        return now - this.lastCheckAt >= this.policy.checkEveryMs;
+      }
+      /**
+       * One check, and the drops it made.
+       *
+       * `onDrop` runs right after each body file goes, in the same synchronous
+       * stretch, so the daemon seals the frame that records the drop before
+       * anything else runs. A frame that fails does not bring the bodies back:
+       * the drop stands, and the daemon logs the failure.
+       */
+      check(now, onDrop) {
+        this.lastCheckAt = now;
+        const holdings = this.wal.holdings();
+        const waiting = /* @__PURE__ */ new Set();
+        const clocks = {};
+        for (const holding of holdings) {
+          waiting.add(holding.sessionUuid);
+          const known = this.progress.get(holding.sessionUuid);
+          if (known === void 0 || known.through !== holding.shippedThrough) {
+            this.progress.set(holding.sessionUuid, {
+              through: holding.shippedThrough,
+              since: now
+            });
+            continue;
+          }
+          clocks[holding.sessionUuid] = {
+            shipped_through: known.through,
+            since: new Date(known.since).toISOString()
+          };
+        }
+        for (const session of [...this.progress.keys()])
+          if (!waiting.has(session)) this.progress.delete(session);
+        const stalled = holdings.map((holding) => ({
+          holding,
+          since: this.progress.get(holding.sessionUuid)?.since ?? now
+        })).filter((entry2) => now - entry2.since >= this.policy.stallGraceMs);
+        let held = 0;
+        for (const { holding } of stalled)
+          held += holding.eventBytes + holding.bodyBytes;
+        const ceiling = ceilingFor(
+          this.policy.ceilingBytes,
+          this.policy.freeBytes(this.walDir),
+          held
+        );
+        const drops = [];
+        if (held > ceiling) {
+          stalled.sort(
+            (a, b5) => a.since - b5.since || a.holding.lastActivityAt - b5.holding.lastActivityAt || (a.holding.sessionUuid < b5.holding.sessionUuid ? -1 : 1)
+          );
+          for (const { holding, since } of stalled) {
+            if (held <= ceiling) break;
+            if (holding.bodyBytes === 0) continue;
+            const bytes = this.wal.dropSessionBodies(holding.sessionUuid);
+            if (bytes === 0) continue;
+            const drop = {
+              session_uuid: holding.sessionUuid,
+              bytes,
+              shipped_through: holding.shippedThrough,
+              last_seq: holding.lastSeq,
+              stalled_since: new Date(since).toISOString(),
+              dropped_at: new Date(now).toISOString(),
+              stalled_bytes: held,
+              ceiling_bytes: ceiling
+            };
+            held -= bytes;
+            drops.push(drop);
+            try {
+              onDrop(drop);
+            } catch {
+            }
+          }
+        }
+        this.remember(now, ceiling, held, stalled.length, drops, clocks);
+        return drops;
+      }
+      /**
+       * Write what this check saw to `ceiling.json`, when it says something the
+       * file does not. A host where no cursor stood still between two checks,
+       * and nothing was dropped, writes no file at all.
+       */
+      remember(now, ceiling, held, stalledSessions, drops, clocks) {
+        const prior = this.state;
+        const kept = [...prior?.drops ?? [], ...drops].filter((drop) => now - Date.parse(drop.dropped_at) < this.keepDropsMs).slice(-DROPS_KEPT);
+        if (prior === void 0 && stalledSessions === 0 && kept.length === 0 && Object.keys(clocks).length === 0)
+          return;
+        const next = {
+          schema: STATE_SCHEMA,
+          checked_at: new Date(now).toISOString(),
+          ceiling_bytes: ceiling,
+          stall_grace_ms: this.policy.stallGraceMs,
+          stalled_bytes: held,
+          stalled_sessions: stalledSessions,
+          drops: kept,
+          stall_clocks: clocks
+        };
+        const changed = this.unsaved || prior === void 0 || prior.stalled_sessions !== next.stalled_sessions || prior.drops.length !== next.drops.length || prior.drops.at(-1)?.dropped_at !== next.drops.at(-1)?.dropped_at || !sameClocks(prior.stall_clocks, next.stall_clocks) || next.stalled_sessions > 0 && (prior.stalled_bytes !== next.stalled_bytes || prior.ceiling_bytes !== next.ceiling_bytes);
+        this.state = next;
+        if (!changed) return;
+        try {
+          writeSensitiveFileAtomic(
+            join16(this.walDir, STATE_FILE),
+            JSON.stringify(next)
+          );
+          this.unsaved = false;
+        } catch (error) {
+          this.unsaved = true;
+          this.log(
+            `WAL ceiling: could not write ${STATE_FILE}: ${error instanceof Error ? error.message : String(error)}`
+          );
+        }
+      }
+    };
+  }
+});
+
 // ../../packages/tacho/src/cli/status.ts
 import { existsSync as existsSync14 } from "node:fs";
 import { dirname as dirname10 } from "node:path";
@@ -18828,6 +19300,7 @@ async function agentStatus(deps) {
     host.host_enrollment_id
   ) : void 0;
   const walStats = new Wal(deps.paths.wal).stats();
+  const ceilingState = readWalCeilingState(deps.paths.wal);
   const gateway = gatewayOf(daemon);
   const routedHarnesses = host.harnesses.filter(isBrokerableHarness);
   const baseUrlHarnesses = host.harnesses.filter(isModelRoutedHarness);
@@ -18924,12 +19397,49 @@ async function agentStatus(deps) {
     wal: {
       sessions: walStats.sessions,
       unshipped: walStats.unshipped,
-      ...walStats.oldestUnshippedAt !== void 0 ? { oldest_unshipped_at: walStats.oldestUnshippedAt } : {}
+      ...walStats.oldestUnshippedAt !== void 0 ? { oldest_unshipped_at: walStats.oldestUnshippedAt } : {},
+      ...ceilingState !== void 0 ? {
+        ceiling: {
+          checked_at: ceilingState.checked_at,
+          ceiling_bytes: ceilingState.ceiling_bytes,
+          stall_grace_ms: ceilingState.stall_grace_ms,
+          stalled_bytes: ceilingState.stalled_bytes,
+          stalled_sessions: ceilingState.stalled_sessions,
+          drops: ceilingState.drops
+        }
+      } : {}
     },
     ...shipping !== void 0 ? { shipping } : {}
   };
   return report;
 }
+function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes} bytes`;
+  if (bytes < 1024 ** 2) return `${(bytes / 1024).toFixed(1)} KiB`;
+  if (bytes < 1024 ** 3) return `${(bytes / 1024 ** 2).toFixed(1)} MiB`;
+  return `${(bytes / 1024 ** 3).toFixed(1)} GiB`;
+}
+function ceilingLines(ceiling) {
+  const lines = [];
+  if (ceiling.stalled_sessions > 0) {
+    const minutes = Math.round(ceiling.stall_grace_ms / 6e4);
+    const one = ceiling.stalled_sessions === 1;
+    const who = `${ceiling.stalled_sessions} session${one ? " has" : "s have"} shipped nothing for at least ${minutes} minute${minutes === 1 ? "" : "s"} and ${one ? "holds" : "hold"} ${formatBytes(ceiling.stalled_bytes)}`;
+    lines.push(
+      ceiling.stalled_bytes > ceiling.ceiling_bytes ? `Ceiling     OVER: ${who}, more than the ${formatBytes(ceiling.ceiling_bytes)} ceiling` : `Ceiling     ${who} of the ${formatBytes(ceiling.ceiling_bytes)} ceiling`
+    );
+  }
+  const newestFirst = [...ceiling.drops].reverse();
+  for (const drop of newestFirst.slice(0, CEILING_DROPS_SHOWN))
+    lines.push(
+      `Dropped     session ${drop.session_uuid} went over the WAL ceiling at ${drop.dropped_at}: ${formatBytes(drop.bytes)} of stored content removed, events ${drop.shipped_through + 1} to ${drop.last_seq} ship without it`
+    );
+  if (newestFirst.length > CEILING_DROPS_SHOWN)
+    lines.push(
+      `            ${newestFirst.length - CEILING_DROPS_SHOWN} earlier drop${newestFirst.length - CEILING_DROPS_SHOWN === 1 ? "" : "s"} in \`oxagen agent status --json\``
+    );
+  return lines;
+}
 function printStatus(report, deps) {
   const h = report.host;
   if (h === void 0) {
@@ -19061,12 +19571,14 @@ function printStatus(report, deps) {
   deps.out(
     `WAL         ${wal.sessions} session files, ${wal.unshipped} events unshipped${wal.oldest_unshipped_at !== void 0 ? ` (oldest ${wal.oldest_unshipped_at})` : ""}`
   );
+  if (wal.ceiling !== void 0)
+    for (const line of ceilingLines(wal.ceiling)) deps.out(line);
   if (shipping !== void 0)
     deps.out(
       `Shipping    ${shipping.healthy ? "ok" : "FAILING"}: ${shipping.detail}`
     );
 }
-var SHIPPING_STALL_MS, TIER_RANK;
+var SHIPPING_STALL_MS, TIER_RANK, CEILING_DROPS_SHOWN;
 var init_status = __esm({
   "../../packages/tacho/src/cli/status.ts"() {
     "use strict";
@@ -19078,6 +19590,7 @@ var init_status = __esm({
     init_settings_writer();
     init_stella_writer();
     init_wal();
+    init_wal_ceiling();
     init_agents();
     init_wire();
     init_deps();
@@ -19086,6 +19599,7 @@ var init_status = __esm({
     init_policy_mode();
     SHIPPING_STALL_MS = 10 * 6e4;
     TIER_RANK = { observe: 0, harness: 1, gateway: 2 };
+    CEILING_DROPS_SHOWN = 5;
   }
 });
 
@@ -19864,8 +20378,8 @@ function harnessFileProblems(harnesses, deps) {
   if (harnesses.includes("codex"))
     check2(deps.paths.codexHooks, deps.readCodexHooks, hooksShapeProblem);
   if (harnesses.includes("cursor")) {
-    const relative8 = absoluteHookCommandProblem(deps.runtime.hookCommand);
-    if (relative8 !== void 0) problems.push(relative8);
+    const relative9 = absoluteHookCommandProblem(deps.runtime.hookCommand);
+    if (relative9 !== void 0) problems.push(relative9);
     for (const path2 of deps.paths.cursorHooks)
       check2(path2, () => deps.readCursorHooks(path2), cursorHooksShapeProblem);
   }
@@ -22342,6 +22856,13 @@ function steeringContext(body2) {
     tokens: clampU32(assembly.tokens + delivered)
   };
 }
+function steeringFactsOf(steering) {
+  if (steering === void 0) return {};
+  return {
+    steering_tokens: steering.tokens,
+    steering_tokens_basis: "estimated"
+  };
+}
 var REQUEST_FULL_DIGEST_ATTR, SYSTEM_CONTEXT_PARTS_OMITTED_ATTR, MEMORY_REQUESTS, LISTED_PER_TURN, U32_MAX, NAME_MAX, tokenSourceFacts, SystemContextMemory, SHARED_SYSTEM_CONTEXT_MEMORY, CONVERSATION_FIELDS2, STEERING_ASSEMBLY_PART, SystemContextTracker;
 var init_system_context = __esm({
   "../../packages/tacho/src/claude-code/system-context.ts"() {
@@ -22435,20 +22956,16 @@ var init_system_context = __esm({
        * the frame's attrs, and `turn` a key that changes when the turn does.
        */
       measure(content, attrs2, turn) {
-        const facts = {};
-        const steering = this.steering;
-        if (steering !== void 0) {
-          facts.steering_tokens = steering.tokens;
-          facts.steering_tokens_basis = "estimated";
-        }
         const recorded = requestOf(content);
         const resolved = recorded === void 0 ? void 0 : resolveRequest(recorded.request, this.memory);
         if (recorded === void 0 || resolved === void 0)
-          return this.checked(facts, {}, () => {
+          return this.checked(steeringFactsOf(this.steering), {}, () => {
           });
         const fullDigest = attrs2?.[REQUEST_FULL_DIGEST_ATTR];
         const key = isSha256Digest(fullDigest) ? fullDigest : recorded.request[PRIOR_MEMBER] === void 0 ? digestBytes(recorded.text) : void 0;
         if (key !== void 0) this.memory.set(key, resolved);
+        const steering = resolved.tools.length > 0 ? this.steering : void 0;
+        const facts = steeringFactsOf(steering);
         const parts = [
           ...resolved.system,
           ...resolved.instructions,
@@ -22478,6 +22995,19 @@ var init_system_context = __esm({
           if (this.listed.length > LISTED_PER_TURN) this.listed.shift();
         });
       }
+      /**
+       * The token sources of a model call whose request the recorder never saw:
+       * the counted OTel or transcript row of a call the proxy did not carry
+       * (#4493). Only the steering count is known without the request. The tool
+       * definition count, the context frame count, and the system context stay
+       * absent, never zero. Nothing changes on the tracker, so there is nothing
+       * to commit. The caller asks only for a call that carries the session's
+       * conversation, since a side call carries no steering.
+       */
+      measureUnseen() {
+        return this.checked(steeringFactsOf(this.steering), {}, () => {
+        }).facts;
+      }
       /**
        * Hand back facts the envelope accepts, or none. A body the envelope
        * refuses loses its frame, so a measurement that fails the schema is
@@ -23841,6 +24371,10 @@ var init_transcript = __esm({
 });
 
 // ../../packages/tacho/src/claude-code/recorder.ts
+function onSessionConversation(querySource) {
+  if (querySource === void 0) return false;
+  return MAIN_CONVERSATION_QUERY_SOURCES.has(querySource) || querySource.startsWith("repl_main_thread:");
+}
 function compact(value) {
   const out = {};
   for (const [key, member2] of Object.entries(value)) {
@@ -23917,7 +24451,7 @@ function inChainOrder(events) {
   }
   return out;
 }
-var NO_SIGHTING, PROMPT_DUPLICATE_OF_ATTR, AFTER_STOP_ATTR, SUBAGENT_TYPE_AMBIGUOUS_ATTR, SessionRecorder;
+var NO_SIGHTING, MAIN_CONVERSATION_QUERY_SOURCES, PROMPT_DUPLICATE_OF_ATTR, AFTER_STOP_ATTR, SUBAGENT_TYPE_AMBIGUOUS_ATTR, SessionRecorder;
 var init_recorder = __esm({
   "../../packages/tacho/src/claude-code/recorder.ts"() {
     "use strict";
@@ -23938,6 +24472,10 @@ var init_recorder = __esm({
     init_transcript();
     NO_SIGHTING = { attrs: {}, commit: () => {
     } };
+    MAIN_CONVERSATION_QUERY_SOURCES = /* @__PURE__ */ new Set([
+      "repl_main_thread",
+      "sdk"
+    ]);
     PROMPT_DUPLICATE_OF_ATTR = "oxagen.prompt_duplicate_of";
     AFTER_STOP_ATTR = "oxagen.after_stop";
     SUBAGENT_TYPE_AMBIGUOUS_ATTR = "oxagen.subagent_type_ambiguous";
@@ -24740,6 +25278,24 @@ var init_recorder = __esm({
           return { attrs: { [LLM_CALL_DUPLICATE_OF_ATTR]: verdict.of }, commit };
         return { attrs: {}, commit };
       }
+      /**
+       * The body of an OTel or transcript model call, with the token sources the
+       * recorder knows without the call's request (#4493). Only the counted row,
+       * the first sighting of its call, takes them. A stamped duplicate is never
+       * summed, and the rollup joins a stamped proxy row back for the members the
+       * counted row lacks. The steering count is the one source known without
+       * the request, so the tool definitions and the system context stay absent
+       * (ADR-062, amendment of 2026-10-02). A member the producer set itself
+       * wins, as on a proxied call. Only a call on the session's own
+       * conversation comes here: an OTel record whose `query_source` says so
+       * ({@link onSessionConversation}), or a transcript `assistant` record,
+       * since Claude Code writes no side call to the transcript.
+       */
+      withUnseenRequestSources(body2, attrs2) {
+        if (attrs2[LLM_CALL_DUPLICATE_OF_ATTR] !== void 0) return body2;
+        const facts = this.systemContext.measureUnseen();
+        return Object.keys(facts).length === 0 ? body2 : { ...facts, ...body2 };
+      }
       /**
        * The attrs a `tool_call` carries, or undefined when the chain already
        * holds this call and the row must not be sealed at all.
@@ -25149,7 +25705,7 @@ var init_recorder = __esm({
         }
         const event = this.seal(
           draft.kind,
-          draft.body,
+          draft.kind === "llm_call" && draft.source === "otel_log" && onSessionConversation(draft.standard.context.query_source) ? this.withUnseenRequestSources(draft.body, duplicate) : draft.body,
           {
             ts: draft.ts,
             source: draft.source,
@@ -25205,6 +25761,8 @@ var init_recorder = __esm({
             body2 = withoutUsage(body2);
             duplicate = { [LLM_CALL_DUPLICATE_OF_ATTR]: "transcript" };
           }
+          if (draft.kind === "llm_call")
+            body2 = this.withUnseenRequestSources(body2, duplicate);
           let content = draft.content;
           if (this.isSealedPrompt(draft.kind, body2)) {
             content = void 0;
@@ -26598,25 +27156,19 @@ async function runContained(command2, deps) {
     return 1;
   }
   const token = deps.env[CONTAINED_GITHUB_TOKEN_ENV];
-  const repository = command2.githubRepository ?? (token !== void 0 ? deps.env["GITHUB_REPOSITORY"] : void 0);
-  if (repository !== void 0 && (token === void 0 || token.length === 0)) {
+  if (token !== void 0 && token.length > 0) {
     deps.err(
-      `--github-repository needs an installation token for it in ${CONTAINED_GITHUB_TOKEN_ENV}.`
-    );
-    return 2;
-  }
-  if (token !== void 0 && token.length > 0 && repository === void 0) {
-    deps.err(
-      `${CONTAINED_GITHUB_TOKEN_ENV} is set; name its one repository with --github-repository owner/name.`
+      `${CONTAINED_GITHUB_TOKEN_ENV} is no longer read. A contained run reaches GitHub through Oxagen's Git custody, which gets a token from the workspace's GitHub App for each request. Remove the variable and the step that mints it, and bind the repository to the workspace.`
     );
     return 2;
   }
+  const repository = command2.githubRepository;
   const body2 = JSON.stringify({
     workspace: command2.workspace ?? deps.cwd,
     harness,
     args: command2.args,
     image,
-    ...repository !== void 0 && token !== void 0 ? { github: { repository, token } } : {}
+    ...repository !== void 0 ? { github: { repository } } : {}
   });
   let exitCode;
   let failure2;
@@ -26936,11 +27488,11 @@ var init_move_commands = __esm({
 
 // ../../packages/tacho/src/host/work-orders.ts
 import { readdirSync as readdirSync9, rmSync as rmSync4 } from "node:fs";
-import { join as join16 } from "node:path";
+import { join as join17 } from "node:path";
 function orderFile(paths, id) {
   if (!WORK_ORDER_ID_PATTERN.test(id))
     throw new Error(`${JSON.stringify(id)} is not a work order id`);
-  return join16(paths.workOrders, `${id}.json`);
+  return join17(paths.workOrders, `${id}.json`);
 }
 function readWorkOrder(paths, id) {
   let raw;
@@ -30756,135 +31308,27 @@ var init_configuration = __esm({
 });
 
 // ../../packages/tacho/src/contained/github.ts
-import {
-  request as httpRequest
-} from "node:http";
-import { request as httpsRequest } from "node:https";
-async function verifyRunGitHubToken(grant, fetch2, upstreams = GITHUB_UPSTREAMS) {
-  const response = await fetch2(
-    `${upstreams.api}/installation/repositories?per_page=2`,
-    {
-      method: "GET",
-      headers: { ...API_HEADERS, authorization: `Bearer ${grant.token}` },
-      signal: AbortSignal.timeout(15e3)
-    }
-  );
-  if (!response.ok)
-    throw new Error(
-      `GitHub refused the run's installation token (${response.status}); mint a new one for this run`
-    );
-  const body2 = JSON.parse(await response.text());
-  const only = body2.repositories?.[0]?.full_name;
-  if (body2.total_count !== 1 || only === void 0 || only.toLowerCase() !== grant.repository.toLowerCase())
-    throw new Error(
-      `The run's GitHub token must reach ${grant.repository} and no other repository; mint it with repositories: [${grant.repository.split("/")[1]}]`
-    );
-}
-async function revokeRunGitHubToken(token, fetch2, upstreams = GITHUB_UPSTREAMS) {
-  const response = await fetch2(`${upstreams.api}/installation/token`, {
-    method: "DELETE",
-    headers: { ...API_HEADERS, authorization: `Bearer ${token}` },
-    signal: AbortSignal.timeout(15e3)
-  });
-  if (response.status === 204) return "revoked";
-  if (response.status === 401) return "already_invalid";
-  throw new Error(`GitHub did not revoke the run's token (${response.status})`);
-}
-function gitHubTarget(path2, repository, upstreams = GITHUB_UPSTREAMS) {
-  const wanted = repository.toLowerCase();
+function custodyGitPath(path2, repository) {
   const git6 = GIT_ROUTE.exec(path2);
-  if (git6) {
-    const [, owner, name, rest] = git6;
-    const repo = name.replace(/\.git$/, "");
-    if (`${owner}/${repo}`.toLowerCase() !== wanted) return void 0;
-    return {
-      kind: "git",
-      url: `${upstreams.git}/${owner}/${repo}.git/${rest}`
-    };
-  }
-  const api = API_ROUTE.exec(path2);
-  if (api) {
-    const [, owner, name, rest = "", query = ""] = api;
-    if (`${owner}/${name}`.toLowerCase() !== wanted) return void 0;
-    if (rest.split("/").some((segment) => segment === "." || segment === ".."))
-      return void 0;
-    return {
-      kind: "api",
-      url: `${upstreams.api}/repos/${owner}/${name}${rest}${query}`
-    };
-  }
-  return void 0;
-}
-function forwardToGitHub(target2, token, incoming, outgoing) {
-  const url = new URL(target2.url);
-  const headers = {
-    "user-agent": "oxagen-contained-launcher",
-    authorization: target2.kind === "git" ? `Basic ${Buffer.from(`x-access-token:${token}`).toString("base64")}` : `Bearer ${token}`
-  };
-  for (const name of FORWARDED) {
-    const value = incoming.headers[name];
-    if (typeof value === "string") headers[name] = value;
-  }
-  const send4 = url.protocol === "https:" ? httpsRequest : httpRequest;
-  const upstream = send4(
-    url,
-    { method: incoming.method, headers, timeout: 12e4 },
-    (response) => {
-      const passed = {};
-      for (const [name, value] of Object.entries(response.headers)) {
-        if (value === void 0) continue;
-        if (name === "set-cookie" || name === "connection") continue;
-        passed[name] = value;
-      }
-      outgoing.writeHead(response.statusCode ?? 502, passed);
-      response.pipe(outgoing);
-    }
-  );
-  upstream.on("timeout", () => upstream.destroy(new Error("GitHub timed out")));
-  upstream.on("error", () => {
-    if (!outgoing.headersSent) {
-      outgoing.writeHead(502, { "content-type": "application/json" });
-      outgoing.end(JSON.stringify({ error: "GitHub could not be reached" }));
-    } else outgoing.destroy();
-  });
-  outgoing.on("close", () => upstream.destroy());
-  incoming.pipe(upstream);
+  if (!git6) return void 0;
+  const [, owner, name, rest] = git6;
+  const repo = name.replace(/\.git$/, "");
+  if (`${owner}/${repo}`.toLowerCase() !== repository.toLowerCase())
+    return void 0;
+  return `/github/${owner}/${repo}.git/${rest}`;
 }
-var containedGitHubSchema, GITHUB_UPSTREAMS, API_HEADERS, SEGMENT, GIT_ROUTE, API_ROUTE, FORWARDED;
+var containedGitHubSchema, SEGMENT, GIT_ROUTE;
 var init_github2 = __esm({
   "../../packages/tacho/src/contained/github.ts"() {
     "use strict";
     init_zod();
     containedGitHubSchema = external_exports.object({
-      repository: external_exports.string().regex(/^[A-Za-z0-9](?:[A-Za-z0-9-]{0,38})\/[A-Za-z0-9._-]{1,100}$/).refine((value) => !/\/\.\.?$/.test(value), "Invalid repository name"),
-      /** Installation access tokens carry the `ghs_` prefix. */
-      token: external_exports.string().regex(/^ghs_[A-Za-z0-9_]{20,255}$/)
+      repository: external_exports.string().regex(/^[A-Za-z0-9](?:[A-Za-z0-9-]{0,38})\/[A-Za-z0-9._-]{1,100}$/).refine((value) => !/\/\.\.?$/.test(value), "Invalid repository name")
     }).strict();
-    GITHUB_UPSTREAMS = {
-      api: "https://api.github.com",
-      git: "https://github.com"
-    };
-    API_HEADERS = {
-      accept: "application/vnd.github+json",
-      "x-github-api-version": "2022-11-28",
-      "user-agent": "oxagen-contained-launcher"
-    };
     SEGMENT = "[A-Za-z0-9_-][A-Za-z0-9._-]*";
     GIT_ROUTE = new RegExp(
       `^/github/git/(${SEGMENT})/(${SEGMENT})/(info/refs\\?service=git-(?:upload|receive)-pack|git-upload-pack|git-receive-pack)$`
     );
-    API_ROUTE = new RegExp(
-      `^/github/api/repos/(${SEGMENT})/(${SEGMENT})((?:/${SEGMENT})*)(\\?[A-Za-z0-9_.,=&%+-]*)?$`
-    );
-    FORWARDED = [
-      "accept",
-      "accept-encoding",
-      "content-type",
-      "content-length",
-      "content-encoding",
-      "git-protocol",
-      "x-github-api-version"
-    ];
   }
 });
 
@@ -30962,17 +31406,38 @@ function containedBridgeHandler(options) {
         );
         return;
       }
-      if (options.github && path2.startsWith("/github/")) {
-        const target2 = gitHubTarget(
-          path2,
-          options.github.repository,
-          options.githubUpstreams
-        );
-        if (target2) {
-          options.forwarded?.(request3.method ?? "GET", path2);
-          forwardToGitHub(target2, options.github.token, request3, response);
+      const github = options.github;
+      const target2 = github === void 0 ? void 0 : custodyGitPath(path2, github.repository);
+      if (github !== void 0 && target2 !== void 0) {
+        const lease = github.lease();
+        const body2 = lease.body;
+        const token = lease.status === 200 ? body2?.token : void 0;
+        if (typeof token !== "string") {
+          options.githubRefused?.(path2);
+          response.writeHead(403, {
+            "content-type": "text/plain",
+            "cache-control": "no-store"
+          });
+          response.end(
+            `Oxagen issued no GitHub credential for this run. ${typeof body2?.error === "string" ? body2.error : "Check the session and the host's enrollment."}`
+          );
           return;
         }
+        try {
+          const headers = {
+            authorization: `Basic ${Buffer.from(`oxagen:${token}`).toString("base64")}`
+          };
+          for (const name of GIT_HEADERS) {
+            const value = request3.headers[name];
+            if (typeof value === "string") headers[name] = value;
+          }
+          request3.headers = headers;
+          request3.url = target2;
+          await github.handle(request3, response);
+        } finally {
+          github.release(token);
+        }
+        return;
       }
       options.refused(path2);
       send(response, 403, {
@@ -31010,16 +31475,23 @@ async function startContainedBridge(options) {
     }
   };
 }
+var GIT_HEADERS;
 var init_bridge = __esm({
   "../../packages/tacho/src/contained/bridge.ts"() {
     "use strict";
     init_github2();
+    GIT_HEADERS = [
+      "content-type",
+      "content-encoding",
+      "git-protocol",
+      "user-agent"
+    ];
   }
 });
 
 // ../../packages/tacho/src/contained/workspace.ts
 import { lstatSync as lstatSync5, readFileSync as readFileSync14, readdirSync as readdirSync10, realpathSync as realpathSync2 } from "node:fs";
-import { isAbsolute, join as join17, relative, resolve as resolve6 } from "node:path";
+import { isAbsolute, join as join18, relative, resolve as resolve6 } from "node:path";
 function within(root, path2) {
   const rel = relative(root, path2);
   return rel === "" || !rel.startsWith("..") && !isAbsolute(rel);
@@ -31050,7 +31522,7 @@ function validateContainedWorkspace(workspace, sessionDirectory, mountInfo = rea
         throw new Error(
           "Remove local credential files from the contained checkout before launch"
         );
-      const path2 = join17(directory, entry2);
+      const path2 = join18(directory, entry2);
       const stat5 = lstatSync5(path2);
       if (stat5.isSymbolicLink()) {
         let target2;
@@ -31204,7 +31676,7 @@ import {
   writeFileSync as writeFileSync2
 } from "node:fs";
 import { tmpdir } from "node:os";
-import { isAbsolute as isAbsolute2, join as join18, relative as relative2 } from "node:path";
+import { isAbsolute as isAbsolute2, join as join19, relative as relative2 } from "node:path";
 import { promisify } from "node:util";
 async function launchContainedAgent(options) {
   validateContainedArguments(options.request.harness, options.request.args);
@@ -31237,7 +31709,7 @@ async function launchContainedAgent(options) {
   if (digest6 === void 0)
     throw new Error("The operator's contained image is not installed");
   const sessionId = `contained-${randomBytes8(16).toString("hex")}`;
-  const directory = mkdtempSync(join18(tmpdir(), "oxagen-contained-"));
+  const directory = mkdtempSync(join19(tmpdir(), "oxagen-contained-"));
   chmodSync6(directory, 448);
   let prepared;
   let containerCreated = false;
@@ -31258,7 +31730,7 @@ async function launchContainedAgent(options) {
     for (const [name2, contents] of entries2) {
       if (!/^[a-z0-9.-]+$/.test(name2))
         throw new Error("Invalid contained configuration filename");
-      writeFileSync2(join18(directory, name2), contents, {
+      writeFileSync2(join19(directory, name2), contents, {
         mode: 256,
         flag: "wx"
       });
@@ -31337,7 +31809,7 @@ var init_launcher = __esm({
 });
 
 // ../../packages/tacho/src/contained/runner.ts
-import { join as join19 } from "node:path";
+import { join as join20 } from "node:path";
 function containedLaunchEndpoint(host) {
   const ingest = new URL(host.endpoints.ingest);
   if (!ingest.pathname.endsWith("/tacho/events"))
@@ -31348,211 +31820,214 @@ function containedLaunchEndpoint(host) {
 }
 function createContainedRunner(options) {
   const launched = /* @__PURE__ */ new Set();
+  const repositories = /* @__PURE__ */ new Map();
   const active2 = /* @__PURE__ */ new Map();
   return {
     launched: (harnessSessionId) => launched.has(harnessSessionId),
+    githubRepository: (harnessSessionId) => repositories.get(harnessSessionId),
     stop: (uuid) => active2.get(uuid)?.abort(),
     stopAll: () => {
       for (const controller of active2.values()) controller.abort();
     },
     run: async (raw, output, signal) => {
       const input = containedRunRequestSchema.parse(raw);
+      const host = options.host();
+      if (host.host_status !== "active" || host.revoked_at !== null || Date.parse(host.expires_at) <= Date.now())
+        throw new Error("This enrollment cannot start a contained run");
+      if (!host.gateway_api_key)
+        throw new Error(
+          "Re-enroll this runner to obtain a daemon gateway credential"
+        );
+      const credential = options.issueCredential(input.harness);
+      if (credential.status !== 200)
+        throw new Error(
+          "The daemon must hold this harness's model credential before containment can start"
+        );
+      const repository = input.github?.repository;
+      const controller = new AbortController();
+      const abort = () => controller.abort();
+      signal?.addEventListener("abort", abort, { once: true });
+      if (signal?.aborted) abort();
+      let sessionUuid2;
+      let launchedSessionId;
+      const session = (id) => {
+        const found = options.registry.get(id);
+        if (!found) throw new Error("Contained session was not recorded");
+        return found;
+      };
       try {
-        const host = options.host();
-        if (host.host_status !== "active" || host.revoked_at !== null || Date.parse(host.expires_at) <= Date.now())
-          throw new Error("This enrollment cannot start a contained run");
-        if (!host.gateway_api_key)
-          throw new Error(
-            "Re-enroll this runner to obtain a daemon gateway credential"
-          );
-        const credential = options.issueCredential(input.harness);
-        if (credential.status !== 200)
-          throw new Error(
-            "The daemon must hold this harness's model credential before containment can start"
-          );
-        if (input.github)
-          await verifyRunGitHubToken(input.github, options.fetch);
-        const controller = new AbortController();
-        const abort = () => controller.abort();
-        signal?.addEventListener("abort", abort, { once: true });
-        if (signal?.aborted) abort();
-        let sessionUuid2;
-        let launchedSessionId;
-        const session = (id) => {
-          const found = options.registry.get(id);
-          if (!found) throw new Error("Contained session was not recorded");
-          return found;
-        };
-        try {
-          return await launchContainedAgent({
-            image: input.image,
-            request: input,
-            output,
-            signal: controller.signal,
-            prepare: async ({ sessionId, directory, workspace }) => {
-              launched.add(sessionId);
-              launchedSessionId = sessionId;
-              await options.hook({
-                harness: input.harness,
-                payload: {
-                  hook_event_name: "SessionStart",
-                  session_id: sessionId,
-                  cwd: workspace,
-                  source: "startup"
-                }
-              });
-              const started = session(sessionId);
-              sessionUuid2 = started.recorder.sessionUuid;
-              active2.set(sessionUuid2, controller);
-              const gateway = createMcpGateway({
-                attribution: () => {
-                  const current = options.host();
-                  if (current.host_status !== "active" || !current.gateway_api_key)
-                    return void 0;
-                  return {
-                    organizationId: current.organization_id,
-                    workspaceId: current.workspace_id,
-                    orgSlug: current.org_slug,
-                    workspaceSlug: current.workspace_slug,
-                    apiKey: current.gateway_api_key,
-                    hostEnrollmentId: current.host_enrollment_id,
-                    chainSessionUuid: started.recorder.sessionUuid,
-                    chainGenesisHash: options.genesis(
-                      started.recorder.sessionUuid
-                    )
-                  };
-                },
-                endpoint: mcpEndpointFor(options.host()),
-                fetch: options.fetch,
-                bundle: () => options.host().bundle,
-                log: options.log,
-                record: (call) => options.record([
-                  started.recorder.sealCollectorEvent("tool_call", {
-                    tool_name: call.toolName,
-                    tool_source: "mcp",
-                    tool_status: call.status,
-                    tool_duration_ms: call.durationMs
-                  })
-                ])
-              });
-              const bridge = await startContainedBridge({
-                socketPath: join19(directory, "bridge.sock"),
+        return await launchContainedAgent({
+          image: input.image,
+          request: input,
+          output,
+          signal: controller.signal,
+          prepare: async ({ sessionId, directory, workspace }) => {
+            launched.add(sessionId);
+            launchedSessionId = sessionId;
+            if (repository !== void 0)
+              repositories.set(sessionId, repository);
+            await options.hook({
+              harness: input.harness,
+              payload: {
+                hook_event_name: "SessionStart",
+                session_id: sessionId,
+                cwd: workspace,
+                source: "startup"
+              }
+            });
+            const started = session(sessionId);
+            sessionUuid2 = started.recorder.sessionUuid;
+            active2.set(sessionUuid2, controller);
+            const gateway = createMcpGateway({
+              attribution: () => {
+                const current = options.host();
+                if (current.host_status !== "active" || !current.gateway_api_key)
+                  return void 0;
+                return {
+                  organizationId: current.organization_id,
+                  workspaceId: current.workspace_id,
+                  orgSlug: current.org_slug,
+                  workspaceSlug: current.workspace_slug,
+                  apiKey: current.gateway_api_key,
+                  hostEnrollmentId: current.host_enrollment_id,
+                  chainSessionUuid: started.recorder.sessionUuid,
+                  chainGenesisHash: options.genesis(
+                    started.recorder.sessionUuid
+                  )
+                };
+              },
+              endpoint: mcpEndpointFor(options.host()),
+              fetch: options.fetch,
+              bundle: () => options.host().bundle,
+              log: options.log,
+              record: (call) => options.record([
+                started.recorder.sealCollectorEvent("tool_call", {
+                  tool_name: call.toolName,
+                  tool_source: "mcp",
+                  tool_status: call.status,
+                  tool_duration_ms: call.durationMs
+                })
+              ])
+            });
+            const bridge = await startContainedBridge({
+              socketPath: join20(directory, "bridge.sock"),
+              sessionId,
+              workspace,
+              harness: input.harness,
+              modelPort: options.modelPort(),
+              issueCredential: () => {
+                const answer = options.issueCredential(input.harness);
+                if (answer.status !== 200)
+                  throw new Error("Credential custody unavailable");
+                return answer.body.token;
+              },
+              model: (request3, response) => options.model.handle(request3, response),
+              hook: options.hook,
+              mcp: (body2) => gateway.handle(body2, {
                 sessionId,
-                workspace,
-                harness: input.harness,
-                modelPort: options.modelPort(),
-                issueCredential: () => {
-                  const answer = options.issueCredential(input.harness);
-                  if (answer.status !== 200)
-                    throw new Error("Credential custody unavailable");
-                  return answer.body.token;
-                },
-                model: (request3, response) => options.model.handle(request3, response),
-                hook: options.hook,
-                mcp: (body2) => gateway.handle(body2, {
-                  sessionId,
-                  enrollmentId: options.host().host_enrollment_id
-                }),
-                ...input.github ? { github: input.github } : {},
-                forwarded: (method, path2) => options.record([
-                  started.recorder.sealCollectorEvent("policy_decision", {
-                    policy_decision: "allow",
-                    policy_source: "bundle",
-                    policy_reason_code: "contained_github_route",
-                    tool_name: `${method} ${path2.split("?")[0] ?? ""}`.slice(
-                      0,
-                      256
-                    )
-                  })
-                ]),
-                refused: (path2) => options.record([
-                  started.recorder.sealCollectorEvent("policy_decision", {
-                    policy_decision: "deny",
-                    policy_source: "bundle",
-                    policy_reason_code: "contained_gateway_route",
-                    tool_name: path2.split("?")[0]?.slice(0, 256) ?? "unknown"
-                  })
-                ])
-              });
-              return {
-                files: containedConfiguration(
-                  input.harness,
-                  input.github?.repository
-                ),
-                close: bridge.close
-              };
-            },
-            measured: async (sessionId, measurement) => {
-              const started = session(sessionId);
-              const genesis = options.genesis(started.recorder.sessionUuid);
-              if (!genesis)
-                throw new Error("Contained session has no recorded genesis");
-              const current = options.host();
-              const response = await options.fetch(
-                containedLaunchEndpoint(current),
-                {
-                  method: "POST",
-                  headers: {
-                    authorization: `Bearer ${current.gateway_api_key}`,
-                    "content-type": "application/json"
-                  },
-                  body: JSON.stringify({
-                    host_enrollment_id: current.host_enrollment_id,
-                    session_uuid: started.recorder.sessionUuid,
-                    genesis_hash: genesis,
-                    measurement
+                enrollmentId: options.host().host_enrollment_id
+              }),
+              // The lease is keyed by this launcher's own session, never by
+              // a working directory or a port, neither of which the
+              // container shares with the host (ADR-254).
+              ...repository !== void 0 ? {
+                github: {
+                  repository,
+                  lease: () => options.github.issueForSession({
+                    session: started.recorder.sessionUuid,
+                    repository
                   }),
-                  signal: AbortSignal.timeout(3e4)
+                  handle: options.github.handle,
+                  release: options.github.release
                 }
+              } : {},
+              githubRefused: (path2) => options.record([
+                started.recorder.sealCollectorEvent("policy_decision", {
+                  policy_decision: "deny",
+                  policy_source: "kernel",
+                  policy_reason_code: "contained_github_custody",
+                  tool_name: path2.split("?")[0]?.slice(0, 256) ?? "unknown"
+                })
+              ]),
+              refused: (path2) => options.record([
+                started.recorder.sealCollectorEvent("policy_decision", {
+                  policy_decision: "deny",
+                  policy_source: "bundle",
+                  policy_reason_code: "contained_gateway_route",
+                  tool_name: path2.split("?")[0]?.slice(0, 256) ?? "unknown"
+                })
+              ])
+            });
+            return {
+              files: containedConfiguration(input.harness, repository),
+              close: bridge.close
+            };
+          },
+          measured: async (sessionId, measurement) => {
+            const started = session(sessionId);
+            const genesis = options.genesis(started.recorder.sessionUuid);
+            if (!genesis)
+              throw new Error("Contained session has no recorded genesis");
+            const current = options.host();
+            const response = await options.fetch(
+              containedLaunchEndpoint(current),
+              {
+                method: "POST",
+                headers: {
+                  authorization: `Bearer ${current.gateway_api_key}`,
+                  "content-type": "application/json"
+                },
+                body: JSON.stringify({
+                  host_enrollment_id: current.host_enrollment_id,
+                  session_uuid: started.recorder.sessionUuid,
+                  genesis_hash: genesis,
+                  measurement
+                }),
+                signal: AbortSignal.timeout(3e4)
+              }
+            );
+            if (!response.ok)
+              throw new Error(
+                `Contained launch registration failed (${response.status}); the agent was not started`
               );
-              if (!response.ok)
-                throw new Error(
-                  `Contained launch registration failed (${response.status}); the agent was not started`
-                );
-              options.record([
-                started.recorder.sealCollectorEvent(
-                  "policy_decision",
-                  {
-                    policy_decision: "allow",
-                    policy_source: "kernel",
-                    policy_reason_code: "contained_launch_registered"
-                  },
-                  {
-                    attrs: {
-                      "oxagen.containment.profile": measurement.profile,
-                      "oxagen.containment.image": measurement.imageDigest,
-                      "oxagen.containment.configuration": measurement.configurationDigest
-                    }
+            options.record([
+              started.recorder.sealCollectorEvent(
+                "policy_decision",
+                {
+                  policy_decision: "allow",
+                  policy_source: "kernel",
+                  policy_reason_code: "contained_launch_registered"
+                },
+                {
+                  attrs: {
+                    "oxagen.containment.profile": measurement.profile,
+                    "oxagen.containment.image": measurement.imageDigest,
+                    "oxagen.containment.configuration": measurement.configurationDigest
                   }
-                )
-              ]);
-            },
-            sealed: async (sessionId, exitCode) => {
-              await options.hook({
-                harness: input.harness,
-                payload: {
-                  hook_event_name: "SessionEnd",
-                  session_id: sessionId,
-                  cwd: input.workspace,
-                  reason: "other",
-                  exit_code: exitCode
                 }
-              });
-            }
-          });
-        } finally {
-          signal?.removeEventListener("abort", abort);
-          if (sessionUuid2) active2.delete(sessionUuid2);
-          if (launchedSessionId) launched.delete(launchedSessionId);
-        }
+              )
+            ]);
+          },
+          sealed: async (sessionId, exitCode) => {
+            await options.hook({
+              harness: input.harness,
+              payload: {
+                hook_event_name: "SessionEnd",
+                session_id: sessionId,
+                cwd: input.workspace,
+                reason: "other",
+                exit_code: exitCode
+              }
+            });
+          }
+        });
       } finally {
-        if (input.github)
-          await revokeRunGitHubToken(input.github.token, options.fetch).then(
-            (outcome) => options.log(`Contained run GitHub token ${outcome}`),
-            (error) => options.log(
-              `Contained run GitHub token was not revoked: ${error instanceof Error ? error.message : String(error)}`
-            )
-          );
+        signal?.removeEventListener("abort", abort);
+        if (sessionUuid2) active2.delete(sessionUuid2);
+        if (launchedSessionId) {
+          launched.delete(launchedSessionId);
+          repositories.delete(launchedSessionId);
+        }
       }
     }
   };
@@ -31573,7 +32048,10 @@ var init_runner = __esm({
       harness: external_exports.enum(["claude-code", "codex"]),
       args: external_exports.array(external_exports.string().max(65536)).max(128),
       image: external_exports.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9/_.:@-]{0,255}$/),
-      /** Optional: one installation token for one repository (ADR-152). */
+      /**
+       * Optional: the one repository the run may reach, through the daemon's
+       * Git custody (ADR-254). The request carries no token.
+       */
       github: containedGitHubSchema.optional()
     }).strict();
   }
@@ -31581,7 +32059,7 @@ var init_runner = __esm({
 
 // ../../packages/tacho/src/collector/detector.ts
 import { promises as fs } from "node:fs";
-import { basename as basename4, join as join20 } from "node:path";
+import { basename as basename4, join as join21 } from "node:path";
 async function eachLimited(items, limit, task) {
   let next = 0;
   const workers = Array.from(
@@ -31607,7 +32085,7 @@ async function scanProject(dir) {
   await eachLimited(names, SCAN_CONCURRENCY, async (name) => {
     const match = SESSION_FILE.exec(name);
     if (match === null) return;
-    const path2 = join20(dir, name);
+    const path2 = join21(dir, name);
     try {
       const st = await fs.stat(path2);
       out.push({ sessionId: match[1], path: path2, mtimeMs: st.mtimeMs });
@@ -31648,7 +32126,7 @@ var init_detector = __esm({
             continue;
           }
           await eachLimited(names, SCAN_CONCURRENCY, async (name) => {
-            const dir = join20(root, name);
+            const dir = join21(root, name);
             try {
               const st = await fs.stat(dir);
               if (st.isDirectory()) dirs.push({ dir, mtimeMs: st.mtimeMs });
@@ -31874,7 +32352,7 @@ var init_detector = __esm({
                 transcript_path: transcript.path,
                 transcript_mtime: new Date(transcript.mtimeMs).toISOString(),
                 claude_pids: processes.map((p) => p.pid),
-                project: basename4(join20(transcript.path, ".."))
+                project: basename4(join21(transcript.path, ".."))
               }
             })
           );
@@ -32247,7 +32725,7 @@ import {
   rm,
   unlink
 } from "node:fs/promises";
-import { dirname as dirname13, join as join21 } from "node:path";
+import { dirname as dirname13, join as join22 } from "node:path";
 async function statOf(absolutePath) {
   try {
     const info = await lstat(absolutePath);
@@ -32287,7 +32765,7 @@ async function contentHash(absolutePath, kind, keep) {
   if (keep !== void 0) {
     try {
       await mkdir(keep.dir, { recursive: true, mode: 448 });
-      const temp2 = join21(keep.dir, `.partial-${randomUUID3()}`);
+      const temp2 = join22(keep.dir, `.partial-${randomUUID3()}`);
       copy = {
         temp: temp2,
         handle: await open3(temp2, "wx", keep.executable ? 448 : 384)
@@ -32331,7 +32809,7 @@ async function settleCopy(temp, name) {
   if (temp === void 0) return;
   if (name !== void 0)
     try {
-      await rename(temp, join21(dirname13(temp), name));
+      await rename(temp, join22(dirname13(temp), name));
       return;
     } catch {
     }
@@ -32347,7 +32825,7 @@ async function copiedBytes(dir) {
   let total2 = 0;
   for (const name of names) {
     try {
-      total2 += (await lstat(join21(dir, name))).size;
+      total2 += (await lstat(join22(dir, name))).size;
     } catch {
     }
   }
@@ -32363,7 +32841,7 @@ async function removeCopiesOutside(root, live) {
   const keep = new Set(live());
   await Promise.all(
     names.filter((name) => !keep.has(name)).map(
-      (name) => rm(join21(root, name), { recursive: true, force: true }).catch(
+      (name) => rm(join22(root, name), { recursive: true, force: true }).catch(
         () => void 0
       )
     )
@@ -32471,7 +32949,7 @@ async function contributionOf(exec4, cwd, root, repoRelative, entry2, copies) {
   let copy = null;
   if (entry2 !== null) {
     if (copies === void 0 || !COPY_NAME.test(entry2[0])) return void 0;
-    copy = join21(copies, entry2[0]);
+    copy = join22(copies, entry2[0]);
     const kept = await statOf(copy);
     if (kept === void 0 || kept === "absent" || kept.kind !== "file")
       return void 0;
@@ -32799,7 +33277,7 @@ var init_session_changes = __esm({
 
 // ../../packages/tacho/src/collector/worktree-snapshot.ts
 import { lstat as lstat2 } from "node:fs/promises";
-import { join as join22 } from "node:path";
+import { join as join23 } from "node:path";
 function headerPath(prefix, path2) {
   const name = `${prefix}${path2}`;
   let quoted2 = false;
@@ -32874,7 +33352,7 @@ async function worktreeFingerprint(status2, root) {
       const path2 = statusPath(record);
       if (path2 === null) return "";
       try {
-        const info = await lstat2(join22(root, path2));
+        const info = await lstat2(join23(root, path2));
         return `${info.size}:${info.mtimeMs}:${info.ctimeMs}`;
       } catch {
         return "absent";
@@ -32980,7 +33458,7 @@ async function readWorktreeSnapshot(exec4, cwd, baseline, measured) {
       }
       let present;
       try {
-        present = (await lstat2(join22(root, path2))).isFile();
+        present = (await lstat2(join23(root, path2))).isFile();
       } catch {
         present = false;
       }
@@ -33081,10 +33559,10 @@ var init_worktree_snapshot = __esm({
 });
 
 // ../../packages/tacho/src/collector/git-lane.ts
-import { join as join23 } from "node:path";
+import { join as join24 } from "node:path";
 function copiesDirOf(root, session) {
   const uuid = session.recorder.sessionUuid;
-  return /^[0-9a-f-]{36}$/i.test(uuid) ? join23(root, uuid) : void 0;
+  return /^[0-9a-f-]{36}$/i.test(uuid) ? join24(root, uuid) : void 0;
 }
 function holdsBaseline(session) {
   return session.baselineCommit !== void 0 || Object.keys(session.baselines ?? {}).length > 0;
@@ -34227,7 +34705,11 @@ async function gitPushBasis(input, record, deps) {
   if (deps.pushCredentialBasis === void 0)
     return TACHO_CREDENTIAL_HARNESS_HELD;
   try {
-    return await deps.pushCredentialBasis(command2, record.cwd ?? input.cwd);
+    return await deps.pushCredentialBasis(
+      command2,
+      record.cwd ?? input.cwd,
+      record.harnessSessionId
+    );
   } catch {
     return TACHO_CREDENTIAL_HARNESS_HELD;
   }
@@ -35451,15 +35933,41 @@ function createGithubProxy(deps) {
   const fetchUpstream = deps.fetch ?? globalThis.fetch;
   function live(lease) {
     const host = deps.host();
-    if (host.github_broker_enabled !== true || host.host_status !== "active" || !Number.isFinite(Date.parse(host.expires_at)) || Date.parse(host.expires_at) <= deps.now() || lease.expires <= deps.now())
+    if (
+      // `tacho github configure` turns this on for a configured checkout.
+      // A contained run opts in by naming its repository at launch instead.
+      lease.launcher !== true && host.github_broker_enabled !== true || host.host_status !== "active" || !Number.isFinite(Date.parse(host.expires_at)) || Date.parse(host.expires_at) <= deps.now() || lease.expires <= deps.now()
+    )
       return void 0;
     const session = deps.registry.byUuid(lease.session);
-    return session && !session.sealed && !session.pendingTerminal && session.control.paused == null && session.control.cancelled == null && receiptMatches(
+    return session && !session.sealed && !session.pendingTerminal && session.control.paused == null && session.control.cancelled == null && (lease.launcher === true || receiptMatches(
       host,
       lease.repository,
       session.cwd,
       deps.registry.agentOf(session).harness
-    ) ? session : void 0;
+    )) ? session : void 0;
+  }
+  function validRepository(value) {
+    return typeof value === "string" && REPO.test(value) && ![".", ".."].includes(value.split("/")[1] ?? "");
+  }
+  function grant(fields, host) {
+    const token = `oxgit_${randomBytes9(32).toString("base64url")}`;
+    const lease = {
+      ...fields,
+      id: `rt_${randomBytes9(10).toString("hex")}`,
+      repository: fields.repository.toLowerCase(),
+      expires: Math.min(deps.now() + LIFE_MS, Date.parse(host.expires_at))
+    };
+    if (!live(lease))
+      return {
+        status: 403,
+        body: { error: "The session or enrollment is not active" }
+      };
+    leases.set(hash(token), lease);
+    return {
+      status: 200,
+      body: { token, expires_at: new Date(lease.expires).toISOString() }
+    };
   }
   function receiptMatches(host, repository, cwd, harness) {
     return cwd !== void 0 && (host.github_repositories ?? []).some(
@@ -35472,14 +35980,14 @@ function createGithubProxy(deps) {
         status: 400,
         body: { error: "A GitHub lease request must be an object" }
       };
-    for (const [key, lease2] of leases) if (!live(lease2)) leases.delete(key);
+    for (const [key, lease] of leases) if (!live(lease)) leases.delete(key);
     const host = deps.host();
     if (host.github_broker_enabled !== true || host.host_status !== "active")
       return {
         status: 403,
         body: { error: "GitHub custody is not enabled on this host" }
       };
-    if (typeof input.repository !== "string" || !REPO.test(input.repository) || [".", ".."].includes(input.repository.split("/")[1] ?? "") || typeof input.cwd !== "string" || typeof input.harness !== "string" || !isWrappedHarness(input.harness))
+    if (!validRepository(input.repository) || typeof input.cwd !== "string" || typeof input.harness !== "string" || !isWrappedHarness(input.harness))
       return {
         status: 400,
         body: {
@@ -35503,24 +36011,39 @@ function createGithubProxy(deps) {
           error: "GitHub custody needs exactly one live session in this working directory"
         }
       };
-    const session = matches[0];
-    const token = `oxgit_${randomBytes9(32).toString("base64url")}`;
-    const lease = {
-      id: `rt_${randomBytes9(10).toString("hex")}`,
-      repository: input.repository.toLowerCase(),
-      session: session.recorder.sessionUuid,
-      expires: Math.min(deps.now() + LIFE_MS, Date.parse(host.expires_at))
-    };
-    if (!live(lease))
+    return grant(
+      {
+        repository: input.repository,
+        session: matches[0].recorder.sessionUuid
+      },
+      host
+    );
+  }
+  function issueForSession(input) {
+    for (const [key, lease] of leases) if (!live(lease)) leases.delete(key);
+    const host = deps.host();
+    if (host.host_status !== "active")
       return {
         status: 403,
-        body: { error: "The session or enrollment is not active" }
+        body: { error: "This host's enrollment is not active" }
       };
-    leases.set(hash(token), lease);
-    return {
-      status: 200,
-      body: { token, expires_at: new Date(lease.expires).toISOString() }
-    };
+    if (!validRepository(input.repository))
+      return {
+        status: 400,
+        body: { error: "Name the GitHub repository as owner/name" }
+      };
+    if (leases.size >= MAX_LEASES)
+      return {
+        status: 409,
+        body: { error: "Too many GitHub run credentials are open on this host" }
+      };
+    return grant(
+      { repository: input.repository, session: input.session, launcher: true },
+      host
+    );
+  }
+  function release2(token) {
+    leases.delete(hash(token));
   }
   async function handle(req, res) {
     const token = bearer(req);
@@ -35758,7 +36281,7 @@ function createGithubProxy(deps) {
       }
     }
   }
-  return { issue, handle };
+  return { issue, issueForSession, release: release2, handle };
 }
 var LIFE_MS, MAX_LEASES, MAX_REQUEST_BYTES, REPO, MAX_REFUSAL_CHARS, REFUSED;
 var init_github_proxy = __esm({
@@ -35866,7 +36389,7 @@ var init_hook_queues = __esm({
 });
 
 // ../../packages/tacho/src/collector/memory-capture/memory-reader.ts
-import { isAbsolute as isAbsolute5, join as join24, sep as sep2 } from "node:path";
+import { isAbsolute as isAbsolute5, join as join25, sep as sep2 } from "node:path";
 function claudeCodeLocation(projectsDir, memoryDir) {
   return {
     harness: "claude-code",
@@ -35878,13 +36401,13 @@ function claudeCodeLocation(projectsDir, memoryDir) {
 }
 function claudeCodeMemoryLocations(configDir, projectDirs = []) {
   const locations = [
-    claudeCodeLocation(() => join24(configDir, "projects"), "memory"),
-    claudeCodeLocation(() => join24(configDir, "agent-memory"), "")
+    claudeCodeLocation(() => join25(configDir, "projects"), "memory"),
+    claudeCodeLocation(() => join25(configDir, "agent-memory"), "")
   ];
   for (const dir of projectDirs.slice(0, MEMORY_PROJECT_DIRS_MAX))
     locations.push(
-      claudeCodeLocation(() => join24(dir, ".claude", "agent-memory"), ""),
-      claudeCodeLocation(() => join24(dir, ".claude", "agent-memory-local"), "")
+      claudeCodeLocation(() => join25(dir, ".claude", "agent-memory"), ""),
+      claudeCodeLocation(() => join25(dir, ".claude", "agent-memory-local"), "")
     );
   return locations;
 }
@@ -36063,13 +36586,13 @@ function createMemoryReader(deps) {
       const projects = await list(top);
       let complete = projects.complete;
       for (const project2 of projects.names) {
-        const dir = location.memoryDir === "" ? join24(top, project2) : join24(top, project2, location.memoryDir);
+        const dir = location.memoryDir === "" ? join25(top, project2) : join25(top, project2, location.memoryDir);
         const files2 = await list(dir);
         if (!files2.complete) complete = false;
         for (const name of files2.names) {
           if (!name.endsWith(location.extension)) continue;
           if (location.skip.includes(name)) continue;
-          const path2 = join24(dir, name);
+          const path2 = join25(dir, name);
           const file = await readAt2(location.harness, path2);
           if (file.kind === "absent" || file.kind === "empty") continue;
           paths.push(path2);
@@ -36155,8 +36678,8 @@ var init_memory_reader = __esm({
     MEMORY_TYPE_PATTERN = /^[a-z][a-z0-9_-]{0,31}$/;
     MEMORY_PROJECT_DIRS_MAX = 200;
     HARNESS_MEMORY_LOCATIONS = [
-      claudeCodeLocation((home) => join24(home, ".claude", "projects"), "memory"),
-      claudeCodeLocation((home) => join24(home, ".claude", "agent-memory"), "")
+      claudeCodeLocation((home) => join25(home, ".claude", "projects"), "memory"),
+      claudeCodeLocation((home) => join25(home, ".claude", "agent-memory"), "")
     ];
     FRONTMATTER = /^---[ \t]*\r?\n(?:([\s\S]*?)\r?\n)?---[ \t]*(?:\r?\n|$)/;
     FRONTMATTER_LINE = /^([ \t]*)([A-Za-z_][\w-]*)[ \t]*:[ \t]*(.*)$/;
@@ -36635,7 +37158,7 @@ var init_memory_upload = __esm({
 });
 
 // ../../packages/tacho/src/collector/memory-capture/memory-uses.ts
-import { basename as basename5, dirname as dirname15, isAbsolute as isAbsolute6, join as join25, resolve as resolve9 } from "node:path";
+import { basename as basename5, dirname as dirname15, isAbsolute as isAbsolute6, join as join26, resolve as resolve9 } from "node:path";
 function memoryFileOf(path2, locations, home) {
   if (!isAbsolute6(path2)) return void 0;
   const file = resolve9(path2);
@@ -36653,7 +37176,7 @@ function memoryFileOf(path2, locations, home) {
   return void 0;
 }
 function pathOf(word, cwd, home) {
-  const expanded = /^(?:~|\$HOME|\$\{HOME\})\//.test(word) ? join25(home, word.slice(word.indexOf("/") + 1)) : word;
+  const expanded = /^(?:~|\$HOME|\$\{HOME\})\//.test(word) ? join26(home, word.slice(word.indexOf("/") + 1)) : word;
   if (isAbsolute6(expanded)) return expanded;
   if (cwd !== void 0 && isAbsolute6(cwd)) return resolve9(cwd, expanded);
   return void 0;
@@ -36932,7 +37455,7 @@ ${use.path}`;
 
 // ../../packages/tacho/src/collector/memory-capture/stella-store.ts
 import { createRequire as createRequire3 } from "node:module";
-import { dirname as dirname16, isAbsolute as isAbsolute7, join as join26, resolve as resolve10 } from "node:path";
+import { dirname as dirname16, isAbsolute as isAbsolute7, join as join27, resolve as resolve10 } from "node:path";
 function sqlite2() {
   sqliteModule2 ??= createRequire3(import.meta.url)(
     "node:sqlite"
@@ -37035,7 +37558,7 @@ async function stellaStoreOf(dir, exists) {
   if (!isAbsolute7(dir)) return void 0;
   let at = resolve10(dir);
   for (let depth = 0; depth < WORKSPACE_SEARCH_DEPTH; depth += 1) {
-    const candidate = join26(at, STELLA_CONTEXT_DB);
+    const candidate = join27(at, STELLA_CONTEXT_DB);
     if (await exists(candidate)) return candidate;
     const up = dirname16(at);
     if (up === at) return void 0;
@@ -37048,7 +37571,7 @@ var init_stella_store = __esm({
   "../../packages/tacho/src/collector/memory-capture/stella-store.ts"() {
     "use strict";
     init_memory_reader();
-    STELLA_CONTEXT_DB = join26(".stella", "private", "context.db");
+    STELLA_CONTEXT_DB = join27(".stella", "private", "context.db");
     STELLA_MEMORIES_VIEW = "export_memories_v1";
     STELLA_USES_VIEW = "export_memory_uses_v1";
     STELLA_USES_PER_READ = 5e3;
@@ -37627,7 +38150,7 @@ var init_cloud_link = __esm({
 });
 
 // ../../packages/tacho/src/collector/local-servers/digest.ts
-import { join as join27 } from "node:path";
+import { join as join28 } from "node:path";
 function objectOf(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
 }
@@ -37652,7 +38175,7 @@ function npmNameSegment(name) {
   return name.startsWith("@") ? `@${encodeURIComponent(name.slice(1))}` : encodeURIComponent(name);
 }
 async function whichOnPath(command2, pathValue, search) {
-  const candidates = command2.includes("/") || command2.includes("\\") ? [command2] : (pathValue ?? "").split(search.delimiter).filter((dir) => dir.length > 0).map((dir) => join27(dir, command2));
+  const candidates = command2.includes("/") || command2.includes("\\") ? [command2] : (pathValue ?? "").split(search.delimiter).filter((dir) => dir.length > 0).map((dir) => join28(dir, command2));
   for (const candidate of candidates) {
     for (const extension of search.extensions) {
       if (await search.isExecutable(candidate + extension)) return candidate + extension;
@@ -38498,7 +39021,7 @@ var init_machine = __esm({
 });
 
 // ../../packages/tacho/src/collector/push-basis.ts
-import { resolve as resolve11 } from "node:path";
+import { isAbsolute as isAbsolute8, relative as relative4, resolve as resolve11 } from "node:path";
 function gitPushTarget(command2) {
   const tokens = tokenizeSimpleCommand(command2);
   if (tokens === void 0 || tokens[0] !== "git") return void 0;
@@ -38538,6 +39061,8 @@ function gitPushTarget(command2) {
   return { chdir, ...remote !== void 0 ? { remote } : {} };
 }
 async function pushCredentialBasis(command2, cwd, deps) {
+  if (deps.containedRepository !== void 0)
+    return containedPushBasis(command2, cwd, deps.containedRepository, deps);
   const receipts = deps.receipts();
   if (cwd === void 0 || receipts.length === 0)
     return TACHO_CREDENTIAL_HARNESS_HELD;
@@ -38550,6 +39075,25 @@ async function pushCredentialBasis(command2, cwd, deps) {
   const urls = await pushUrls(dir, remote, deps);
   return urls.length > 0 && urls.every((url) => url === receipt.url) ? TACHO_CREDENTIAL_GATEWAY_BROKERED : TACHO_CREDENTIAL_HARNESS_HELD;
 }
+function githubRepositoryOf(url) {
+  const match = /^https:\/\/github\.com\/([A-Za-z0-9-]+\/[A-Za-z0-9._-]+?)(?:\.git)?$/.exec(
+    url
+  );
+  return match?.[1]?.toLowerCase();
+}
+async function containedPushBasis(command2, cwd, repository, deps) {
+  const target2 = gitPushTarget(command2);
+  if (cwd === void 0 || target2 === void 0)
+    return TACHO_CREDENTIAL_HARNESS_HELD;
+  const dir = target2.chdir.reduce((from, to) => resolve11(from, to), cwd);
+  const inside2 = relative4(cwd, dir);
+  if (inside2.startsWith("..") || isAbsolute8(inside2))
+    return TACHO_CREDENTIAL_HARNESS_HELD;
+  const remote = target2.remote ?? await defaultPushRemote(dir, deps);
+  const urls = await pushUrls(dir, remote, deps);
+  const wanted = repository.toLowerCase();
+  return urls.length > 0 && urls.every((url) => githubRepositoryOf(url) === wanted) ? TACHO_CREDENTIAL_GATEWAY_BROKERED : TACHO_CREDENTIAL_HARNESS_HELD;
+}
 async function gitOut(dir, args, deps) {
   const result2 = await deps.execAsync("git", ["-C", dir, ...args]);
   return result2.status === 0 ? result2.stdout.trim() : void 0;
@@ -38625,7 +39169,7 @@ var init_codec = __esm({
 import { createHash as createHash12 } from "node:crypto";
 import { mkdir as mkdir2, readdir as readdir2, readFile as readFile2, rm as rm2, writeFile } from "node:fs/promises";
 import { homedir as homedir5 } from "node:os";
-import { dirname as dirname17, join as join28 } from "node:path";
+import { dirname as dirname17, join as join29 } from "node:path";
 function envDir(env, key) {
   const value = env[key];
   return value === void 0 || value.trim() === "" ? null : value;
@@ -38633,13 +39177,13 @@ function envDir(env, key) {
 function skillsRoot(harness, env = process.env, home = homedir5()) {
   switch (harness) {
     case "claude-code":
-      return join28(envDir(env, "CLAUDE_CONFIG_DIR") ?? join28(home, ".claude"), "skills");
+      return join29(envDir(env, "CLAUDE_CONFIG_DIR") ?? join29(home, ".claude"), "skills");
     case "codex": {
       const codexHome = envDir(env, "CODEX_HOME");
-      return codexHome === null ? join28(home, ".agents", "skills") : join28(codexHome, "skills");
+      return codexHome === null ? join29(home, ".agents", "skills") : join29(codexHome, "skills");
     }
     case "stella":
-      return join28(envDir(env, "STELLA_HOME") ?? join28(home, ".stella"), "skills");
+      return join29(envDir(env, "STELLA_HOME") ?? join29(home, ".stella"), "skills");
     case "cursor":
     case "claude-desktop":
       return null;
@@ -38692,7 +39236,7 @@ async function readMarker(folder) {
   }
   if (!entries2.includes(SESSION_MARKER)) return { state: "foreign" };
   try {
-    const parsed = JSON.parse(await readFile2(join28(folder, SESSION_MARKER), "utf8"));
+    const parsed = JSON.parse(await readFile2(join29(folder, SESSION_MARKER), "utf8"));
     return isMarker(parsed) ? { state: "ours", marker: parsed } : { state: "foreign" };
   } catch {
     return { state: "foreign" };
@@ -38707,15 +39251,15 @@ function liveSessions(marker, now) {
   return live;
 }
 async function writeMarker(folder, marker) {
-  await writeFile(join28(folder, SESSION_MARKER), `${JSON.stringify(marker, null, 2)}
+  await writeFile(join29(folder, SESSION_MARKER), `${JSON.stringify(marker, null, 2)}
 `);
 }
 async function writeSkill(folder, skill) {
   await rm2(folder, { recursive: true, force: true });
   await mkdir2(folder, { recursive: true });
-  await writeFile(join28(folder, "SKILL.md"), skillMarkdown(skill));
+  await writeFile(join29(folder, "SKILL.md"), skillMarkdown(skill));
   for (const file of skill.files) {
-    const target2 = join28(folder, file.path);
+    const target2 = join29(folder, file.path);
     await mkdir2(dirname17(target2), { recursive: true });
     await writeFile(target2, file.content);
   }
@@ -38743,7 +39287,7 @@ async function placeSkills(root, sessionId, skills, now = /* @__PURE__ */ new Da
       result2.warnings.push(refusal);
       continue;
     }
-    const folder = join28(root, skill.name);
+    const folder = join29(root, skill.name);
     if (taken.has(skill.name)) {
       result2.skipped.push(skill.name);
       result2.warnings.push(
@@ -38801,7 +39345,7 @@ async function removeSkills(root, sessionId, now = /* @__PURE__ */ new Date()) {
     throw error;
   }
   for (const name of names.sort(compareText)) {
-    const folder = join28(root, name);
+    const folder = join29(root, name);
     const found = await readMarker(folder);
     if (found.state !== "ours") continue;
     const sessions = liveSessions(found.marker, now);
@@ -40041,10 +40585,10 @@ var init_model_usage = __esm({
 // ../../packages/tacho/src/collector/model-proxy.ts
 import { createHash as createHash14 } from "node:crypto";
 import {
-  request as httpRequest2,
+  request as httpRequest,
   Agent as HttpAgent
 } from "node:http";
-import { Agent as HttpsAgent, request as httpsRequest2 } from "node:https";
+import { Agent as HttpsAgent, request as httpsRequest } from "node:https";
 import {
   gunzipSync,
   brotliDecompressSync,
@@ -40226,7 +40770,7 @@ function createModelProxy(deps) {
       for (const call of calls) held += call.reserved;
     return held;
   }
-  function ceilingFor(route, model, requestBytes, json2, hasSession) {
+  function ceilingFor2(route, model, requestBytes, json2, hasSession) {
     const { budget, model_prices: prices } = deps.policy().bundle;
     if (budget.mode !== "enforced") return 0;
     const limited = hasSession && budget.session_limit_usd !== void 0 || budget.daily_limit_usd !== void 0;
@@ -40593,7 +41137,7 @@ function createModelProxy(deps) {
         resolve19(outcome);
       };
       try {
-        upstream = (secure ? httpsRequest2 : httpRequest2)({
+        upstream = (secure ? httpsRequest : httpRequest)({
           protocol: target2.protocol,
           hostname: target2.hostname,
           port: target2.port.length > 0 ? Number(target2.port) : secure ? 443 : 80,
@@ -40929,7 +41473,7 @@ function createModelProxy(deps) {
     let abortReason;
     let upstreamReq;
     const entry2 = {
-      reserved: metered ? ceilingFor(
+      reserved: metered ? ceilingFor2(
         route,
         askedModel,
         requestTextBytes,
@@ -41358,7 +41902,7 @@ function createModelProxy(deps) {
       );
     };
     const openUpstream = (fresh) => {
-      const created = (secure ? httpsRequest2 : httpRequest2)({
+      const created = (secure ? httpsRequest : httpRequest)({
         protocol: target2.protocol,
         hostname: target2.hostname,
         port: target2.port.length > 0 ? Number(target2.port) : secure ? 443 : 80,
@@ -42066,7 +42610,7 @@ var init_server = __esm({
 
 // ../../packages/tacho/src/collector/spool.ts
 import { existsSync as existsSync19, readFileSync as readFileSync16 } from "node:fs";
-import { join as join29 } from "node:path";
+import { join as join30 } from "node:path";
 function sessionOwnedElsewhere(error) {
   return error.status === 403 && error.body.includes(SESSION_OWNED_ELSEWHERE);
 }
@@ -42226,7 +42770,7 @@ var init_spool = __esm({
        * gone for good.
        */
       stash(event, reason3, body2) {
-        const path2 = join29(
+        const path2 = join30(
           this.options.quarantineDir,
           `${event.session_uuid}-${String(event.seq).padStart(8, "0")}.json`
         );
@@ -42244,7 +42788,7 @@ var init_spool = __esm({
       }
       /** Add a body to a quarantine record that was written without one. */
       stashBodyBeside(event, body2) {
-        const path2 = join29(
+        const path2 = join30(
           this.options.quarantineDir,
           `${event.session_uuid}-${String(event.seq).padStart(8, "0")}.json`
         );
@@ -42373,7 +42917,7 @@ var init_spool = __esm({
           if (event !== void 0) withdrawn.push(event);
         }
         if (retention.proven && withdrawn.length > 0) {
-          const dropped = this.options.wal.dropBodies(withdrawn);
+          const dropped = await this.options.wal.dropBodiesAsync(withdrawn);
           if (dropped > 0)
             this.options.log(
               `retention: dropped ${String(dropped)} body(ies) the mandate no longer covers`
@@ -42653,13 +43197,13 @@ var init_spool = __esm({
 
 // ../../packages/tacho/src/collector/transcript-tailer.ts
 import { promises as fs2 } from "node:fs";
-import { basename as basename6, join as join30 } from "node:path";
+import { basename as basename6, join as join31 } from "node:path";
 function hasTranscriptNormalizer(session) {
   return session.harness === void 0 || TRANSCRIPT_NORMALIZED_HARNESSES.has(session.harness);
 }
 function subagentDirOf(transcriptPath) {
   if (!transcriptPath.endsWith(".jsonl")) return void 0;
-  return join30(transcriptPath.slice(0, -".jsonl".length), "subagents");
+  return join31(transcriptPath.slice(0, -".jsonl".length), "subagents");
 }
 function subagentIdOf(path2) {
   return /^agent-(.+)\.jsonl$/.exec(basename6(path2))?.[1];
@@ -43179,11 +43723,11 @@ var init_transcript_tailer = __esm({
        * those were 3,634 of 5,059 subagent transcripts.
        */
       async subagentTranscripts(dir) {
-        const paths = (await this.listDir(dir)).map((name) => join30(dir, name));
-        const workflows = join30(dir, "workflows");
+        const paths = (await this.listDir(dir)).map((name) => join31(dir, name));
+        const workflows = join31(dir, "workflows");
         for (const workflow of await this.listDir(workflows)) {
-          const at = join30(workflows, workflow);
-          for (const name of await this.listDir(at)) paths.push(join30(at, name));
+          const at = join31(workflows, workflow);
+          for (const name of await this.listDir(at)) paths.push(join31(at, name));
         }
         return paths.filter((path2) => subagentIdOf(path2) !== void 0).sort();
       }
@@ -43468,7 +44012,7 @@ import {
 } from "node:fs";
 import { readdir as readdir3, readFile as readFile3, stat as stat2 } from "node:fs/promises";
 import { homedir as homedir7, hostname as osHostname2 } from "node:os";
-import { dirname as dirname18, join as join31 } from "node:path";
+import { dirname as dirname18, join as join32 } from "node:path";
 import { execFile as execFile3, spawnSync as spawnSync5 } from "node:child_process";
 function defaultExec(command2, args) {
   const result2 = spawnSync5(command2, args, {
@@ -43984,6 +44528,7 @@ async function initializeDaemon(options, server, port, ready) {
     };
   }
   let launchedContained = () => false;
+  let containedGitHubRepository = () => void 0;
   function policy() {
     const current = host;
     return {
@@ -43996,7 +44541,7 @@ async function initializeDaemon(options, server, port, ready) {
       controlReachable: lastControlAt !== void 0 && now() - lastControlAt < 2 * timers.bundleRefreshMs
     };
   }
-  const bodyPurgeOwedPath = join31(paths.wal, "body-purge-owed");
+  const bodyPurgeOwedPath = join32(paths.wal, "body-purge-owed");
   function markBodyPurgeOwed(retention, dropped) {
     try {
       ensureDir(paths.wal);
@@ -44646,7 +45191,7 @@ async function initializeDaemon(options, server, port, ready) {
         let sessionId;
         try {
           const file = JSON.parse(
-            readFileSync17(join31(paths.spool, name), "utf8")
+            readFileSync17(join32(paths.spool, name), "utf8")
           );
           const named = file.payload?.session_id;
           sessionId = typeof named === "string" ? named : void 0;
@@ -44696,10 +45241,14 @@ async function initializeDaemon(options, server, port, ready) {
           now,
           // Both reads hold this hook's session queue, and both answer no
           // answer once `stop` begins (`hookExecAsync`).
-          pushCredentialBasis: (command2, cwd) => pushCredentialBasis(command2, cwd, {
-            receipts: () => readHostFile(paths.hostFile)?.github_repositories ?? [],
-            execAsync: hookExecAsync
-          }),
+          pushCredentialBasis: (command2, cwd, harnessSessionId) => {
+            const containedRepository = containedGitHubRepository(harnessSessionId);
+            return pushCredentialBasis(command2, cwd, {
+              receipts: () => readHostFile(paths.hostFile)?.github_repositories ?? [],
+              ...containedRepository !== void 0 ? { containedRepository } : {},
+              execAsync: hookExecAsync
+            });
+          },
           repositoryRemote: (cwd) => readRepositoryRemote(hookExecAsync, cwd),
           cedar: loadCedarRuntime,
           skills,
@@ -44786,7 +45335,7 @@ async function initializeDaemon(options, server, port, ready) {
   function setAsideConflictingTerminal(uuid, pending, conflict) {
     const name = `${uuid}-terminal-conflict-${String(conflict.seq).padStart(8, "0")}.json`;
     writeSensitiveFileAtomic(
-      join31(paths.quarantine, name),
+      join32(paths.quarantine, name),
       JSON.stringify(
         {
           reason: conflict.message,
@@ -44865,8 +45414,8 @@ async function initializeDaemon(options, server, port, ready) {
   function moveToFailedSpool(path2, name, reason3) {
     log(`spool file ${name} moved to spool/failed/: ${reason3}`);
     try {
-      ensureDir(join31(paths.spool, "failed"));
-      renameSync5(path2, join31(paths.spool, "failed", name));
+      ensureDir(join32(paths.spool, "failed"));
+      renameSync5(path2, join32(paths.spool, "failed", name));
     } catch (error) {
       log(
         `spool file ${name} could not be moved to spool/failed/: ${error instanceof Error ? error.message : String(error)}`
@@ -44915,7 +45464,7 @@ async function initializeDaemon(options, server, port, ready) {
         continue;
       }
       reads += 1;
-      const path2 = join31(paths.spool, name);
+      const path2 = join32(paths.spool, name);
       let file;
       try {
         file = JSON.parse(readFileSync17(path2, "utf8"));
@@ -45128,7 +45677,7 @@ async function initializeDaemon(options, server, port, ready) {
         let requested;
         try {
           const file = JSON.parse(
-            await readFile3(join31(paths.spool, name), "utf8")
+            await readFile3(join32(paths.spool, name), "utf8")
           );
           const payload = file.payload;
           requested = payload?.hook_event_name === "PreToolUse" && typeof payload.tool_use_id === "string" ? payload.tool_use_id : void 0;
@@ -45311,6 +45860,23 @@ async function initializeDaemon(options, server, port, ready) {
     port: options.modelProxyPort ?? (options.port === 0 ? 0 : modelProxyPortFor(host)),
     log
   });
+  const githubProxy = createGithubProxy({
+    host: () => {
+      const current = readHostFile(paths.hostFile);
+      return {
+        ...host,
+        github_broker_enabled: current?.github_broker_enabled === true,
+        github_repositories: current?.github_repositories ?? []
+      };
+    },
+    policy,
+    refreshBundle,
+    registry: registry2,
+    controlFetch: options.fetch ?? globalThis.fetch,
+    now,
+    record,
+    log
+  });
   const contained = createContainedRunner({
     host: () => host,
     registry: registry2,
@@ -45341,10 +45907,12 @@ async function initializeDaemon(options, server, port, ready) {
         log
       }
     ),
+    github: githubProxy,
     fetch: options.fetch ?? ((input, init) => fetch(input, init)),
     log
   });
   launchedContained = contained.launched;
+  containedGitHubRepository = contained.githubRepository;
   function interruptModelCalls(commands) {
     for (const command2 of commands) {
       const cuts = command2.command === "pause" || command2.command === "cancel" || command2.command === "kill" || command2.command === "steer" && command2.delivery_mode === "interrupt";
@@ -45409,23 +45977,6 @@ async function initializeDaemon(options, server, port, ready) {
     for (const refusal of session.recorder.takeOtelRefusals())
       log(`OTel record not sealed for session ${sessionId}: ${refusal}`);
   }
-  const githubProxy = createGithubProxy({
-    host: () => {
-      const current = readHostFile(paths.hostFile);
-      return {
-        ...host,
-        github_broker_enabled: current?.github_broker_enabled === true,
-        github_repositories: current?.github_repositories ?? []
-      };
-    },
-    policy,
-    refreshBundle,
-    registry: registry2,
-    controlFetch: options.fetch ?? globalThis.fetch,
-    now,
-    record,
-    log
-  });
   const api = {
     runContained: contained.run,
     githubLease: (input) => githubProxy.issue(input),
@@ -45648,7 +46199,7 @@ async function initializeDaemon(options, server, port, ready) {
     let removed = 0;
     for (const name of readdirSync11(paths.quarantine)) {
       if (!name.endsWith(".json")) continue;
-      const file = join31(paths.quarantine, name);
+      const file = join32(paths.quarantine, name);
       try {
         if (at - statSync9(file).mtimeMs < retainMs) continue;
         unlinkSync12(file);
@@ -45665,6 +46216,42 @@ async function initializeDaemon(options, server, port, ready) {
   let lastCompact = 0;
   const COMPACT_EVERY_MS = 60 * 6e4;
   const COMPACT_RETRY_MS = 6e4;
+  const walCeiling = new WalCeiling(
+    wal,
+    paths.wal,
+    { ...DEFAULT_WAL_CEILING, ...options.walCeiling },
+    timers.walRetainMs,
+    log
+  );
+  function recordCeilingDrop(drop) {
+    const mark = hostRecorder.markChain();
+    try {
+      record([
+        hostRecorder.sealCollectorEvent("telemetry_gap", {
+          gap_cause: "wal_ceiling",
+          // How long the session went without shipping, capped at what the
+          // column holds.
+          gap_duration_ms: Math.min(
+            Math.max(
+              0,
+              Date.parse(drop.dropped_at) - Date.parse(drop.stalled_since)
+            ),
+            4294967295
+          ),
+          incident_evidence: { ...drop }
+        })
+      ]);
+    } catch (error) {
+      hostRecorder.rollbackChain(mark);
+      log(
+        `WAL ceiling: removed the stored bodies of session ${drop.session_uuid}, but could not record it on the daemon chain: ${error instanceof Error ? error.message : String(error)}`
+      );
+      return;
+    }
+    log(
+      `WAL ceiling: removed ${drop.bytes} bytes of stored bodies from session ${drop.session_uuid}, which has shipped nothing since ${drop.stalled_since}; events ${drop.shipped_through + 1} to ${drop.last_seq} ship without their bodies`
+    );
+  }
   retryOwedBodyPurge();
   let gitLane;
   function startGitReads() {
@@ -45811,6 +46398,11 @@ async function initializeDaemon(options, server, port, ready) {
     });
     await stage("acks", () => sendAcks());
     void startGitReads();
+    await stage("wal ceiling", () => {
+      if (!walCeiling.due(now())) return;
+      if (queues.busy(hostRecord.harnessSessionId)) return;
+      walCeiling.check(now(), recordCeilingDrop);
+    });
     await stage("compact", () => {
       if (now() - lastCompact < COMPACT_EVERY_MS) return;
       lastCompact = now();
@@ -45904,7 +46496,7 @@ async function initializeDaemon(options, server, port, ready) {
   let memoryTimer;
   if (options.listen ?? true) {
     const codexMemories = createCodexMemoryStore({
-      path: join31(dirname18(paths.codexHooks), CODEX_MEMORY_STORE_FILE),
+      path: join32(dirname18(paths.codexHooks), CODEX_MEMORY_STORE_FILE),
       stat: (path2) => stat2(path2),
       log
     });
@@ -46045,6 +46637,7 @@ var init_daemon = __esm({
     init_process_scan();
     init_retention();
     init_wal();
+    init_wal_ceiling();
     init_work_orders();
     init_ids();
     init_timestamp();
@@ -46467,7 +47060,7 @@ var init_schema = __esm({
 import {
   closeSync as closeSync7,
   constants as constants3,
-  fstatSync,
+  fstatSync as fstatSync2,
   lstatSync as lstatSync6,
   mkdirSync as mkdirSync7,
   openSync as openSync7,
@@ -46475,8 +47068,8 @@ import {
   realpathSync as realpathSync4,
   writeFileSync as writeFileSync5
 } from "node:fs";
-import { dirname as dirname19, join as join32, resolve as resolve12 } from "node:path";
-function bundlePath(root, relative8, create2 = false) {
+import { dirname as dirname19, join as join33, resolve as resolve12 } from "node:path";
+function bundlePath(root, relative9, create2 = false) {
   const absolute = resolve12(root);
   if (create2) mkdirSync7(absolute, { recursive: true, mode: 448 });
   if (lstatSync6(absolute).isSymbolicLink() || !lstatSync6(absolute).isDirectory()) {
@@ -46484,9 +47077,9 @@ function bundlePath(root, relative8, create2 = false) {
   }
   const base2 = realpathSync4(absolute);
   let current = base2;
-  const parts = relative8.split("/");
+  const parts = relative9.split("/");
   for (let i2 = 0; i2 < parts.length; i2++) {
-    current = join32(current, parts[i2]);
+    current = join33(current, parts[i2]);
     try {
       const stat5 = lstatSync6(current);
       if (stat5.isSymbolicLink() || i2 < parts.length - 1 && !stat5.isDirectory()) {
@@ -46503,11 +47096,11 @@ function bundlePath(root, relative8, create2 = false) {
   }
   return current;
 }
-function readBounded(root, relative8, limit = ARP_MAX_BLOB_BYTES) {
-  const path2 = bundlePath(root, relative8);
+function readBounded(root, relative9, limit = ARP_MAX_BLOB_BYTES) {
+  const path2 = bundlePath(root, relative9);
   const fd2 = openSync7(path2, constants3.O_RDONLY | constants3.O_NOFOLLOW);
   try {
-    const stat5 = fstatSync(fd2);
+    const stat5 = fstatSync2(fd2);
     if (!stat5.isFile() || stat5.size > limit)
       throw new Error(
         "ARP file exceeds its size limit or is not a regular file"
@@ -46526,8 +47119,8 @@ function readBounded(root, relative8, limit = ARP_MAX_BLOB_BYTES) {
     closeSync7(fd2);
   }
 }
-function writeNew(root, relative8, bytes) {
-  const path2 = bundlePath(root, relative8, true);
+function writeNew(root, relative9, bytes) {
+  const path2 = bundlePath(root, relative9, true);
   const fd2 = openSync7(
     path2,
     constants3.O_WRONLY | constants3.O_CREAT | constants3.O_EXCL | constants3.O_NOFOLLOW,
@@ -47356,7 +47949,7 @@ import { randomUUID as randomUUID4 } from "node:crypto";
 import {
   closeSync as closeSync8,
   constants as constants4,
-  fstatSync as fstatSync2,
+  fstatSync as fstatSync3,
   lstatSync as lstatSync7,
   mkdirSync as mkdirSync8,
   openSync as openSync8,
@@ -47365,14 +47958,14 @@ import {
   rmSync as rmSync7,
   writeFileSync as writeFileSync6
 } from "node:fs";
-import { dirname as dirname20, isAbsolute as isAbsolute8, join as join33, relative as relative4, resolve as resolve13, sep as sep3 } from "node:path";
+import { dirname as dirname20, isAbsolute as isAbsolute9, join as join34, relative as relative5, resolve as resolve13, sep as sep3 } from "node:path";
 function fail2(message) {
   throw new Error(`ARP: ${message}`);
 }
 function readRegular(path2, limit) {
   const fd2 = openSync8(path2, constants4.O_RDONLY | constants4.O_NOFOLLOW);
   try {
-    const before = fstatSync2(fd2);
+    const before = fstatSync3(fd2);
     if (!before.isFile() || before.size > limit)
       fail2("Input is not a bounded regular file.");
     const bytes = Buffer.alloc(before.size);
@@ -47384,7 +47977,7 @@ function readRegular(path2, limit) {
     }
     if (readSync5(fd2, Buffer.alloc(1), 0, 1, offset) !== 0)
       fail2("Input grew while it was read.");
-    const after = fstatSync2(fd2);
+    const after = fstatSync3(fd2);
     if (bytes.length > limit || before.size !== after.size || before.mtimeMs !== after.mtimeMs || before.ctimeMs !== after.ctimeMs) {
       fail2(
         "Input changed while it was read. Stop its writer and capture again."
@@ -47403,12 +47996,12 @@ function rejectSecrets(bytes) {
   }
 }
 function within2(root, path2) {
-  const rel = relative4(root, path2);
-  return rel === "" || !isAbsolute8(rel) && rel !== ".." && !rel.startsWith(`..${sep3}`);
+  const rel = relative5(root, path2);
+  return rel === "" || !isAbsolute9(rel) && rel !== ".." && !rel.startsWith(`..${sep3}`);
 }
 function newPath(path2) {
   const full = resolve13(path2);
-  return join33(
+  return join34(
     realpathSync5(dirname20(full)),
     full.slice(dirname20(full).length + 1)
   );
@@ -47424,7 +48017,7 @@ function sourcePath(root, path2) {
   }
   let current = root;
   for (const part2 of path2.split("/")) {
-    current = join33(current, part2);
+    current = join34(current, part2);
     if (lstatSync7(current).isSymbolicLink())
       fail2("Symlinks require a resource adapter.");
   }
@@ -47677,10 +48270,10 @@ function prepareCheckpoint(options) {
   });
   mkdirSync8(destination, { mode: 448 });
   try {
-    const restored = join33(destination, "workspace");
+    const restored = join34(destination, "workspace");
     mkdirSync8(restored, { mode: 448 });
     for (const { entry: entry2, bytes } of files2) {
-      const path2 = join33(restored, entry2.path);
+      const path2 = join34(restored, entry2.path);
       if (entry2.kind === "directory")
         mkdirSync8(path2, { recursive: true, mode: 448 });
       else {
@@ -47692,9 +48285,9 @@ function prepareCheckpoint(options) {
         });
       }
     }
-    const promptDir = join33(restored, ".arp");
+    const promptDir = join34(restored, ".arp");
     mkdirSync8(promptDir, { mode: 448 });
-    const promptFile = join33(promptDir, "handoff.json");
+    const promptFile = join34(promptDir, "handoff.json");
     const prompt = {
       checkpoint_digest: checkpointDigest,
       task: task.request,
@@ -47711,7 +48304,7 @@ function prepareCheckpoint(options) {
       flag: "wx",
       mode: 384
     });
-    const reportPath = join33(destination, "report.json");
+    const reportPath = join34(destination, "report.json");
     writeFileSync6(
       reportPath,
       jcs({
@@ -48128,7 +48721,7 @@ function buildTachoProgram(options = {}) {
     "The repository root to mount at /workspace (default: the current directory)"
   ).option(
     "--github-repository <owner/name>",
-    "The one repository the run may reach, with a token in OXAGEN_CONTAINED_GITHUB_TOKEN"
+    "The one repository the run may fetch and push, through Oxagen's Git custody. The workspace must have it bound."
   ).argument("<agent>", "claude or codex").argument("[args...]", "Arguments for the agent, after --").action(
     async (agent, args, opts) => {
       const controller = new AbortController();
@@ -48235,7 +48828,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "@oxagen/cli",
-      version: "2.1.4-383",
+      version: "2.1.4-391",
       description: "Oxagen governance CLI \u2014 spend, lineage, grounding, credentials, and audit (agentic coding lives in the stella CLI)",
       type: "module",
       main: "./dist/index.js",
@@ -48320,10 +48913,10 @@ var init_retired = __esm({
 
 // src/lib/atomic-write.ts
 import { writeFileSync as writeFileSync7, renameSync as renameSync6, unlinkSync as unlinkSync14, existsSync as existsSync21 } from "node:fs";
-import { dirname as dirname21, join as join34 } from "node:path";
+import { dirname as dirname21, join as join35 } from "node:path";
 function atomicWriteFileSync(path2, data) {
   const dir = dirname21(path2);
-  const tmp = join34(
+  const tmp = join35(
     dir,
     `.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2)}.tmp`
   );
@@ -48345,7 +48938,7 @@ var init_atomic_write = __esm({
 
 // src/lib/config.ts
 import { homedir as homedir8 } from "os";
-import { join as join35 } from "path";
+import { join as join36 } from "path";
 import { readFileSync as readFileSync20, mkdirSync as mkdirSync9, existsSync as existsSync22 } from "fs";
 function getConfigDir() {
   return CONFIG_DIR;
@@ -48396,8 +48989,8 @@ var CONFIG_DIR, CONFIG_FILE;
 var init_config = __esm({
   "src/lib/config.ts"() {
     init_atomic_write();
-    CONFIG_DIR = join35(homedir8(), ".config", "oxagen");
-    CONFIG_FILE = join35(CONFIG_DIR, "config.json");
+    CONFIG_DIR = join36(homedir8(), ".config", "oxagen");
+    CONFIG_FILE = join36(CONFIG_DIR, "config.json");
   }
 });
 
@@ -48429,16 +49022,16 @@ import {
   writeFile as writeFile2
 } from "node:fs/promises";
 import { homedir as homedir9 } from "node:os";
-import { join as join36 } from "node:path";
+import { join as join37 } from "node:path";
 function isDebugEnabled() {
   const v = process.env[DEBUG_ENV];
   return v === "1" || v === "true";
 }
 function logsDir() {
-  return join36(homedir9(), ".oxagen", "logs");
+  return join37(homedir9(), ".oxagen", "logs");
 }
 function debugLogFile() {
-  return join36(logsDir(), "cli.output");
+  return join37(logsDir(), "cli.output");
 }
 function sanitize(value, depth = 0) {
   if (value === null || value === void 0) return value;
@@ -51459,9 +52052,9 @@ var init_git = __esm({
 
 // ../../packages/steering-freshness/src/cache.ts
 import { mkdir as mkdir4, readFile as readFile6, writeFile as writeFile4 } from "node:fs/promises";
-import { dirname as dirname22, join as join37 } from "node:path";
+import { dirname as dirname22, join as join38 } from "node:path";
 function stampPath(gitCommonDir) {
-  return join37(gitCommonDir, "oxagen", "steering-freshness.json");
+  return join38(gitCommonDir, "oxagen", "steering-freshness.json");
 }
 async function readFetchStamp(gitCommonDir, io = defaultIo) {
   try {
@@ -51515,24 +52108,24 @@ var init_cache = __esm({
 // ../../packages/steering-freshness/src/hooks.ts
 import { mkdir as mkdir5, readFile as readFile7, writeFile as writeFile5 } from "node:fs/promises";
 import { homedir as homedir10 } from "node:os";
-import { dirname as dirname23, join as join38 } from "node:path";
+import { dirname as dirname23, join as join39 } from "node:path";
 function hookCommand(harness) {
   return `oxagen steering gate --harness ${harness}`;
 }
 function hookConfigPath(projectRoot, harness, env = process.env, home = homedir10()) {
   switch (harness) {
     case "claude-code":
-      return join38(projectRoot, ".claude", "settings.json");
+      return join39(projectRoot, ".claude", "settings.json");
     case "codex":
-      return join38(env["CODEX_HOME"] ?? join38(home, ".codex"), "hooks.json");
+      return join39(env["CODEX_HOME"] ?? join39(home, ".codex"), "hooks.json");
     case "cursor":
-      return join38(home, ".cursor", "hooks.json");
+      return join39(home, ".cursor", "hooks.json");
     case "stella":
-      return join38(env["STELLA_HOME"] ?? join38(home, ".stella"), "stella.toml");
+      return join39(env["STELLA_HOME"] ?? join39(home, ".stella"), "stella.toml");
   }
 }
 function stellaJsonPath(env, home) {
-  return join38(env["STELLA_HOME"] ?? join38(home, ".stella"), "settings.json");
+  return join39(env["STELLA_HOME"] ?? join39(home, ".stella"), "settings.json");
 }
 function isRecord7(v) {
   return v !== null && typeof v === "object" && !Array.isArray(v);
@@ -52261,7 +52854,7 @@ var init_policy = __esm({
 // ../../packages/steering-freshness/src/settings.ts
 import { readFile as readFile8 } from "node:fs/promises";
 import { homedir as homedir11 } from "node:os";
-import { join as join39 } from "node:path";
+import { join as join40 } from "node:path";
 async function readLayer(scope, path2, read2) {
   let text4;
   try {
@@ -52313,14 +52906,14 @@ function parseLayer(scope, path2, text4) {
 }
 async function loadSteeringSettings({
   projectRoot,
-  userSettingsPath = join39(homedir11(), USER_SETTINGS_RELATIVE),
+  userSettingsPath = join40(homedir11(), USER_SETTINGS_RELATIVE),
   read: read2 = readFile8,
   workspacePolicy = null
 }) {
   const targets = [
     ["user", userSettingsPath],
-    ["project", join39(projectRoot, PROJECT_DIR_NAME, PROJECT_SETTINGS_FILE)],
-    ["local", join39(projectRoot, PROJECT_DIR_NAME, LOCAL_SETTINGS_FILE)]
+    ["project", join40(projectRoot, PROJECT_DIR_NAME, PROJECT_SETTINGS_FILE)],
+    ["local", join40(projectRoot, PROJECT_DIR_NAME, LOCAL_SETTINGS_FILE)]
   ];
   const layers = [];
   const warnings = [];
@@ -52368,7 +52961,7 @@ var init_settings = __esm({
     "use strict";
     init_git();
     init_policy();
-    USER_SETTINGS_RELATIVE = join39(
+    USER_SETTINGS_RELATIVE = join40(
       ".config",
       "oxagen",
       "settings.json"
@@ -52381,7 +52974,7 @@ var init_settings = __esm({
 
 // ../../packages/steering-freshness/src/check.ts
 import { lstat as lstat3 } from "node:fs/promises";
-import { isAbsolute as isAbsolute9, join as join40, resolve as resolve14 } from "node:path";
+import { isAbsolute as isAbsolute10, join as join41, resolve as resolve14 } from "node:path";
 function publishedCommits(platform) {
   if (platform.headCommits && platform.headCommits.length > 0)
     return platform.headCommits;
@@ -52473,7 +53066,7 @@ async function checkSteeringFreshness(opts) {
     );
   }
   const commonDir = allowNetwork ? await gitOrNull(repoCtx, "rev-parse", "--git-common-dir") : null;
-  const stampDir = commonDir ? isAbsolute9(commonDir) ? commonDir : resolve14(root, commonDir) : null;
+  const stampDir = commonDir ? isAbsolute10(commonDir) ? commonDir : resolve14(root, commonDir) : null;
   const stamp = stampDir ? await readFetchStamp(stampDir, cacheIo) : null;
   const remoteContactDue = allowNetwork && shouldContactRemote(stamp, policy.fetchIntervalSeconds, now());
   const branch = policy.branch ?? await defaultBranch(networkCtx(repoCtx), policy.remote, {
@@ -52695,7 +53288,7 @@ async function absentFromDisk(root, paths) {
   const flags = await Promise.all(
     paths.map(async (path2) => {
       try {
-        await lstat3(join40(root, path2));
+        await lstat3(join41(root, path2));
         return false;
       } catch {
         return true;
@@ -53348,9 +53941,9 @@ import {
   rmSync as rmSync8,
   writeFileSync as writeFileSync8
 } from "node:fs";
-import { join as join41 } from "node:path";
+import { join as join42 } from "node:path";
 function workspaceLinkPath(cwd) {
-  return join41(cwd, ".oxagen", "workspace.json");
+  return join42(cwd, ".oxagen", "workspace.json");
 }
 function readWorkspaceLink(cwd) {
   const filePath = workspaceLinkPath(cwd);
@@ -53367,7 +53960,7 @@ function readWorkspaceLink(cwd) {
   }
 }
 function writeWorkspaceLink(cwd, link) {
-  const dir = join41(cwd, ".oxagen");
+  const dir = join42(cwd, ".oxagen");
   mkdirSync10(dir, { recursive: true });
   writeFileSync8(workspaceLinkPath(cwd), JSON.stringify(link, null, 2), "utf8");
 }
@@ -53393,7 +53986,7 @@ __export(steering_exports, {
 });
 import { execFileSync } from "node:child_process";
 import { existsSync as existsSync24, realpathSync as realpathSync6 } from "node:fs";
-import { dirname as dirname24, join as join42, normalize, parse as parsePath } from "node:path";
+import { dirname as dirname24, join as join43, normalize, parse as parsePath } from "node:path";
 function findProjectRoot(start) {
   const { root } = parsePath(start);
   const rawGitRoot = gitRootOr(start);
@@ -53402,7 +53995,7 @@ function findProjectRoot(start) {
   if (gitRoot !== null) return gitRoot;
   let dir = from;
   for (; ; ) {
-    if (existsSync24(join42(dir, PROJECT_DIR_NAME))) return dir;
+    if (existsSync24(join43(dir, PROJECT_DIR_NAME))) return dir;
     if (dir === root) return from;
     const parent = dirname24(dir);
     if (parent === dir) return from;
@@ -64334,7 +64927,7 @@ var init_record = __esm({
       external_exports.object({
         source: external_exports.enum(["proposal", "run", "import"]),
         uri: external_exports.string(),
-        agent: external_exports.string().optional().describe("The agent that proposed the record with steering_propose."),
+        agent: external_exports.string().optional().describe("The agent that proposed the record with propose_steering."),
         memories: external_exports.array(provenanceMemorySchema).min(1).optional().describe(
           "The memories the curator cited for the record. Required when source is run."
         )
@@ -68748,14 +69341,14 @@ var init_memory_client = __esm({
 
 // src/lib/markdown-import.ts
 import { readFile as readFile9 } from "node:fs/promises";
-import { basename as basename7, dirname as dirname25, isAbsolute as isAbsolute10, relative as relative5, resolve as resolve15, sep as sep4 } from "node:path";
+import { basename as basename7, dirname as dirname25, isAbsolute as isAbsolute11, relative as relative6, resolve as resolve15, sep as sep4 } from "node:path";
 function inside(rel) {
-  return rel !== "" && !rel.startsWith("..") && !isAbsolute10(rel);
+  return rel !== "" && !rel.startsWith("..") && !isAbsolute11(rel);
 }
 function importFilename(path2, folder) {
-  let rel = relative5(process.cwd(), path2);
+  let rel = relative6(process.cwd(), path2);
   if (!inside(rel) && folder !== void 0) {
-    rel = relative5(dirname25(resolve15(folder)), resolve15(path2));
+    rel = relative6(dirname25(resolve15(folder)), resolve15(path2));
   }
   const name = inside(rel) ? rel.split(sep4).join("/") : basename7(path2);
   return name.length > 256 ? basename7(path2).slice(-256) : name;
@@ -68973,7 +69566,7 @@ __export(steering_import_exports, {
   handleSteeringImport: () => handleSteeringImport
 });
 import { readdir as readdir4, realpath as realpath2, stat as stat4 } from "node:fs/promises";
-import { extname, join as join43 } from "node:path";
+import { extname, join as join44 } from "node:path";
 function byName(a, b5) {
   return a.name < b5.name ? -1 : 1;
 }
@@ -69001,7 +69594,7 @@ async function findMarkdownFiles(paths) {
     }
     entries2.sort(byName);
     for (const entry2 of entries2) {
-      const path2 = join43(dir, entry2.name);
+      const path2 = join44(dir, entry2.name);
       if (entry2.isDirectory()) {
         if (entry2.name.startsWith(".") || entry2.name === "node_modules") continue;
         await walk(path2, folder);
@@ -69071,6 +69664,268 @@ var init_steering_import = __esm({
   }
 });
 
+// src/commands/steering-findings.ts
+var steering_findings_exports = {};
+__export(steering_findings_exports, {
+  PROPOSAL_STATUS_WORDS: () => PROPOSAL_STATUS_WORDS,
+  STEERING_FINDINGS_CAPABILITIES: () => STEERING_FINDINGS_CAPABILITIES,
+  apiRefusal: () => apiRefusal,
+  reportApiFailure: () => reportApiFailure,
+  steeringFindings: () => steeringFindings,
+  usageError: () => usageError
+});
+function isRecord9(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function textOrNull(value) {
+  return typeof value === "string" && value.length > 0 ? value : null;
+}
+function apiRefusal(err2) {
+  const message = errorMessage(err2);
+  const start = message.indexOf("{");
+  const end = message.lastIndexOf("}");
+  if (start >= 0 && end > start) {
+    try {
+      const body2 = JSON.parse(message.slice(start, end + 1));
+      const error = isRecord9(body2) && isRecord9(body2.error) ? body2.error : null;
+      const said = error === null ? null : textOrNull(error.message);
+      if (error !== null && said !== null) {
+        return {
+          code: textOrNull(error.code),
+          reason: textOrNull(error.reason),
+          message: said
+        };
+      }
+    } catch {
+    }
+  }
+  return { code: null, reason: null, message };
+}
+function reportApiFailure(out, writer, err2, nextSteps = {}) {
+  const refusal = apiRefusal(err2);
+  out.error(refusal.message, refusal.reason ?? refusal.code ?? "api");
+  if (out.isJson || refusal.reason === null) return;
+  const next = nextSteps[refusal.reason];
+  if (next !== void 0) writer.writeErr(next);
+}
+function usageError(writer, message, line) {
+  writer.writeErr(`error: ${message}`);
+  writer.writeErr(`usage: ${line}`);
+  process.exitCode = 2;
+}
+function plural(count7, one, many) {
+  return `${count7} ${count7 === 1 ? one : many}`;
+}
+function findingRow(finding) {
+  const pr = finding.pull_request;
+  const proposal = finding.proposal;
+  return [
+    finding.id,
+    finding.kind,
+    `${finding.path}:${finding.line}`,
+    finding.record.label ?? finding.record.lineage,
+    `#${pr.number} ${pr.state}`,
+    proposal === null ? "none" : `${proposal.id} (${PROPOSAL_STATUS_WORDS[proposal.status]})`
+  ];
+}
+async function steeringFindings(opts = {}, writer = stdoutWriter) {
+  const out = createOutput({ json: opts.json }, writer);
+  let result2;
+  try {
+    result2 = await apiGetOrThrow(
+      "repository/findings"
+    );
+  } catch (err2) {
+    reportApiFailure(out, writer, err2);
+    return;
+  }
+  if (out.isJson) {
+    out.data(result2);
+    return;
+  }
+  const repositories = result2.repositories.filter((r) => r.findings.length > 0);
+  if (repositories.length === 0) {
+    writer.write(
+      "No findings. The Oxagen check found no statement in a linked repository's instruction files that repeats or contradicts a steering record."
+    );
+    return;
+  }
+  let total2 = 0;
+  for (const [index, repository] of repositories.entries()) {
+    if (index > 0) writer.write("");
+    writer.write(`${repository.full_name} (${repository.provider})`);
+    printTable(
+      ["FINDING", "KIND", "FILE", "RECORD", "PULL REQUEST", "PROPOSAL"],
+      repository.findings.map(findingRow),
+      writer
+    );
+    total2 += repository.findings.length;
+  }
+  writer.write("");
+  writer.write(
+    `${plural(total2, "finding", "findings")} in ${plural(repositories.length, "repository", "repositories")}.`
+  );
+  const promotable = repositories.some(
+    (r) => r.findings.some((f) => f.kind === "contradiction" && f.proposal === null)
+  );
+  if (promotable) {
+    writer.write(
+      "Promote a contradiction to a proposal with `oxagen steering promote <finding-id>`."
+    );
+  }
+}
+var STEERING_FINDINGS_CAPABILITIES, PROPOSAL_STATUS_WORDS;
+var init_steering_findings = __esm({
+  "src/commands/steering-findings.ts"() {
+    init_api();
+    init_capture_writer();
+    init_output();
+    STEERING_FINDINGS_CAPABILITIES = [
+      "list_code_repository_findings"
+    ];
+    PROPOSAL_STATUS_WORDS = {
+      proposed: "waiting for its steering PR",
+      pr_open: "steering PR open",
+      checks_running: "checks running",
+      checks_passed: "checks passed",
+      checks_failed: "checks failed",
+      merged: "merged",
+      rejected: "rejected"
+    };
+  }
+});
+
+// src/commands/steering-promote.ts
+var steering_promote_exports = {};
+__export(steering_promote_exports, {
+  STEERING_PROMOTE_CAPABILITIES: () => STEERING_PROMOTE_CAPABILITIES,
+  steeringPromote: () => steeringPromote
+});
+async function steeringPromote(findingId, opts = {}, writer = stdoutWriter) {
+  const id = findingId.trim();
+  if (!FINDING_ID.test(id)) {
+    usageError(
+      writer,
+      `expected a finding id that starts with crf_, got ${JSON.stringify(findingId)}. Run \`oxagen steering findings\` to list them.`,
+      USAGE
+    );
+    return;
+  }
+  const out = createOutput({ json: opts.json }, writer);
+  let result2;
+  try {
+    result2 = await apiPostOrThrow(
+      "repository/findings/promote",
+      { finding_id: id }
+    );
+  } catch (err2) {
+    reportApiFailure(out, writer, err2, NEXT_STEPS);
+    return;
+  }
+  if (out.isJson) {
+    out.data(result2);
+    return;
+  }
+  writer.write(`Opened proposal ${result2.proposal_id} for record ${result2.lineage}.`);
+  const pr = result2.pull_request;
+  writer.write(
+    pr === null ? "Steering PR: none yet" : `Steering PR: #${pr.number} ${pr.url}`
+  );
+  writer.write(`Status: ${PROPOSAL_STATUS_WORDS[result2.status]}`);
+  writer.write("Nothing steers until a person merges the steering PR.");
+}
+var STEERING_PROMOTE_CAPABILITIES, FINDING_ID, USAGE, NEXT_STEPS;
+var init_steering_promote = __esm({
+  "src/commands/steering-promote.ts"() {
+    init_api();
+    init_capture_writer();
+    init_output();
+    init_steering_findings();
+    STEERING_PROMOTE_CAPABILITIES = [
+      "promote_instruction_to_steering"
+    ];
+    FINDING_ID = /^crf_[0-9A-Za-z]+$/;
+    USAGE = "oxagen steering promote <finding-id> [--json]";
+    NEXT_STEPS = {
+      finding_resolved: "Run `oxagen steering findings` to see the statements that still match a record.",
+      already_proposed: "Run `oxagen steering findings` to see the open proposal and its steering PR.",
+      lineage_pr_open: "Merge or close the PR that is open on the record, then promote the finding again."
+    };
+  }
+});
+
+// src/commands/steering-restore-block.ts
+var steering_restore_block_exports = {};
+__export(steering_restore_block_exports, {
+  STEERING_RESTORE_BLOCK_CAPABILITIES: () => STEERING_RESTORE_BLOCK_CAPABILITIES,
+  managedBlockFile: () => managedBlockFile,
+  steeringRestoreBlock: () => steeringRestoreBlock
+});
+function managedBlockFile(path2) {
+  const name = path2.trim().replace(/^\.\//, "").toLowerCase();
+  const files2 = Object.keys(MANAGED_BLOCK_FILES);
+  return files2.find((file) => file.toLowerCase() === name) ?? null;
+}
+async function steeringRestoreBlock(proposalId, path2, opts = {}, writer = stdoutWriter) {
+  const id = proposalId.trim();
+  if (!PROPOSAL_ID2.test(id)) {
+    usageError(
+      writer,
+      `expected a proposal id that starts with prp_, got ${JSON.stringify(proposalId)}`,
+      USAGE2
+    );
+    return;
+  }
+  const file = managedBlockFile(path2);
+  if (file === null) {
+    usageError(
+      writer,
+      `expected AGENTS.md, CLAUDE.md, or README.md, got ${JSON.stringify(path2)}`,
+      USAGE2
+    );
+    return;
+  }
+  const out = createOutput({ json: opts.json }, writer);
+  let result2;
+  try {
+    result2 = await apiPostOrThrow(
+      "context/prs/restore-block",
+      { proposalId: id, path: file }
+    );
+  } catch (err2) {
+    reportApiFailure(out, writer, err2);
+    return;
+  }
+  if (out.isJson) {
+    out.data(result2);
+    return;
+  }
+  writer.write(
+    `Restored the managed block in ${file} on the steering PR for ${id}.`
+  );
+  writer.write(`Commit: ${result2.commit_sha}`);
+  writer.write(`Status: ${PROPOSAL_STATUS_WORDS[result2.status]}`);
+}
+var STEERING_RESTORE_BLOCK_CAPABILITIES, MANAGED_BLOCK_FILES, PROPOSAL_ID2, USAGE2;
+var init_steering_restore_block = __esm({
+  "src/commands/steering-restore-block.ts"() {
+    init_api();
+    init_capture_writer();
+    init_output();
+    init_steering_findings();
+    STEERING_RESTORE_BLOCK_CAPABILITIES = [
+      "restore_managed_block"
+    ];
+    MANAGED_BLOCK_FILES = {
+      "AGENTS.md": true,
+      "CLAUDE.md": true,
+      "README.md": true
+    };
+    PROPOSAL_ID2 = /^prp_[0-9A-Za-z]+$/;
+    USAGE2 = "oxagen steering restore-block <proposal-id> <AGENTS.md|CLAUDE.md|README.md> [--json]";
+  }
+});
+
 // src/commands/tools.ts
 var tools_exports = {};
 __export(tools_exports, {
@@ -69149,7 +70004,7 @@ function resolveDownloadUrl(url, apiUrl) {
   const base2 = apiUrl.replace(/\/+$/, "");
   return `${base2}${url.startsWith("/") ? "" : "/"}${url}`;
 }
-function formatBytes(bytes) {
+function formatBytes2(bytes) {
   return bytes === null ? "not recorded" : `${bytes.toLocaleString("en-US")} bytes`;
 }
 async function runExportStatus(exportId, opts = {}, writer = stdoutWriter) {
@@ -69183,7 +70038,7 @@ async function runExportStatus(exportId, opts = {}, writer = stdoutWriter) {
     );
     return;
   }
-  writer.write(`Size: ${formatBytes(result2.bundleBytes)}`);
+  writer.write(`Size: ${formatBytes2(result2.bundleBytes)}`);
   writer.write(`Digest: ${result2.bundleDigest ?? "not recorded"}`);
   writer.write(`Frames: ${result2.frameCount ?? "not recorded"}`);
   writer.write(`Merkle root: ${result2.merkleRoot ?? "not recorded"}`);
@@ -69275,7 +70130,7 @@ async function runDownload(exportId, opts = {}, writer = stdoutWriter) {
     out.data(result2);
     return;
   }
-  writer.write(`Wrote ${path2} (${formatBytes(bytes.byteLength)}).`);
+  writer.write(`Wrote ${path2} (${formatBytes2(bytes.byteLength)}).`);
   writer.write(`Digest ${actual} matches the recorded bundle digest.`);
   writer.write(`Check every frame offline with \`oxagen verify ${path2}\`.`);
 }
@@ -70446,10 +71301,10 @@ __export(verify_exports, {
   verifyBundle: () => verifyBundle3
 });
 import { existsSync as existsSync25, readFileSync as readFileSync22, statSync as statSync10 } from "node:fs";
-import { join as join44 } from "node:path";
+import { join as join45 } from "node:path";
 function readDirectory(dir) {
   const read2 = (name) => {
-    const path2 = join44(dir, name);
+    const path2 = join45(dir, name);
     return existsSync25(path2) ? readFileSync22(path2, "utf8") : void 0;
   };
   return assemble(read2, dir);
@@ -70509,7 +71364,7 @@ function formatFrame(frame) {
   return parts.join("  ");
 }
 function formatCounts(counts) {
-  return counts.map((c) => `${c.kind} ${c.count} (in ${plural(c.frames, "frame")})`).join(", ");
+  return counts.map((c) => `${c.kind} ${c.count} (in ${plural2(c.frames, "frame")})`).join(", ");
 }
 function formatVerification(result2) {
   const lines = [];
@@ -70522,7 +71377,7 @@ function formatVerification(result2) {
   ).length;
   if (notCarried > 0) {
     lines.push(
-      `  Digest not carried on ${plural(notCarried, "wrapped (tse_) frame")}. A wrapped frame is hashed over its full event, and the bundle does not hold that event for these frames: an export before format 3 never did, and a format-3 export leaves it out when the stored row cannot be proven to rebuild it. For these frames, only the links and the Merkle root can be checked.`
+      `  Digest not carried on ${plural2(notCarried, "wrapped (tse_) frame")}. A wrapped frame is hashed over its full event, and the bundle does not hold that event for these frames: an export before format 3 never did, and a format-3 export leaves it out when the stored row cannot be proven to rebuild it. For these frames, only the links and the Merkle root can be checked.`
     );
   }
   lines.push("");
@@ -70551,7 +71406,7 @@ function formatVerification(result2) {
     (c) => c.status === "broken"
   ).length;
   lines.push(
-    result2.ok ? `HELD ${runId}: ${plural(result2.frames.length, "frame")}` : `BROKEN ${runId}: ${brokenFrames} of ${plural(result2.frames.length, "frame")} broken, ${plural(brokenChecks, "check")} broken`
+    result2.ok ? `HELD ${runId}: ${plural2(result2.frames.length, "frame")}` : `BROKEN ${runId}: ${brokenFrames} of ${plural2(result2.frames.length, "frame")} broken, ${plural2(brokenChecks, "check")} broken`
   );
   return lines;
 }
@@ -70569,7 +71424,7 @@ async function verifyBundle3(bundle2, opts = {}, writer = stdoutWriter) {
   if (!result2.ok && (process.exitCode === void 0 || process.exitCode === 0))
     process.exitCode = 1;
 }
-var REQUIRED, OPTIONAL, BundleReadError, plural;
+var REQUIRED, OPTIONAL, BundleReadError, plural2;
 var init_verify2 = __esm({
   "src/commands/verify.ts"() {
     init_esm2();
@@ -70584,7 +71439,7 @@ var init_verify2 = __esm({
     OPTIONAL = "redactions.json";
     BundleReadError = class extends Error {
     };
-    plural = (n4, word) => `${n4} ${word}${n4 === 1 ? "" : "s"}`;
+    plural2 = (n4, word) => `${n4} ${word}${n4 === 1 ? "" : "s"}`;
   }
 });
 
@@ -70796,7 +71651,7 @@ function ago(iso, now = /* @__PURE__ */ new Date()) {
   if (hours < 48) return `${hours}h ago`;
   return `${Math.round(hours / 24)}d ago`;
 }
-function plural2(count7, one, many) {
+function plural3(count7, one, many) {
   return `${count7} ${count7 === 1 ? one : many}`;
 }
 function table(headers, rows) {
@@ -70808,7 +71663,7 @@ function table(headers, rows) {
 }
 function formatWorkspaceMemories(result2, now = /* @__PURE__ */ new Date()) {
   if (result2.groups.length === 0) {
-    return result2.total_groups === 0 ? "No memories yet. Oxagen collects them from enrolled hosts every five minutes." : `No memories on this page. The list holds ${plural2(result2.total_groups, "group", "groups")}.`;
+    return result2.total_groups === 0 ? "No memories yet. Oxagen collects them from enrolled hosts every five minutes." : `No memories on this page. The list holds ${plural3(result2.total_groups, "group", "groups")}.`;
   }
   const rows = result2.groups.map((group) => {
     const { memory } = group;
@@ -70827,13 +71682,13 @@ function formatWorkspaceMemories(result2, now = /* @__PURE__ */ new Date()) {
   const shown2 = result2.groups.length;
   lines.push(
     "",
-    shown2 < result2.total_groups ? `Showing ${shown2} of ${plural2(result2.total_groups, "group", "groups")}. Use --limit and --offset to page.` : `${plural2(result2.total_groups, "group", "groups")}.`
+    shown2 < result2.total_groups ? `Showing ${shown2} of ${plural3(result2.total_groups, "group", "groups")}. Use --limit and --offset to page.` : `${plural3(result2.total_groups, "group", "groups")}.`
   );
   if (result2.truncated)
     lines.push(
       `More than ${result2.total_memories} memories matched, and the list groups the top ${result2.total_memories}. Narrow the filters to see the rest.`
     );
-  lines.push(`${plural2(result2.waiting, "memory waits", "memories wait")} in this workspace.`);
+  lines.push(`${plural3(result2.waiting, "memory waits", "memories wait")} in this workspace.`);
   return lines.join("\n");
 }
 function formatWorkspaceMemory(result2, now = /* @__PURE__ */ new Date()) {
@@ -70891,7 +71746,7 @@ function formatDismissResult(result2, restore) {
   const lines = [];
   if (result2.changed.length > 0)
     lines.push(
-      `${restore ? "Restored" : "Dismissed"} ${plural2(result2.changed.length, "memory", "memories")}: ${result2.changed.join(", ")}.`
+      `${restore ? "Restored" : "Dismissed"} ${plural3(result2.changed.length, "memory", "memories")}: ${result2.changed.join(", ")}.`
     );
   else lines.push(`No memory was ${restore ? "restored" : "dismissed"}.`);
   if (!restore && result2.rejections > 0)
@@ -71360,7 +72215,7 @@ import {
   writeFileSync as writeFileSync10
 } from "node:fs";
 import { homedir as homedir12, hostname as osHostname3 } from "node:os";
-import { join as join45, relative as relative6, resolve as resolve17, sep as sep5 } from "node:path";
+import { join as join46, relative as relative7, resolve as resolve17, sep as sep5 } from "node:path";
 function git4(cwd, args) {
   return new Promise((done) => {
     try {
@@ -71407,7 +72262,7 @@ function parseRemoteRepository(url) {
 }
 function oxagenPresent(root) {
   try {
-    return readdirSync12(join45(root, ".oxagen")).some(
+    return readdirSync12(join46(root, ".oxagen")).some(
       (name) => name !== "workspace.json"
     );
   } catch {
@@ -71416,18 +72271,18 @@ function oxagenPresent(root) {
 }
 function symlinkState(root) {
   try {
-    if (!lstatSync8(join45(root, ".stella")).isDirectory()) return "none";
+    if (!lstatSync8(join46(root, ".stella")).isDirectory()) return "none";
   } catch {
     return "none";
   }
   let oxagenReal;
   try {
-    oxagenReal = realpathSync7(join45(root, ".oxagen"));
+    oxagenReal = realpathSync7(join46(root, ".oxagen"));
   } catch {
     return "missing";
   }
   for (const link of STELLA_LINKS) {
-    const at = join45(root, link);
+    const at = join46(root, link);
     try {
       if (!lstatSync8(at).isSymbolicLink()) return "missing";
       const target2 = realpathSync7(at);
@@ -71441,7 +72296,7 @@ function symlinkState(root) {
   return "linked";
 }
 function machineId(configDir = getConfigDir()) {
-  const file = join45(configDir, MACHINE_ID_FILE);
+  const file = join46(configDir, MACHINE_ID_FILE);
   let secret = null;
   try {
     if (existsSync26(file)) {
@@ -71521,14 +72376,14 @@ async function ensureWorkspaceLinkIgnored(root) {
   const top = await git4(root, ["rev-parse", "--show-toplevel"]);
   if (!top) return null;
   const topDir = resolve17(top);
-  const entry2 = relative6(
+  const entry2 = relative7(
     topDir,
-    join45(realpathOr2(root), ".oxagen", "workspace.json")
+    join46(realpathOr2(root), ".oxagen", "workspace.json")
   ).split(sep5).join("/");
   if (entry2.startsWith("../")) return null;
   const rule = await git4(topDir, ["check-ignore", "--no-index", "-v", entry2]);
   if (rule !== null) return null;
-  const gitignore = join45(resolve17(top), ".gitignore");
+  const gitignore = join46(resolve17(top), ".gitignore");
   let existing = "";
   try {
     existing = readFileSync23(gitignore, "utf8");
@@ -72011,8 +72866,8 @@ import {
 } from "node:fs";
 import {
   dirname as dirname26,
-  isAbsolute as isAbsolute11,
-  join as join46,
+  isAbsolute as isAbsolute12,
+  join as join47,
   parse as parsePath2,
   posix as posix5,
   sep as sep6
@@ -72025,7 +72880,7 @@ function checkSteeringPath(path2) {
   if (path2.includes("\\")) {
     return { ok: false, reason: "contains a backslash" };
   }
-  if (posix5.isAbsolute(path2) || isAbsolute11(path2) || /^[A-Za-z]:/.test(path2)) {
+  if (posix5.isAbsolute(path2) || isAbsolute12(path2) || /^[A-Za-z]:/.test(path2)) {
     return { ok: false, reason: "absolute path" };
   }
   const normalized = posix5.normalize(path2);
@@ -72125,7 +72980,7 @@ function findLinkedRoot(start) {
 }
 function fsReader(root) {
   return (path2) => {
-    const abs = join46(root, ...path2.split("/"));
+    const abs = join47(root, ...path2.split("/"));
     try {
       const st = lstatSync9(abs);
       if (!st.isFile()) return Buffer.from(`\0not-a-file:${abs}`);
@@ -72136,14 +72991,14 @@ function fsReader(root) {
   };
 }
 function assertInsideOxagen(root, path2) {
-  const oxagenAbs = join46(root, OXAGEN_DIR);
+  const oxagenAbs = join47(root, OXAGEN_DIR);
   let oxagenReal;
   try {
     oxagenReal = realpathSync8(oxagenAbs);
   } catch {
     return;
   }
-  const abs = join46(root, ...path2.split("/"));
+  const abs = join47(root, ...path2.split("/"));
   try {
     if (lstatSync9(abs).isSymbolicLink()) {
       throw new Error(
@@ -72173,8 +73028,8 @@ function assertInsideOxagen(root, path2) {
   }
 }
 function pruneEmptyDirs(root, path2) {
-  const stop = join46(root, OXAGEN_DIR);
-  let dir = dirname26(join46(root, ...path2.split("/")));
+  const stop = join47(root, OXAGEN_DIR);
+  let dir = dirname26(join47(root, ...path2.split("/")));
   while (dir.startsWith(stop + sep6)) {
     try {
       if (readdirSync13(dir).length > 0) return;
@@ -72189,12 +73044,12 @@ function applyPlan(root, plan) {
   for (const w of plan.writes) assertInsideOxagen(root, w.path);
   for (const d of plan.deletes) assertInsideOxagen(root, d);
   for (const w of plan.writes) {
-    const abs = join46(root, ...w.path.split("/"));
+    const abs = join47(root, ...w.path.split("/"));
     mkdirSync12(dirname26(abs), { recursive: true });
     atomicWriteFileSync(abs, w.content);
   }
   for (const d of plan.deletes) {
-    rmSync9(join46(root, ...d.split("/")), { force: true });
+    rmSync9(join47(root, ...d.split("/")), { force: true });
     pruneEmptyDirs(root, d);
   }
 }
@@ -74292,7 +75147,7 @@ var init_registry_launch = __esm({
 function messageOf2(error) {
   return error instanceof Error ? error.message : String(error);
 }
-function isRecord9(value) {
+function isRecord10(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function isList(value) {
@@ -74303,7 +75158,7 @@ function jsonEqual(a, b5) {
   if (Array.isArray(a)) {
     return Array.isArray(b5) && a.length === b5.length && a.every((item, index) => jsonEqual(item, b5[index]));
   }
-  if (isRecord9(a) && isRecord9(b5)) {
+  if (isRecord10(a) && isRecord10(b5)) {
     const keys = Object.keys(a);
     return keys.length === Object.keys(b5).length && keys.every((key) => Object.hasOwn(b5, key) && jsonEqual(a[key], b5[key]));
   }
@@ -74312,16 +75167,16 @@ function jsonEqual(a, b5) {
 function valueAt2(value, path2) {
   let current = value;
   for (const step of path2.split(".")) {
-    if (step.endsWith("[]") || !isRecord9(current) || !Object.hasOwn(current, step)) return void 0;
+    if (step.endsWith("[]") || !isRecord10(current) || !Object.hasOwn(current, step)) return void 0;
     current = current[step];
   }
   return current;
 }
 function withValueAt(value, path2, replacement) {
   const [step, ...rest] = path2.split(".");
-  if (step === void 0 || !isRecord9(value)) return value;
+  if (step === void 0 || !isRecord10(value)) return value;
   const inner = Object.hasOwn(value, step) ? value[step] : void 0;
-  if (rest.length > 0 && !isRecord9(inner)) return value;
+  if (rest.length > 0 && !isRecord10(inner)) return value;
   const next = rest.length === 0 ? replacement : withValueAt(inner, rest.join("."), replacement);
   return { ...value, [step]: next };
 }
@@ -74996,11 +75851,11 @@ var init_openapi = __esm({
 });
 
 // ../../packages/mcp-studio/src/compile/json-schema.ts
-function isRecord11(value) {
+function isRecord12(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function propertiesOf(schema) {
-  return isRecord11(schema.properties) ? schema.properties : {};
+  return isRecord12(schema.properties) ? schema.properties : {};
 }
 function requiredOf(schema) {
   if (!Array.isArray(schema.required)) return [];
@@ -82612,13 +83467,13 @@ var require_path = __commonJS({
   "../../node_modules/.pnpm/@protobufjs+path@1.1.2/node_modules/@protobufjs/path/index.js"(exports) {
     "use strict";
     var path2 = exports;
-    var isAbsolute13 = (
+    var isAbsolute14 = (
       /**
        * Tests if the specified path is absolute.
        * @param {string} path Path to test
        * @returns {boolean} `true` if path is absolute
        */
-      path2.isAbsolute = function isAbsolute14(path3) {
+      path2.isAbsolute = function isAbsolute15(path3) {
         return /^(?:\/|\w+:)/.test(path3);
       }
     );
@@ -82630,7 +83485,7 @@ var require_path = __commonJS({
        */
       path2.normalize = function normalize3(path3) {
         path3 = path3.replace(/\\/g, "/").replace(/\/{2,}/g, "/");
-        var parts = path3.split("/"), absolute = isAbsolute13(path3), prefix = "";
+        var parts = path3.split("/"), absolute = isAbsolute14(path3), prefix = "";
         if (absolute)
           prefix = parts.shift() + "/";
         for (var i2 = 0; i2 < parts.length; ) {
@@ -82652,7 +83507,7 @@ var require_path = __commonJS({
     path2.resolve = function resolve19(originPath, includePath, alreadyNormalized) {
       if (!alreadyNormalized)
         includePath = normalize2(includePath);
-      if (isAbsolute13(includePath))
+      if (isAbsolute14(includePath))
         return includePath;
       if (!alreadyNormalized)
         originPath = normalize2(originPath);
@@ -86926,7 +87781,7 @@ function shapeInput(key, entry2, upstream, supplied, issues) {
   for (const [name, value] of defaults) {
     if (!usable("defaults", name)) continue;
     const property = shaped[name];
-    shaped[name] = { ...isRecord11(property) ? property : {}, default: value };
+    shaped[name] = { ...isRecord12(property) ? property : {}, default: value };
     required = required.filter((other) => other !== name);
   }
   const renamed = /* @__PURE__ */ new Map();
@@ -86972,7 +87827,7 @@ function selectTree(paths) {
   return root;
 }
 function trimObject(schema, children) {
-  if (!isRecord11(schema.properties)) return schema;
+  if (!isRecord12(schema.properties)) return schema;
   const properties = schema.properties;
   const kept = {};
   for (const [name, node2] of children) {
@@ -86986,9 +87841,9 @@ function trimObject(schema, children) {
   return out;
 }
 function trimNode(schema, node2) {
-  if (node2.whole || !isRecord11(schema)) return schema;
+  if (node2.whole || !isRecord12(schema)) return schema;
   if (!node2.array) return trimObject(schema, node2.children);
-  return isRecord11(schema.items) ? { ...schema, items: trimObject(schema.items, node2.children) } : schema;
+  return isRecord12(schema.items) ? { ...schema, items: trimObject(schema.items, node2.children) } : schema;
 }
 function selectOutput(outputSchema, select) {
   if (select.length === 0) return outputSchema;
@@ -87660,12 +88515,12 @@ function walkSchemas(root, at, visit2) {
       node2.forEach((item, index) => walk(item, `${path2}[${index}]`, depth + 1));
       return;
     }
-    if (!isRecord11(node2) || above.has(node2)) return;
+    if (!isRecord12(node2) || above.has(node2)) return;
     visit2(node2, path2);
     above.add(node2);
     for (const [key, value] of Object.entries(node2)) {
       if (DATA.has(key)) continue;
-      if (SCHEMA_MAPS.has(key) && isRecord11(value)) {
+      if (SCHEMA_MAPS.has(key) && isRecord12(value)) {
         for (const [name, child] of Object.entries(value)) walk(child, `${path2}.${key}.${name}`, depth + 1);
       } else {
         walk(value, `${path2}.${key}`, depth + 1);
@@ -87676,14 +88531,14 @@ function walkSchemas(root, at, visit2) {
   walk(root, at, 0);
 }
 function tagOf(schema) {
-  if (!isRecord11(schema)) return void 0;
+  if (!isRecord12(schema)) return void 0;
   if (Object.hasOwn(schema, "const")) return JSON.stringify(schema.const);
   if (Array.isArray(schema.enum) && schema.enum.length === 1) return JSON.stringify(schema.enum[0]);
   return void 0;
 }
 function distinguishable(branches) {
   if (branches.length < 2) return true;
-  const records = branches.filter(isRecord11);
+  const records = branches.filter(isRecord12);
   const [first] = records;
   if (first === void 0 || records.length < branches.length) return false;
   const types = records.map((branch) => branch.type);
@@ -87774,7 +88629,7 @@ function shapedInput(entry2, upstream) {
   for (const [name, value] of defaults) {
     if (!Object.hasOwn(shaped, name)) continue;
     const property = shaped[name];
-    shaped[name] = { ...isRecord11(property) ? property : {}, default: value };
+    shaped[name] = { ...isRecord12(property) ? property : {}, default: value };
     required = required.filter((other) => other !== name);
   }
   const renamed = new Map(rename3.filter(([from]) => Object.hasOwn(shaped, from)));
@@ -87804,7 +88659,7 @@ function selectTree2(paths) {
   return root;
 }
 function trimObject2(schema, children) {
-  if (!isRecord11(schema.properties)) return schema;
+  if (!isRecord12(schema.properties)) return schema;
   const properties = schema.properties;
   const kept = {};
   for (const [name, node2] of children) {
@@ -87818,9 +88673,9 @@ function trimObject2(schema, children) {
   return out;
 }
 function trimNode2(schema, node2) {
-  if (node2.whole || !isRecord11(schema)) return schema;
+  if (node2.whole || !isRecord12(schema)) return schema;
   if (!node2.array) return trimObject2(schema, node2.children);
-  return isRecord11(schema.items) ? { ...schema, items: trimObject2(schema.items, node2.children) } : schema;
+  return isRecord12(schema.items) ? { ...schema, items: trimObject2(schema.items, node2.children) } : schema;
 }
 function servedOutput(outputSchema, select) {
   if (select.length === 0) return outputSchema;
@@ -87870,7 +88725,7 @@ function quoted(values) {
   return orList2(values.map((value) => JSON.stringify(value)));
 }
 function isArraySchema(schema) {
-  if (!isRecord11(schema)) return false;
+  if (!isRecord12(schema)) return false;
   return schema.type === "array" || Array.isArray(schema.type) && schema.type.includes("array");
 }
 function lintTools(folder, context, report) {
@@ -88047,7 +88902,7 @@ function lintUpstream(folder, context, key, entry2, upstream, report) {
     });
   }
   const oneOf2 = (node2, at) => {
-    if (!Array.isArray(node2.oneOf) || isRecord11(node2.discriminator) || distinguishable(node2.oneOf)) return;
+    if (!Array.isArray(node2.oneOf) || isRecord12(node2.discriminator) || distinguishable(node2.oneOf)) return;
     report("undiscriminated_one_of", {
       tool: key,
       field: `${at}.oneOf`,
@@ -88657,7 +89512,7 @@ function upstreamError(response, bytes) {
   let problem;
   if (text4 !== "" && isJsonMediaType(headerValue(response.headers, "content-type"))) {
     const parsed = parseJson3(text4);
-    if (parsed.ok && isRecord9(parsed.value)) problem = parsed.value;
+    if (parsed.ok && isRecord10(parsed.value)) problem = parsed.value;
   }
   const title = problem === void 0 ? void 0 : firstText(problem, ["title"]);
   const detail = problem === void 0 ? text4.trim() === "" ? void 0 : text4 : firstText(problem, ["detail", "message", "error_description", "error"]);
@@ -88841,11 +89696,11 @@ var init_apply_credential = __esm({
 
 // ../../packages/mcp-studio/src/execute/mcp.ts
 function toolResult(value) {
-  if (!isRecord9(value)) return { ok: false, detail: "The tools/call result is not an object." };
+  if (!isRecord10(value)) return { ok: false, detail: "The tools/call result is not an object." };
   if (!isList(value.content)) return { ok: false, detail: "The tools/call result has no content list." };
   const content = [];
   for (const [index, item] of value.content.entries()) {
-    if (!isRecord9(item) || typeof item.type !== "string") {
+    if (!isRecord10(item) || typeof item.type !== "string") {
       return { ok: false, detail: `Content item ${index} is not an object with a string type.` };
     }
     content.push({ ...item, type: item.type });
@@ -88853,7 +89708,7 @@ function toolResult(value) {
   const result2 = { content };
   const structured = value.structuredContent;
   if (structured !== void 0 && structured !== null) {
-    if (!isRecord9(structured)) return { ok: false, detail: "The tools/call result's structuredContent is not an object." };
+    if (!isRecord10(structured)) return { ok: false, detail: "The tools/call result's structuredContent is not an object." };
     result2.structuredContent = structured;
   }
   const isError = value.isError;
@@ -88972,7 +89827,7 @@ function rejectedAttempt(response, failure2) {
 function findResponse(value, id) {
   const messages = isList(value) ? value : [value];
   for (const message of messages) {
-    if (isRecord9(message) && message.id === id && !Object.hasOwn(message, "method")) return message;
+    if (isRecord10(message) && message.id === id && !Object.hasOwn(message, "method")) return message;
   }
   return void 0;
 }
@@ -89022,8 +89877,8 @@ async function readReply(session, response, id, what) {
   return { ok: true, value: message };
 }
 function rpcError2(error) {
-  const message = isRecord9(error) && typeof error.message === "string" ? error.message : JSON.stringify(error);
-  const code = isRecord9(error) && typeof error.code === "number" ? ` (code ${error.code})` : "";
+  const message = isRecord10(error) && typeof error.message === "string" ? error.message : JSON.stringify(error);
+  const code = isRecord10(error) && typeof error.code === "number" ? ` (code ${error.code})` : "";
   return { title: "MCP error", detail: cutDetail(`${message}${code}`), status: void 0 };
 }
 async function initialize(session) {
@@ -89050,7 +89905,7 @@ async function initialize(session) {
   if (!reply2.ok) return reply2;
   if (Object.hasOwn(reply2.value, "error")) return { ok: false, error: rpcError2(reply2.value.error) };
   const result2 = reply2.value.result;
-  if (!isRecord9(result2)) return invalidResponse("The MCP server's initialize result is not an object.", response.status);
+  if (!isRecord10(result2)) return invalidResponse("The MCP server's initialize result is not an object.", response.status);
   const version2 = result2.protocolVersion;
   session.protocol = typeof version2 === "string" && PROTOCOL_VERSION2.test(version2) ? version2 : MCP_PROTOCOL_VERSION2;
   return { ok: true, value: void 0 };
@@ -89252,8 +90107,8 @@ function firstPosition(paging, args, options) {
   if (paging.style === "offset") return 0;
   const properties = options.inputSchema.properties;
   const name = options.agentName(paging.input);
-  const property = isRecord9(properties) && Object.hasOwn(properties, name) ? properties[name] : void 0;
-  if (isRecord9(property)) {
+  const property = isRecord10(properties) && Object.hasOwn(properties, name) ? properties[name] : void 0;
+  if (isRecord10(property)) {
     const fallback = wholeNumber(property.default) ?? wholeNumber(property.minimum);
     if (fallback !== void 0) return fallback;
   }
@@ -89351,11 +90206,11 @@ function errorText4(error) {
 function asSentence(text4) {
   return /[.!?…]$/.test(text4) ? text4 : `${text4}.`;
 }
-function plural3(count7, one, many) {
+function plural4(count7, one, many) {
   return `${count7} ${count7 === 1 ? one : many}`;
 }
 function pagingNote(paged, options) {
-  const read2 = `${plural3(paged.items, "item", "items")} from ${plural3(paged.pages, "page", "pages")}`;
+  const read2 = `${plural4(paged.items, "item", "items")} from ${plural4(paged.pages, "page", "pages")}`;
   switch (paged.stop) {
     case "last_page":
       return void 0;
@@ -89403,7 +90258,7 @@ function graphqlDocument(template, args) {
   return { query, variables: Object.fromEntries(present.map((a) => [a.name, args[a.property]])) };
 }
 function errorMessages(errors) {
-  return errors.map((entry2) => isRecord9(entry2) && typeof entry2.message === "string" ? entry2.message : JSON.stringify(entry2)).join("; ");
+  return errors.map((entry2) => isRecord10(entry2) && typeof entry2.message === "string" ? entry2.message : JSON.stringify(entry2)).join("; ");
 }
 function invalidResponse2(detail, status2) {
   return { ok: false, error: { title: "Invalid response", detail, status: status2 } };
@@ -89414,14 +90269,14 @@ function interpret(template) {
     const status2 = response.status;
     const parsed = bytes.byteLength === 0 ? void 0 : parseJson3(decodeText2(bytes));
     const body2 = parsed?.ok === true ? parsed.value : void 0;
-    if (isRecord9(body2) && isList(body2.errors) && body2.errors.length > 0) {
+    if (isRecord10(body2) && isList(body2.errors) && body2.errors.length > 0) {
       return { ok: false, error: { title: "GraphQL error", detail: cutDetail(errorMessages(body2.errors)), status: status2 } };
     }
     if (status2 < 200 || status2 >= 300) return { ok: false, error: upstreamError(response, bytes) };
     if (parsed === void 0) return invalidResponse2(`The upstream answered ${status2} with no body.`, status2);
     if (!parsed.ok) return invalidResponse2(`The upstream answered ${status2} with JSON that does not parse: ${parsed.message}`, status2);
-    const data = isRecord9(body2) ? body2.data : void 0;
-    if (!isRecord9(data)) return invalidResponse2(`The upstream answered ${status2} with no data object.`, status2);
+    const data = isRecord10(body2) ? body2.data : void 0;
+    if (!isRecord10(data)) return invalidResponse2(`The upstream answered ${status2} with no data object.`, status2);
     if (!Object.hasOwn(data, field)) return invalidResponse2(`The response's data has no ${field} field.`, status2);
     const value = data[field];
     return { ok: true, value: isList(value) ? { items: value } : value };
@@ -107716,7 +108571,7 @@ function scalarText(value, name) {
 }
 function shapeOf(value, name) {
   if (isList(value)) return { kind: "list", items: value.map((item) => scalarText(item, name)) };
-  if (isRecord9(value)) {
+  if (isRecord10(value)) {
     return {
       kind: "object",
       entries: Object.entries(value).filter(([, item]) => item !== void 0).map(([key, item]) => [key, scalarText(item, name)])
@@ -107837,7 +108692,7 @@ function formText(value) {
   throw invalidArguments(`A form body cannot carry a ${typeof value} value.`);
 }
 function formBody(value) {
-  if (!isRecord9(value)) throw invalidArguments("A form body takes an object.");
+  if (!isRecord10(value)) throw invalidArguments("A form body takes an object.");
   const form = new URLSearchParams();
   for (const [key, item] of Object.entries(value)) {
     const items = (isList(item) ? item : [item]).filter((one) => one !== void 0);
@@ -108065,7 +108920,7 @@ function project(value, at) {
     const each = at.each;
     return value.map((item) => project(item, each)).filter((item) => item !== ABSENT);
   }
-  if (isRecord9(value) && at.fields.size > 0) {
+  if (isRecord10(value) && at.fields.size > 0) {
     const kept = [];
     for (const [name, child] of at.fields) {
       if (!Object.hasOwn(value, name)) continue;
@@ -108082,7 +108937,7 @@ function remove(value, at) {
     const each = at.each;
     return value.map((item) => remove(item, each)).filter((item) => item !== ABSENT);
   }
-  if (isRecord9(value) && at.fields.size > 0) {
+  if (isRecord10(value) && at.fields.size > 0) {
     const kept = [];
     for (const [name, item] of Object.entries(value)) {
       const child = at.fields.get(name);
@@ -108118,10 +108973,10 @@ function shapeRecord(value, rules, isError) {
   let out = value;
   if (rules.select !== void 0 && !isError) out = project(out, rules.select);
   if (rules.redact !== void 0) out = remove(out, rules.redact);
-  return isRecord9(out) ? out : {};
+  return isRecord10(out) ? out : {};
 }
 function shapeJson(value, rules) {
-  return isRecord9(value) ? shapeRecord(value, rules, false) : value;
+  return isRecord10(value) ? shapeRecord(value, rules, false) : value;
 }
 function byteLength(text4) {
   return encodeText(text4).byteLength;
@@ -108148,7 +109003,7 @@ function resultBytes(content, structured) {
 }
 function jsonResult(value, text4) {
   const result2 = { content: [textItem(text4)] };
-  if (isRecord9(value)) result2.structuredContent = value;
+  if (isRecord10(value)) result2.structuredContent = value;
   return result2;
 }
 function fitsCap(result2, rules) {
@@ -108203,7 +109058,7 @@ function shapeTextItem(item, rules, isError) {
   const text4 = item.text;
   if (typeof text4 !== "string") return item;
   const parsed = parseJson3(text4);
-  if (!parsed.ok || !isRecord9(parsed.value)) return item;
+  if (!parsed.ok || !isRecord10(parsed.value)) return item;
   return { ...item, text: JSON.stringify(shapeRecord(parsed.value, rules, isError)) };
 }
 function shapeToolResult(result2, rules, notes) {
@@ -108268,7 +109123,7 @@ function hasType(type, value) {
     case "boolean":
       return typeof value === "boolean";
     case "object":
-      return isRecord9(value);
+      return isRecord10(value);
     case "array":
       return isList(value);
     default:
@@ -108279,10 +109134,10 @@ function checkString(schema, value, path2) {
   const issues = [];
   const length = [...value].length;
   if (typeof schema.minLength === "number" && length < schema.minLength) {
-    issues.push(`${path2} must be at least ${schema.minLength} ${plural4(schema.minLength, "character")} long.`);
+    issues.push(`${path2} must be at least ${schema.minLength} ${plural5(schema.minLength, "character")} long.`);
   }
   if (typeof schema.maxLength === "number" && length > schema.maxLength) {
-    issues.push(`${path2} must be at most ${schema.maxLength} ${plural4(schema.maxLength, "character")} long.`);
+    issues.push(`${path2} must be at most ${schema.maxLength} ${plural5(schema.maxLength, "character")} long.`);
   }
   if (typeof schema.pattern === "string" && testPattern(schema.pattern, value) === false) {
     issues.push(`${path2} must match the pattern ${schema.pattern}.`);
@@ -108340,7 +109195,7 @@ function resolveRef(root, ref2) {
       const index = Number(token);
       if (!Number.isInteger(index) || index < 0 || index >= current.length) return void 0;
       current = current[index];
-    } else if (isRecord9(current) && Object.hasOwn(current, token)) {
+    } else if (isRecord10(current) && Object.hasOwn(current, token)) {
       current = current[token];
     } else {
       return void 0;
@@ -108350,7 +109205,7 @@ function resolveRef(root, ref2) {
 }
 function canonical2(value) {
   if (isList(value)) return `[${value.map(canonical2).join(",")}]`;
-  if (isRecord9(value)) {
+  if (isRecord10(value)) {
     const keys = Object.keys(value).sort();
     return `{${keys.map((key) => `${JSON.stringify(key)}:${canonical2(value[key])}`).join(",")}}`;
   }
@@ -108364,7 +109219,7 @@ function listOf(values) {
   const more = values.length - shown2.length;
   return more > 0 ? `${shown2.join(", ")}, and ${more} more` : shown2.join(", ");
 }
-function plural4(count7, one, many = `${one}s`) {
+function plural5(count7, one, many = `${one}s`) {
   return count7 === 1 ? one : many;
 }
 var MAX_DEPTH2, MAX_STEPS, MAX_ISSUES, TYPE_NAMES, Checker;
@@ -108394,7 +109249,7 @@ var init_validate = __esm({
         this.steps += 1;
         if (depth > MAX_DEPTH2 || this.steps > MAX_STEPS) return [];
         if (schema === false) return [`${path2} is not allowed.`];
-        if (!isRecord9(schema)) return [];
+        if (!isRecord10(schema)) return [];
         if (value === null && schema.nullable === true) return [];
         const issues = [];
         if (typeof schema.$ref === "string") {
@@ -108412,7 +109267,7 @@ var init_validate = __esm({
         if (typeof value === "string") issues.push(...checkString(schema, value, path2));
         else if (typeof value === "number") issues.push(...checkNumber(schema, value, path2));
         else if (isList(value)) issues.push(...this.checkArray(schema, value, path2, depth));
-        else if (isRecord9(value)) issues.push(...this.checkObject(schema, value, path2, depth));
+        else if (isRecord10(value)) issues.push(...this.checkObject(schema, value, path2, depth));
         issues.push(...this.checkCombinators(schema, value, path2, depth));
         return issues;
       }
@@ -108422,10 +109277,10 @@ var init_validate = __esm({
       checkArray(schema, value, path2, depth) {
         const issues = [];
         if (typeof schema.minItems === "number" && value.length < schema.minItems) {
-          issues.push(`${path2} must have at least ${schema.minItems} ${plural4(schema.minItems, "item")}.`);
+          issues.push(`${path2} must have at least ${schema.minItems} ${plural5(schema.minItems, "item")}.`);
         }
         if (typeof schema.maxItems === "number" && value.length > schema.maxItems) {
-          issues.push(`${path2} must have at most ${schema.maxItems} ${plural4(schema.maxItems, "item")}.`);
+          issues.push(`${path2} must have at most ${schema.maxItems} ${plural5(schema.maxItems, "item")}.`);
         }
         if (schema.uniqueItems === true) {
           const seen = /* @__PURE__ */ new Set();
@@ -108457,13 +109312,13 @@ var init_validate = __esm({
           }
         }
         if (typeof schema.minProperties === "number" && present.length < schema.minProperties) {
-          issues.push(`${path2} must have at least ${schema.minProperties} ${plural4(schema.minProperties, "property", "properties")}.`);
+          issues.push(`${path2} must have at least ${schema.minProperties} ${plural5(schema.minProperties, "property", "properties")}.`);
         }
         if (typeof schema.maxProperties === "number" && present.length > schema.maxProperties) {
-          issues.push(`${path2} must have at most ${schema.maxProperties} ${plural4(schema.maxProperties, "property", "properties")}.`);
+          issues.push(`${path2} must have at most ${schema.maxProperties} ${plural5(schema.maxProperties, "property", "properties")}.`);
         }
-        const properties = isRecord9(schema.properties) ? schema.properties : {};
-        const patterns = isRecord9(schema.patternProperties) ? Object.entries(schema.patternProperties) : [];
+        const properties = isRecord10(schema.properties) ? schema.properties : {};
+        const patterns = isRecord10(schema.patternProperties) ? Object.entries(schema.patternProperties) : [];
         for (const key of present) {
           const at = propertyPath(path2, key);
           let known = false;
@@ -108743,7 +109598,7 @@ function differenceAt(path2, expected, actual) {
     if (expected.length === actual.length) return void 0;
     return { path: `${path2}[${shared}]`, expected: expected[shared], actual: actual[shared] };
   }
-  if (isRecord9(expected) && isRecord9(actual)) {
+  if (isRecord10(expected) && isRecord10(actual)) {
     for (const key of Object.keys(expected)) {
       const found = differenceAt(keyPath(path2, key), expected[key], Object.hasOwn(actual, key) ? actual[key] : void 0);
       if (found !== void 0) return found;
@@ -108821,7 +109676,7 @@ function rpcMessage(request3) {
   const parsed = parseJson3(decodeText2(request3.body));
   if (!parsed.ok) return void 0;
   const value = isList(parsed.value) ? parsed.value[0] : parsed.value;
-  return isRecord9(value) ? value : void 0;
+  return isRecord10(value) ? value : void 0;
 }
 function replayTransport(exchanges, route) {
   let next = 0;
@@ -109530,7 +110385,7 @@ import {
   readlinkSync as readlinkSync3,
   statSync as statSync11
 } from "node:fs";
-import { dirname as dirname27, isAbsolute as isAbsolute12, join as join47, relative as relative7, resolve as resolve18, sep as sep7 } from "node:path";
+import { dirname as dirname27, isAbsolute as isAbsolute13, join as join48, relative as relative8, resolve as resolve18, sep as sep7 } from "node:path";
 function git5(cwd, args, input) {
   try {
     return execFileSync2("git", args, {
@@ -109557,7 +110412,7 @@ function commitOf(root, ref2) {
   return sha.length > 0 ? sha : null;
 }
 function readWorkingFile(root, path2) {
-  const abs = join47(root, ...path2.split("/"));
+  const abs = join48(root, ...path2.split("/"));
   try {
     const stat5 = lstatSync10(abs);
     if (stat5.isSymbolicLink()) return readlinkSync3(abs, "utf8");
@@ -109651,7 +110506,7 @@ function isDir(path2) {
 function findSteeringRoot(start) {
   let dir = resolve18(start);
   for (; ; ) {
-    if (isFile(join47(dir, WORKSPACE_TOML_PATH)) || isFile(join47(dir, AGENTS_MD_PATH)) && isDir(join47(dir, STEERING_DIR))) {
+    if (isFile(join48(dir, WORKSPACE_TOML_PATH)) || isFile(join48(dir, AGENTS_MD_PATH)) && isDir(join48(dir, STEERING_DIR))) {
       return dir;
     }
     const parent = dirname27(dir);
@@ -109665,8 +110520,8 @@ function within3(path2, scope) {
 function scopesFor(root, cwd, paths, trees) {
   const scopes = [];
   for (const path2 of paths) {
-    const rel = relative7(root, resolve18(cwd, path2));
-    if (rel === ".." || rel.startsWith(`..${sep7}`) || isAbsolute12(rel)) {
+    const rel = relative8(root, resolve18(cwd, path2));
+    if (rel === ".." || rel.startsWith(`..${sep7}`) || isAbsolute13(rel)) {
       return { error: `${path2} is outside the steering repo at ${root}.` };
     }
     const scope = rel.split(sep7).join("/");
@@ -109731,7 +110586,7 @@ function cacheFile(cacheDir, root) {
     key: token === void 0 ? null : createHash20("sha256").update(token).digest("hex").slice(0, 16)
   };
   const key = createHash20("sha256").update(JSON.stringify([root, identity])).digest("hex").slice(0, 32);
-  return join47(cacheDir, `${key}.json`);
+  return join48(cacheDir, `${key}.json`);
 }
 function readCache(file, now) {
   let entry2;
@@ -109830,7 +110685,7 @@ async function fetchSteeringIndex(root) {
 function defaultDeps2() {
   return {
     fetchPublished: fetchSteeringIndex,
-    cacheDir: join47(getConfigDir(), "cache", "steering-check"),
+    cacheDir: join48(getConfigDir(), "cache", "steering-check"),
     now: () => Date.now()
   };
 }
@@ -112086,7 +112941,7 @@ function buildProgram() {
     }
   );
   const steeringCmd = program2.command("steering").description(
-    "Steering records: whether .oxagen/ carries the ones merged on the production branch, and Markdown import"
+    "Steering records: whether .oxagen/ carries the ones merged on the production branch, Markdown import, and instruction file findings"
   );
   steeringCmd.command("status").description(
     "Compare .oxagen/ against the remote production branch and show the two gates"
@@ -112142,6 +112997,26 @@ function buildProgram() {
       await handleSteeringImport2(paths, opts);
     }
   );
+  steeringCmd.command("findings").description(
+    "List the statements in linked repositories' instruction files that repeat or contradict a steering record"
+  ).option("--json", "Output JSON").action(async (opts) => {
+    const { steeringFindings: steeringFindings2 } = await Promise.resolve().then(() => (init_steering_findings(), steering_findings_exports));
+    await steeringFindings2(opts);
+  });
+  steeringCmd.command("promote").argument("<finding-id>", "The crf_\u2026 id `oxagen steering findings` shows").description(
+    "Propose a new version of the record a statement contradicts, with the statement as its text, and open its steering PR"
+  ).option("--json", "Output JSON").action(async (findingId, opts) => {
+    const { steeringPromote: steeringPromote2 } = await Promise.resolve().then(() => (init_steering_promote(), steering_promote_exports));
+    await steeringPromote2(findingId, opts);
+  });
+  steeringCmd.command("restore-block").argument("<proposal-id>", "The prp_\u2026 proposal whose steering PR holds the file").argument("<path>", "AGENTS.md, CLAUDE.md, or README.md").description(
+    "Restore Oxagen's managed block in one file of an open steering PR, as one commit from the production branch"
+  ).option("--json", "Output JSON").action(
+    async (proposalId, path2, opts) => {
+      const { steeringRestoreBlock: steeringRestoreBlock2 } = await Promise.resolve().then(() => (init_steering_restore_block(), steering_restore_block_exports));
+      await steeringRestoreBlock2(proposalId, path2, opts);
+    }
+  );
   const toolsCmd = program2.command("tools").description("The workspace's connected MCP servers and their tools");
   toolsCmd.command("migrate").description(
     "Open the pull request that moves the workspace's MCP servers into its steering repo, or print the one already open"
@@ -112156,7 +113031,7 @@ function buildProgram() {
     "The repository root to mount at /workspace (default: the current directory)"
   ).option(
     "--github-repository <owner/name>",
-    "The one repository the run may reach, with a token in OXAGEN_CONTAINED_GITHUB_TOKEN"
+    "The one repository the run may fetch and push, through Oxagen's Git custody. The workspace must have it bound."
   ).argument("[command...]", "After --: claude or codex, then its arguments").action(
     async (command2, opts) => {
       if (command2.length === 0) {
@@ -112724,7 +113599,7 @@ function buildProgram() {
     "With --contained: the repository root to mount at /workspace (default: the current directory)"
   ).option(
     "--github-repository <owner/name>",
-    "With --contained: the one repository the run may reach, with a token in OXAGEN_CONTAINED_GITHUB_TOKEN"
+    "With --contained: the one repository the run may fetch and push, through Oxagen's Git custody. The workspace must have it bound."
   ).argument("[command...]", "After --: the agent's command and its arguments").action(
     async (command2, opts) => {
       const { handleAgentRun: handleAgentRun2 } = await Promise.resolve().then(() => (init_tacho(), tacho_exports));