@coreplane/switchboard 1.231.0 → 1.232.0

package/dist/assets/deploy/cloudflare/knownLength.ts

@@ -0,0 +1,43 @@
+// The container's answer, re-framed so its length survives to the browser.
+//
+// The bot writes `Content-Length` on every whole-object artifact answer
+// (src/channels/liveView.ts `serveArtifact`), and locally the header is there.
+// Live, a `200` for a 31 MB video reached the browser with no length while the
+// `206` answers for the same bytes kept theirs: somewhere past the container
+// the passthrough became a stream of unknown length. A player that falls back
+// from ranges to a plain read of such a stream cannot seek and, with
+// `preload="metadata"` on a file whose index sits at the end, never finds it.
+//
+// The Workers runtime emits `Content-Length` for a body it knows the length
+// of, and `FixedLengthStream` is how a body declares one: this re-wraps the
+// container's answer through a pipe sized by the container's own header. The
+// pipe also refuses a body of another length, so a short or long upstream
+// fails the response instead of lying about it. Pure over the Response and a
+// pipe factory, so it is tested here with a fake pipe and wired in worker.ts
+// with `new FixedLengthStream(size)`.
+
+/** `new FixedLengthStream(size)` in workerd; a fake in tests. */
+export type LengthPipe = (size: number) => {
+  readable: ReadableStream<Uint8Array>;
+  writable: WritableStream<Uint8Array>;
+};
+
+/** A response that could carry a WebSocket (workerd's `Response` does). */
+type MaybeSocket = Response & { webSocket?: unknown };
+
+/** The same answer with its body declared at the length the container named.
+ *  Untouched: an answer with no body, one whose `Content-Length` is missing
+ *  or not a byte count, a zero-length one, and a WebSocket upgrade — each is
+ *  either already known-length or not a byte stream at all. */
+export function withKnownLength(res: Response, lengthPipe: LengthPipe): Response {
+  if (res.body === null || (res as MaybeSocket).webSocket) return res;
+  const header = res.headers.get("content-length");
+  if (header === null || !/^\d{1,15}$/.test(header)) return res;
+  const size = Number(header);
+  if (size === 0) return res;
+  const { readable, writable } = lengthPipe(size);
+  // The pipe's own failure (a body of another length) ends the readable with
+  // that error; nothing here swallows it into a clean end.
+  void res.body.pipeTo(writable).catch(() => undefined);
+  return new Response(readable, res);
+}

package/dist/assets/deploy/cloudflare/worker.ts

@@ -47,6 +47,7 @@ import { systemClock } from "../../src/core/trace/clock.ts";
 import { createTracer } from "../../src/core/trace/tracer.ts";
 import { shimRoute, stripTraceContext, withTraceContext, workerLogSink } from "../../src/core/trace/workerTrace.ts";
 import { COPY_PATH, handleArtifactsCopy } from "./artifactsCopy.ts";
+import { withKnownLength } from "./knownLength.ts";
 import type { ShipCoordinatorParams } from "./coordinator";
 import { INSTANCE, INTERNAL } from "./shared";
 
@@ -414,6 +415,13 @@ async function recordFiring(env: Env, firing: ScheduleFiring): Promise<void> {
   if (!res.ok) console.error(`[schedule] ${firing.schedule}: recording the firing failed — ${res.reason}`);
 }
 
+/** The container's answer with the length it named declared to the runtime
+ *  (knownLength.ts): live, a whole-object artifact `200` lost its
+ *  `Content-Length` between the container and the browser while the `206`s
+ *  kept theirs, and a player that falls back to a plain read of a stream it
+ *  cannot size never finds an index at the end of the file. */
+const withLength = (res: Response): Response => withKnownLength(res, (size) => new FixedLengthStream(size));
+
 export default {
   async fetch(request: Request, env: Env): Promise<Response> {
     const pathname = new URL(request.url).pathname;
@@ -425,7 +433,7 @@ export default {
     // authorize call below); a caller cannot be allowed to speak it.
     const inbound = stripRestartSubject(stripTraceContext(request));
     const route = shimRoute(pathname);
-    if (route === undefined) return getContainer(env.SWITCHBOARD, INSTANCE).fetch(inbound);
+    if (route === undefined) return withLength(await getContainer(env.SWITCHBOARD, INSTANCE).fetch(inbound));
     const root = tracer.start("bot-shim.fetch", { sinks: traceSinks, attrs: { route } });
     try {
       const forwarded = withTraceContext(inbound, root);
@@ -454,7 +462,7 @@ export default {
                     fetch: (input, init) => fetch(input, init),
                     lengthPipe: (size) => new FixedLengthStream(size),
                   })
-                : await getContainer(env.SWITCHBOARD, INSTANCE).fetch(forwarded);
+                : withLength(await getContainer(env.SWITCHBOARD, INSTANCE).fetch(forwarded));
       root.end(res.status >= 500 ? "error" : "ok", { httpStatus: res.status });
       return res;
     } catch (err) {

package/dist/assets/deploy/cloudflare-resident/worker.ts

@@ -1110,9 +1110,12 @@ const NO_REF_HINT_REASON: RefHintReason = { ownPr: null, refByDefault: false };
 type RebindOutcome =
   | { kind: "none"; binding: ThreadBinding }
   | { kind: "refuse"; refused: RebindRefused }
-  /** `note`: the move was the record alone — a dirty tree already on the
-   *  branch, no checkout run — in the verdict's words, for the log line. */
-  | { kind: "rebound"; moved: ThreadBinding; rebound: Rebound; note?: string };
+  | { kind: "rebound"; moved: ThreadBinding; rebound: Rebound; keepTree: false }
+  /** The move was the record alone — a dirty tree already on the branch, no
+   *  checkout run — with the verdict's `note` for the log line. The attach
+   *  that follows must keep that tree (`keepTree`, the worktree step's word
+   *  for it): the promise the note makes is the attach's to keep. */
+  | { kind: "rebound"; moved: ThreadBinding; rebound: Rebound; keepTree: true; note: string };
 
 /** Result of one /op test/build execution. `ok` is the command's
  *  verdict — a failing test run is a RESULT with ok:false, never an error. */
@@ -4570,6 +4573,7 @@ export class ResidentDO extends Sandbox<Env> {
         refHint,
         wantSha,
         reuse,
+        keepTree: rebind.keepTree === true,
         slug,
         t0,
         facts,
@@ -4595,16 +4599,32 @@ export class ResidentDO extends Sandbox<Env> {
    *  mirror mutex so no other attach of the thread touches the tree meanwhile.
    *  The rest of the attach then runs on the moved ref: the mirror fetch for
    *  the PR head (item 51) and item 17's stale check, which keeps a tree whose
-   *  HEAD is the ref's tip or a descendant of it. The binding records the move
-   *  (`rebound`); the answer carries it, or the named refusal, so the bot can
-   *  say where the follow-up runs and why. A refusal never fails the attach. */
+   *  HEAD is the ref's tip or a descendant of it. When the verdict moved the
+   *  record alone — a dirty tree with the branch already checked out — the
+   *  answer says so (`keepTree`) and the worktree step keeps that tree, dirt
+   *  included, instead of item 17's dirty wipe: the promise not to touch it is
+   *  the whole attach's. The binding records the move (`rebound`); the answer
+   *  carries it, or the named refusal, so the bot can say where the follow-up
+   *  runs and why. A refusal never fails the attach. */
   private async rebindToOwnPr(
     prior: ThreadBinding | undefined,
     ownPr: OwnPr | null,
     reuse: boolean,
     defaultRef: string,
     slug: string,
-  ): Promise<{ binding: ThreadBinding | undefined; rebound?: Rebound; rebindRefused?: RebindRefused } | ThreadErr> {
+  ): Promise<
+    | {
+        binding: ThreadBinding | undefined;
+        rebound?: Rebound;
+        rebindRefused?: RebindRefused;
+        /** The move was the record alone — the tree is dirty with the branch
+         *  already checked out — and the attach must keep that tree as it
+         *  stands: the worktree step's item 17 wipe of a dirty tree would
+         *  destroy the very work the rebind declined to touch. */
+        keepTree?: true;
+      }
+    | ThreadErr
+  > {
     const plan = rebindPlan({ ownPr, reuse, binding: prior, defaultRef });
     if (plan.kind === "none" || prior === undefined) return { binding: prior };
     if (plan.kind === "refuse") return { binding: prior, rebindRefused: plan.refused };
@@ -4704,8 +4724,8 @@ export class ResidentDO extends Sandbox<Env> {
           const moved: ThreadBinding = { ...current, ref: again.to, rebound };
           await this.ctx.storage.put(key, moved);
           return verdict.checkout
-            ? { kind: "rebound", moved, rebound }
-            : { kind: "rebound", moved, rebound, note: verdict.note };
+            ? { kind: "rebound", moved, rebound, keepTree: false }
+            : { kind: "rebound", moved, rebound, keepTree: true, note: verdict.note };
         }, ATTACH_MUTEX_WAIT_MS)
       ).value;
     } catch (err) {
@@ -4723,10 +4743,16 @@ export class ResidentDO extends Sandbox<Env> {
       return { binding: prior, rebindRefused: outcome.refused };
     }
     const { moved, rebound } = outcome;
+    if (!outcome.keepTree) {
+      console.log(
+        `attach ${prior.threadKey}: rebound ${rebound.from} → ${rebound.to} (the thread's own pull request #${rebound.pr})`,
+      );
+      return { binding: moved, rebound };
+    }
     console.log(
-      `attach ${prior.threadKey}: rebound ${rebound.from} → ${rebound.to} (the thread's own pull request #${rebound.pr})${outcome.note ? ` — ${outcome.note}` : ""}`,
+      `attach ${prior.threadKey}: rebound ${rebound.from} → ${rebound.to} (the thread's own pull request #${rebound.pr}) — ${outcome.note}`,
     );
-    return { binding: moved, rebound };
+    return { binding: moved, rebound, keepTree: true };
   }
 
   /** The move when the thread's tree is gone (item 16): the binding's ref
@@ -4781,7 +4807,7 @@ export class ResidentDO extends Sandbox<Env> {
     };
     const moved: ThreadBinding = { ...current, ref: plan.to, rebound };
     await this.ctx.storage.put(threadBindingKey(current.threadKey), moved);
-    return { kind: "rebound", moved, rebound };
+    return { kind: "rebound", moved, rebound, keepTree: false };
   }
 
   /** The release's word on what the run pushed (`/detach` `pushed`, item
@@ -4809,6 +4835,10 @@ export class ResidentDO extends Sandbox<Env> {
     refHint: string | null;
     wantSha: string | null;
     reuse: boolean;
+    /** The rebind moved the record alone over a dirty tree already on the
+     *  branch (item 16) and promised not to touch it: the worktree step keeps
+     *  the tree as it stands instead of item 17's dirty wipe. */
+    keepTree: boolean;
     slug: string;
     t0: number;
     facts: RepoFacts;
@@ -4820,7 +4850,7 @@ export class ResidentDO extends Sandbox<Env> {
     rebound?: Rebound;
     rebindRefused?: RebindRefused;
   }): Promise<AttachOk | ThreadErr> {
-    const { threadKey, refHint, wantSha, reuse, slug, t0, facts, record, binding, mode, rollback } = input;
+    const { threadKey, refHint, wantSha, reuse, keepTree, slug, t0, facts, record, binding, mode, rollback } = input;
     const { rebound, rebindRefused } = input;
 
     // Command-level token mint — before the lock so mint latency
@@ -4899,6 +4929,7 @@ export class ResidentDO extends Sandbox<Env> {
         const recreated = await this.ensureThreadWorktree(binding, sha, mode.originUrl, mode.modeSwitch, {
           detached: target.kind === "sha",
           reuse,
+          keepTree,
         });
         return { sha, threadLockKey, recreated };
       }, ATTACH_MUTEX_WAIT_MS);
@@ -5003,10 +5034,13 @@ export class ResidentDO extends Sandbox<Env> {
    *  trees; a reusing attach (`opts.reuse`, item 66) keeps a readable tree
    *  exactly as it stands (the dirt and the HEAD are the resumed run's own
    *  work) and throws `ReuseRefusedError` for one it cannot keep, touching
-   *  nothing. The decision is the pure `decideWorktree`; this method measures
-   *  the facts and runs the verdict. Returns true when the tree was
-   *  (re)created. MUST be called holding the mirror mutex: the clone reads
-   *  the mirror.
+   *  nothing; a provisioning attach whose own rebind moved the record alone
+   *  over a dirty tree already on the branch (`opts.keepTree`, item 16) keeps
+   *  that tree as it stands too — the dirt is why the rebind declined to touch
+   *  it — and provisions one that turns out not to be there. The decision is
+   *  the pure `decideWorktree`; this method measures the facts and runs the
+   *  verdict. Returns true when the tree was (re)created. MUST be called
+   *  holding the mirror mutex: the clone reads the mirror.
    *
    *  "Dirty" is tracked-file dirt (`status --porcelain -uno`): untracked
    *  scratch files are the thread's own state and survive re-attach.
@@ -5029,8 +5063,11 @@ export class ResidentDO extends Sandbox<Env> {
     /** `detached`: the bound ref is gone from the mirror and `sha` is the
      *  expected commit it still holds (item 51) — the tree is checked out at
      *  that commit, detached, instead of at a branch. `reuse`: a resumed
-     *  run's attach (item 66): keep the tree as it stands, or refuse. */
-    opts: { detached: boolean; reuse: boolean } = { detached: false, reuse: false },
+     *  run's attach (item 66): keep the tree as it stands, or refuse.
+     *  `keepTree`: this attach's rebind moved the record alone over a dirty
+     *  tree already on the branch (item 16): keep a readable tree as it
+     *  stands, provision one that is not there. */
+    opts: { detached: boolean; reuse: boolean; keepTree: boolean } = { detached: false, reuse: false, keepTree: false },
   ): Promise<boolean> {
     const wt = binding.worktreePath;
     const threadDir = parentDir(wt);
@@ -5067,7 +5104,14 @@ export class ResidentDO extends Sandbox<Env> {
         }
       }
     }
-    const decision = decideWorktree({ reuse: opts.reuse, modeSwitch, sha, worktreePath: wt, facts });
+    const decision = decideWorktree({
+      reuse: opts.reuse,
+      keepTree: opts.keepTree,
+      modeSwitch,
+      sha,
+      worktreePath: wt,
+      facts,
+    });
     if (decision.kind === "refuse") throw new ReuseRefusedError(decision.why);
     if (decision.kind === "reuse") return false;
 

package/dist/assets/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "switchboard",
-  "version": "1.231.0",
+  "version": "1.232.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "switchboard",
-      "version": "1.231.0",
+      "version": "1.232.0",
       "license": "Apache-2.0",
       "workspaces": [
         "web",
@@ -20032,7 +20032,7 @@
     },
     "packages/switchboard": {
       "name": "@coreplane/switchboard",
-      "version": "1.231.0",
+      "version": "1.232.0",
       "license": "Apache-2.0",
       "dependencies": {
         "@earendil-works/pi-ai": "0.85.1",

package/dist/assets/package.json

@@ -1,6 +1,6 @@
 {
   "name": "switchboard",
-  "version": "1.231.0",
+  "version": "1.232.0",
   "private": true,
   "description": "Mention it in Slack and an agent reviews the PR, ships the fix, or answers the question — on the model you choose, with its tools running where you decide.",
   "license": "Apache-2.0",

package/dist/assets/source.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.231.0",
-  "commit": "1cade13414f48f68e82675b961909eae72531b59",
-  "builtAt": "2026-09-16T00:12:48.252Z"
+  "version": "1.232.0",
+  "commit": "d61cfe3bf51e3ff2a69387412add020b4182875d",
+  "builtAt": "2026-09-16T15:02:34.038Z"
 }

package/dist/assets/src/core/coordinator/driver.ts

@@ -44,6 +44,7 @@ import {
   settleUnit,
   startUnit,
   type ChildFacts,
+  type MergeReadyFacts,
   type CoordinatorAction,
   type PlanGraph,
   type PlanUnitNode,
@@ -278,7 +279,13 @@ function prCheckReturn(step: string, a: BotAnswer): StepReturn {
     return {
       type: "pr-check",
       step,
-      pr: { state: "open", prNumber, url, ...(typeof headSha === "string" ? { headSha } : {}) },
+      pr: {
+        state: "open",
+        prNumber,
+        url,
+        ...(typeof headSha === "string" ? { headSha } : {}),
+        ...(typeof a.body.autoMergeEnabled === "boolean" ? { autoMergeEnabled: a.body.autoMergeEnabled } : {}),
+      },
       at,
     };
   // A merged pull request is read whole or not at all: the merge commit and
@@ -448,12 +455,36 @@ async function runUnit(
         const body = { ...tag, index: note.index, agent: note.agent, outcome: note.outcome };
         await step.do(`${unit}/note/${++notes}`, STEP_CONFIG, () => call(bot, "round", body));
       } else {
+        // A merge_ready ending names the pull request as it is at the APPROVED
+        // head (agent-ship item 9): one more pr-check reads the facts fresh —
+        // auto-merge may have been switched on since the round's check, or it
+        // may already have fired, in which case the answer is `merged` and the
+        // report says so rather than naming a gate that has passed. An
+        // unreadable answer just leaves the facts out.
+        let endFacts: MergeReadyFacts | undefined;
+        if (note.ending.kind === "merge_ready") {
+          try {
+            const check = prCheckReturn(
+              `${unit}/end/pr-facts`,
+              answerOf(
+                "pr-check",
+                await step.do(`${unit}/end/pr-facts`, STEP_CONFIG, () => call(bot, "pr-check", tag)),
+              ),
+            );
+            if (check.type === "pr-check" && check.pr.state === "merged")
+              endFacts = { merged: { sha: check.pr.sha, mergedAt: check.pr.mergedAt } };
+            else if (check.type === "pr-check" && check.pr.state === "open" && check.pr.autoMergeEnabled !== undefined)
+              endFacts = { autoMergeEnabled: check.pr.autoMergeEnabled };
+          } catch {
+            // the report simply omits the fact
+          }
+        }
         // The last coding child's run is named so the bot can put its handoff
         // — the deviations it recorded — on the unit's board issue beside the
         // ending (agent-ship item 14).
         const body = {
           ...tag,
-          ending: { kind: note.ending.kind, report: renderUnitReport(state) },
+          ending: { kind: note.ending.kind, report: renderUnitReport(state, endFacts) },
           ...(state.pr !== undefined ? { pr: state.pr } : {}),
           ...(state.lastCodingRunId !== undefined ? { codingRunId: state.lastCodingRunId } : {}),
         };

package/dist/assets/src/core/ship/coordinator.ts

@@ -443,7 +443,7 @@ export type ChildFacts =
  *  with no open one — a merged one, `sha` the merge commit on the base. */
 export type PrCheck =
   | { state: "none" }
-  | { state: "open"; prNumber: number; url: string; headSha?: string }
+  | { state: "open"; prNumber: number; url: string; headSha?: string; autoMergeEnabled?: boolean }
   | { state: "merged"; prNumber: number; url: string; sha: string; mergedAt: string };
 
 /** What a step answered. Every bot answer carries `at`, the bot's clock — the machine's time. */
@@ -1159,7 +1159,17 @@ function splitReport(s: UnitPipelineState): string {
 
 /** The thread's report for a unit's ending — the ship pipeline's own words
  *  for the endings it has, and the merge's for the ones it gains. */
-export function renderUnitReport(s: UnitPipelineState): string {
+/** What the driver read at the approved head when it composed a `merge_ready`
+ *  ending (agent-ship item 9): the pull request's own auto-merge fact, or the
+ *  merge that already happened — auto-merge or a person can merge between the
+ *  approval and the ending, and the report must describe the pull request as
+ *  it is, never a gate that has already passed. */
+export interface MergeReadyFacts {
+  autoMergeEnabled?: boolean;
+  merged?: { sha: string; mergedAt: string };
+}
+
+export function renderUnitReport(s: UnitPipelineState, facts?: MergeReadyFacts): string {
   const e = s.ending;
   if (!e) return "";
   const rounds = `${e.reviewRounds} review round${e.reviewRounds === 1 ? "" : "s"}`;
@@ -1189,7 +1199,14 @@ export function renderUnitReport(s: UnitPipelineState): string {
         `✅ Merge-ready after ${rounds}: ${e.pr.url}`,
         verdictLine,
         declinedLine,
-        "Remaining gate: a person's merge — the runner merges only when the instance's `merge` field says runner, and ship never approves.",
+        // What the driver read at the approved head when it composed this
+        // ending (agent-ship item 9): a merge that already happened is named
+        // as such, else the pull request's own auto-merge fact, else the gate.
+        facts?.merged
+          ? `Already merged: ${e.pr.url} (merge commit \`${facts.merged.sha.slice(0, 7)}\`, merged ${facts.merged.mergedAt}) — auto-merge or a person merged it after the approval; the runner merged nothing.`
+          : facts?.autoMergeEnabled
+            ? "Auto-merge is on for this pull request: the approval merges it once checks pass."
+            : "Remaining gate: a person's merge — the runner merges only when the instance's `merge` field says runner, and ship never approves.",
       ].join("\n");
     case "merge_refused":
       return join([

package/dist/assets/src/execution/residentReuse.ts

@@ -16,7 +16,11 @@
  *  PROVISIONS (a fresh one). A reusing attach keeps a readable tree exactly
  *  as it stands, dirt and stale HEAD included, and refuses by name a tree it
  *  cannot keep (gone, unreadable, built for the other mode) without touching
- *  it. A provisioning attach keeps the dirty/stale discipline byte for byte. */
+ *  it. A provisioning attach keeps the dirty/stale discipline byte for byte —
+ *  with one exception it is told about (`keepTree`): when its own rebind onto
+ *  the thread's pull request branch found the tree dirty with that branch
+ *  already checked out and moved the record alone, the dirt is the thread's
+ *  own work and the tree is kept as it stands. */
 
 export type ParsedReuse = { reuse: boolean } | { error: string };
 
@@ -58,6 +62,15 @@ export type WorktreeDecision =
 export function decideWorktree(input: {
   /** True for a resumed run's attach: keep the tree, never wipe it. */
   reuse: boolean;
+  /** True when this attach's rebind moved the binding onto the branch the
+   *  tree already had checked out, dirty, and promised not to touch it
+   *  (residentRebind.ts, the `checkout: false` verdict): the dirt is the
+   *  thread's own uncommitted work on its own pull request branch, so a
+   *  readable tree is kept as it stands — dirt and HEAD included, like a
+   *  resumed run's — while a tree that turns out missing, unreadable or built
+   *  for the other mode has nothing to keep and is provisioned like any fresh
+   *  attach's. Absent on every attach that did not make that move. */
+  keepTree?: boolean;
   /** The tree was built for the other mode (read-only against writable). */
   modeSwitch: boolean;
   /** The commit a provisioning attach checks out: the ref's tip, or the expected head. */
@@ -65,7 +78,7 @@ export function decideWorktree(input: {
   worktreePath: string;
   facts: WorktreeFacts;
 }): WorktreeDecision {
-  const { reuse, modeSwitch, sha, worktreePath, facts } = input;
+  const { reuse, keepTree = false, modeSwitch, sha, worktreePath, facts } = input;
   if (modeSwitch) {
     return reuse
       ? {
@@ -92,7 +105,9 @@ export function decideWorktree(input: {
   }
   // A reusing attach judges nothing past readability: the dirt and the HEAD are the run's own state.
   if (reuse) return { kind: "reuse" };
-  if (facts.dirty) return { kind: "recreate", why: "dirty" };
+  // The rebind promised a dirty tree on its own branch would not be touched;
+  // the dirt is the reason it made that promise, so it is not a reason to wipe.
+  if (facts.dirty) return keepTree ? { kind: "reuse" } : { kind: "recreate", why: "dirty" };
   if (facts.head !== sha && facts.descendsFromTip !== true) return { kind: "recreate", why: "stale" };
   return { kind: "reuse" };
 }

package/dist/assets/web/dist/.vite/manifest.json

@@ -28,7 +28,7 @@
     "src": "../node_modules/@fontsource-variable/jetbrains-mono/files/jetbrains-mono-vietnamese-wght-normal.woff2"
   },
   "../node_modules/@pierre/diffs/dist/index.js": {
-    "file": "assets/dist-BjLBNLkl.js",
+    "file": "assets/dist-boTdDLF4.js",
     "name": "dist",
     "src": "../node_modules/@pierre/diffs/dist/index.js",
     "isDynamicEntry": true,
@@ -2562,16 +2562,16 @@
       "_seed-DeKSHrt2.js"
     ]
   },
-  "_StatusDot-D-h9p7Iv.js": {
-    "file": "assets/StatusDot-D-h9p7Iv.js",
+  "_StatusDot-DexKtvUC.js": {
+    "file": "assets/StatusDot-DexKtvUC.js",
     "name": "StatusDot",
     "imports": [
       "_seed-DeKSHrt2.js",
-      "_Tooltip-BuDnXjL7.js"
+      "_Tooltip-DGQ2gu9M.js"
     ]
   },
-  "_Tooltip-BuDnXjL7.js": {
-    "file": "assets/Tooltip-BuDnXjL7.js",
+  "_Tooltip-DGQ2gu9M.js": {
+    "file": "assets/Tooltip-DGQ2gu9M.js",
     "name": "Tooltip",
     "imports": [
       "_AppShell-lYVcj-k7.js",
@@ -2789,7 +2789,7 @@
     ]
   },
   "src/main.ts": {
-    "file": "assets/main-BRrMt0Kr.js",
+    "file": "assets/main-BHhLVMQh.js",
     "name": "main",
     "src": "src/main.ts",
     "isEntry": true,
@@ -2841,19 +2841,19 @@
     ]
   },
   "src/pages/ResidentDetailPage.vue": {
-    "file": "assets/ResidentDetailPage-Df6D2emM.js",
+    "file": "assets/ResidentDetailPage-V4K35SYX.js",
     "name": "ResidentDetailPage",
     "src": "src/pages/ResidentDetailPage.vue",
     "isDynamicEntry": true,
     "imports": [
       "_AppShell-lYVcj-k7.js",
       "_seed-DeKSHrt2.js",
-      "_StatusDot-D-h9p7Iv.js",
+      "_StatusDot-DexKtvUC.js",
       "_residentDiskBudget-BMBKlYRH.js"
     ]
   },
   "src/pages/ResidentsIndexPage.vue": {
-    "file": "assets/ResidentsIndexPage-B0yECe2z.js",
+    "file": "assets/ResidentsIndexPage-3HuYaDwD.js",
     "name": "ResidentsIndexPage",
     "src": "src/pages/ResidentsIndexPage.vue",
     "isDynamicEntry": true,
@@ -2861,20 +2861,20 @@
       "_AppShell-lYVcj-k7.js",
       "_seed-DeKSHrt2.js",
       "_wallClock-61NpVkY6.js",
-      "_StatusDot-D-h9p7Iv.js",
+      "_StatusDot-DexKtvUC.js",
       "_residentDiskBudget-BMBKlYRH.js",
       "_indexFormat-B-pd4r7Y.js"
     ]
   },
   "src/pages/RunRoutePage.vue": {
-    "file": "assets/RunRoutePage-D4FG8JbC.js",
+    "file": "assets/RunRoutePage-Dr867-Ha.js",
     "name": "RunRoutePage",
     "src": "src/pages/RunRoutePage.vue",
     "isDynamicEntry": true,
     "imports": [
       "_AppShell-lYVcj-k7.js",
       "_seed-DeKSHrt2.js",
-      "_Tooltip-BuDnXjL7.js",
+      "_Tooltip-DGQ2gu9M.js",
       "src/main.ts",
       "_wallClock-61NpVkY6.js",
       "_NotFoundPage-BzWS4Ca1.js",
@@ -2890,31 +2890,31 @@
     ]
   },
   "src/pages/RunsIndexPage.vue": {
-    "file": "assets/RunsIndexPage-qxjCAVwQ.js",
+    "file": "assets/RunsIndexPage-D_lpXsr8.js",
     "name": "RunsIndexPage",
     "src": "src/pages/RunsIndexPage.vue",
     "isDynamicEntry": true,
     "imports": [
       "_AppShell-lYVcj-k7.js",
       "_seed-DeKSHrt2.js",
-      "_Tooltip-BuDnXjL7.js",
+      "_Tooltip-DGQ2gu9M.js",
       "_wallClock-61NpVkY6.js",
       "_RunsTabs-DEICQ4FY.js",
-      "_StatusDot-D-h9p7Iv.js",
+      "_StatusDot-DexKtvUC.js",
       "_indexFormat-B-pd4r7Y.js",
       "_favicon-CWPcvWvp.js",
       "_localIso-L06jV29p.js"
     ]
   },
   "src/pages/ScheduledPage.vue": {
-    "file": "assets/ScheduledPage-B0xQSZIS.js",
+    "file": "assets/ScheduledPage-dfrjQ5E9.js",
     "name": "ScheduledPage",
     "src": "src/pages/ScheduledPage.vue",
     "isDynamicEntry": true,
     "imports": [
       "_AppShell-lYVcj-k7.js",
       "_seed-DeKSHrt2.js",
-      "_Tooltip-BuDnXjL7.js",
+      "_Tooltip-DGQ2gu9M.js",
       "_wallClock-61NpVkY6.js",
       "_RunsTabs-DEICQ4FY.js",
       "_indexFormat-B-pd4r7Y.js",