@coreplane/switchboard 1.212.0 → 1.213.0

package/dist/assets/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "switchboard",
-  "version": "1.212.0",
+  "version": "1.213.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "switchboard",
-      "version": "1.212.0",
+      "version": "1.213.0",
       "license": "Apache-2.0",
       "workspaces": [
         "web",
@@ -21,6 +21,7 @@
       "dependencies": {
         "@anthropic-ai/sdk": "^0.124.0",
         "@slack/bolt": "^5.1.0",
+        "aws4fetch": "^1.0.20",
         "e2b": "^2.46.1",
         "mdast-util-from-markdown": "^2.0.3",
         "undici": "^8.10.2",
@@ -18999,11 +19000,12 @@
     },
     "packages/switchboard": {
       "name": "@coreplane/switchboard",
-      "version": "1.212.0",
+      "version": "1.213.0",
       "license": "Apache-2.0",
       "dependencies": {
         "@anthropic-ai/sdk": "^0.124.0",
         "@slack/bolt": "^5.1.0",
+        "aws4fetch": "^1.0.20",
         "e2b": "^2.46.1",
         "mdast-util-from-markdown": "^2.0.3",
         "undici": "^8.10.2",

package/dist/assets/package.json

@@ -1,6 +1,6 @@
 {
   "name": "switchboard",
-  "version": "1.212.0",
+  "version": "1.213.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",
@@ -81,6 +81,7 @@
   "dependencies": {
     "@anthropic-ai/sdk": "^0.124.0",
     "@slack/bolt": "^5.1.0",
+    "aws4fetch": "^1.0.20",
     "e2b": "^2.46.1",
     "mdast-util-from-markdown": "^2.0.3",
     "undici": "^8.10.2",

package/dist/assets/source.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.212.0",
-  "commit": "c3e94f963fc37fc7c8308cb34268f868413b76b3",
-  "builtAt": "2026-09-14T06:44:27.746Z"
+  "version": "1.213.0",
+  "commit": "e6d1e5ef45c220f43d4a956547c3f55458fbf3ab",
+  "builtAt": "2026-09-14T17:32:11.100Z"
 }

package/dist/assets/src/agents/registry.ts

@@ -42,6 +42,15 @@ export function machineNeedsRepo(machine: MachineClass): boolean {
 export const IDENTITIES = ["none", "read", "write"] as const;
 export type Identity = (typeof IDENTITIES)[number];
 
+/** The loops a preset's runs can be driven by (docs/reference/specs/harness-pi.md
+ *  item 1): `native`, the in-process turn loop (`src/runner.ts`), or `pi`, the
+ *  pi coding agent in the run's own execution container, driven over its RPC
+ *  protocol and bridged onto the run's events. A deployment's `harness:` block
+ *  overrides a preset's own declaration (`effectiveHarness`,
+ *  src/core/harness/select.ts). */
+export const HARNESSES = ["native", "pi"] as const;
+export type Harness = (typeof HARNESSES)[number];
+
 /** The pace that marks a run as looping rather than working: a model turn
  *  every ten seconds, sustained for the whole wall clock. A busy run takes
  *  20–40 s a turn (a model think plus a tool call), so a run that averages six
@@ -110,6 +119,11 @@ export interface AgentDef {
    *  discovery, no gh CLI. Selected by the dispatcher AFTER executor
    *  resolution via RunOptions.system; the shared AgentDef is never mutated. */
   residentSystem?: string;
+  /** Which loop drives the preset's runs (`HARNESSES`): the native loop
+   *  unless declared, and whatever a deployment's `harness.<preset>` says
+   *  over that. Only a preset with a workspace can run on pi — pi is a process
+   *  in the run's execution container. */
+  harness?: Harness;
 }
 
 // Every PR the coding agent ships carries a rich description by default —
@@ -435,6 +449,26 @@ Maintain the user-facing status card with the update_status tool: one item per c
 
 Use Slack-friendly formatting (no markdown headers; *bold*, bullets, code blocks). Your final message is posted to Slack: lead with the outcome, then one line per child — its preset, its thread, its status and its result in a sentence — and what is still running, if anything.`;
 
+/** The compound answer's preset — the one preset absent from the router's
+ *  table that a plain message still reaches: a message with two or more
+ *  independent asks routes to it with the parts named
+ *  (docs/reference/specs/routing-and-config.md item 21). Its def below opts
+ *  out of the table (`routable: false`); the router names it only in the
+ *  compound form. */
+export const COMPOUND_PRESET = "conductor";
+
+/** How a plain message reaches a preset (docs/reference/specs/routing-and-config.md
+ *  item 21), read off its def: `routed` — a row of the router's table, picked
+ *  for a single ask; `compound` — the compound form alone, a message with
+ *  several independent asks; `directive` — never picked, only `agent:<name>`.
+ *  `help` renders its lines from this, so its words follow the registry. */
+export type PresetDoor = "routed" | "compound" | "directive";
+
+export function presetDoor(def: AgentDef): PresetDoor {
+  if (def.routable !== false) return "routed";
+  return def.name === COMPOUND_PRESET ? "compound" : "directive";
+}
+
 export const AGENTS: Record<string, AgentDef> = {
   general: {
     name: "general",
@@ -466,6 +500,9 @@ export const AGENTS: Record<string, AgentDef> = {
     // `config set channel efforts.coding=…`, or `effort:` per request).
     machine: "repo-resident",
     identity: "write", // pushes branches and opens pull requests
+    // The native loop until the pi series moves this preset; a deployment
+    // flips it early with `harness: { coding: pi }` (docs/reference/specs/harness-pi.md).
+    harness: "native",
   },
   review: {
     name: "review",

package/dist/assets/src/core/redact.ts

@@ -46,6 +46,14 @@ const REDACT: Array<{ re: RegExp; replace: string }> = [
 const SECRET_COMPONENT =
   /^(secret|token|password|passwd|pwd|credential|credentials|key|apikey|auth|session|sessionid|cookie)$/i;
 
+// An identifier component that marks the whole identifier as an ERROR CODE, not
+// a secret name: `github-token-mint-failed: HTTP 422 …` names a failure about a
+// token, and the word after the colon is diagnosis, never a credential. Without
+// this guard the assignment pass redacted `HTTP` out of that message
+// (`github-token-mint-failed: «redacted» 422 …`), garbling the one line that
+// tells an operator what went wrong.
+const ERROR_CODE_COMPONENT = /^(failed|failure|error|err|refused|denied|invalid|missing|expired|unset|mismatch)$/i;
+
 /** Redact the VALUE of any `<name> = value` / `<name>: value` where the name has
  *  a secret-marking component. Handles quoted values (with spaces) and unquoted,
  *  and a quoted NAME (`"password": "…"` in pasted JSON — the closing quote sits
@@ -64,7 +72,9 @@ function redactNamedAssignments(text: string): string {
     // decides whether it names a secret (`_SECRET` → ["", "SECRET"]).
     /(?<![A-Za-z0-9_-])([A-Za-z0-9_-]+)("?)(\s*[=:]\s*)("(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'|[^\s]{4,})/g,
     (whole, id: string, close: string, sep: string, val: string) => {
-      if (!id.split(/[_-]/).some((p) => SECRET_COMPONENT.test(p))) return whole;
+      const parts = id.split(/[_-]/);
+      if (!parts.some((p) => SECRET_COMPONENT.test(p))) return whole;
+      if (parts.some((p) => ERROR_CODE_COMPONENT.test(p))) return whole;
       const quote = val[0] === '"' || val[0] === "'" ? val[0] : "";
       return `${id}${close}${sep}${quote}«redacted»${quote}`;
     },

package/dist/assets/src/core/runEvents.ts

@@ -118,7 +118,23 @@ export type RunNoteKind =
    *  post-step beside the thread's Slack-only note, so the record says the
    *  verdict is Slack-only and a coordinator reading it never asks GitHub
    *  for a review that was never sent. */
-  | "review_not_posted";
+  | "review_not_posted"
+  /** A pi run's context was compacted (docs/reference/specs/harness-pi.md item
+   *  6): pi summarized its older turns into one entry and the model reads the
+   *  summary from here on; the transcript keeps the originals, so the record
+   *  is a superset of the model's context. The summary names the token counts
+   *  before and after. Published by the pi bridge. */
+  | "compacted"
+  /** The pi harness itself failed in a way the run must show (harness-pi.md
+   *  item 6): the extension threw, pi asked a dialog no one answers (answered
+   *  cancelled), or pi emitted an event kind this build's bridge does not
+   *  know — named, so a pi bump is visible in the first run's record. Published
+   *  by the pi bridge. */
+  | "harness_error"
+  /** The harness's gate refused a tool call the model asked for (harness-pi.md
+   *  item 7): the summary names the tool and the rule; the model read the same
+   *  reason as the tool's result. Published by the bot's authorize route. */
+  | "tool_refused";
 
 /** Every `RunNoteKind`, as a value (a reader that filters notes by kind uses
  *  this; adding a kind to the union without adding it here is a type error). */
@@ -139,6 +155,9 @@ export const RUN_NOTE_KINDS = [
   "cold_sandbox",
   "pr_not_opened",
   "review_not_posted",
+  "compacted",
+  "harness_error",
+  "tool_refused",
 ] as const satisfies readonly RunNoteKind[];
 type _EveryKindListed = [RunNoteKind] extends [(typeof RUN_NOTE_KINDS)[number]] ? true : never;
 const _everyKindListed: _EveryKindListed = true;
@@ -383,6 +402,27 @@ export type RunEvent =
       seq?: number;
       at?: number;
     }
+  /** A file moved through the artifact store (docs/reference/specs/execution.md item 20,
+   *  record 0033): one the run received from its thread (`in`, staged before
+   *  the turn) or one it sent (`out`, `attach_file`). The record keeps the
+   *  store KEY and the facts a page needs to list the file — never a URL: the
+   *  run page's proxy route (`/runs/:id/artifacts/<key>`, live-view.md item 26)
+   *  mints a signed GET per request, so a stored record never carries a
+   *  credential that expires or leaks, and the parser refuses a payload that
+   *  tries. A side fact beside the tool pair that moved the file (like
+   *  `skill_use`), never a step; the friction analyzer ignores it. */
+  | {
+      type: "artifact";
+      direction: "in" | "out";
+      /** The store key (`src/artifacts/keys.ts`): `runs/<runId>/out/<seq>-<basename>` or `threads/<thread>/in/<ts>/<i>-<basename>`. */
+      key: string;
+      /** The file's name as the person sees it (the Slack filename, the tool's `name`). */
+      name: string;
+      size: number;
+      contentType: string;
+      seq?: number;
+      at?: number;
+    }
   /** A skill was loaded into the model's context (docs/reference/specs/skills.md). Emitted
    *  by the `use_skill` tool on a successful load — alongside, not instead of,
    *  its `tool_call`/`tool_result` pair — so skill use is a first-class fact in

package/dist/assets/src/core/runFriction.ts

@@ -384,12 +384,14 @@ export function analyzeRunFriction(events: readonly RunEvent[], opts: FrictionOp
       return;
     }
     // Side facts about the run, not steps: skill_use rides beside a use_skill
-    // call that already produced its own tool pair; review_artifact,
-    // pr_description, pr_opened, review_posted, the ship_round boundaries and
-    // the router's route are published by the dispatcher/pipeline outside the
-    // model loop entirely. Counting any of them would distort the story.
+    // call that already produced its own tool pair, and artifact beside the
+    // attach_file call (or the dispatcher's staging) that moved the file;
+    // review_artifact, pr_description, pr_opened, review_posted, the ship_round
+    // boundaries and the router's route are published by the dispatcher/pipeline
+    // outside the model loop entirely. Counting any of them would distort the story.
     if (
       ev.type === "skill_use" ||
+      ev.type === "artifact" ||
       ev.type === "review_artifact" ||
       ev.type === "pr_description" ||
       ev.type === "pr_opened" ||

package/dist/assets/src/core/trace/workerTrace.ts

@@ -55,6 +55,10 @@ export function shimRoute(pathname: string): string | undefined {
   // The model proxy's two routes (docs/reference/specs/model-proxy.md): a bounded
   // request per model call, forwarded to the container like everything else.
   if (pathname === "/v1/messages" || pathname === "/v1/chat/completions") return "model-proxy";
+  // The pi harness's three routes (docs/reference/specs/harness-pi.md item 7): a
+  // run's extension asking for its tools, a verdict, a relayed tool's result.
+  if (pathname === "/harness/tools" || pathname === "/harness/authorize" || pathname === "/harness/tool")
+    return "harness";
   if (pathname === "/docs" || pathname.startsWith("/docs/")) return "docs";
   if (pathname === "/" || pathname === "/index.html") return "page";
   return "other";

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

@@ -117,6 +117,10 @@ export function checkoutUpdateCommand(sha: string, clean: CleanScope): string {
  *  step at all.) The kill surfaces either as the shell's
  *  own death (SIGTERM, exit 143, "Session terminated") or, past the shell, as
  *  the SDK's replacement errors (stale process handle, closed supervisor).
+ *  `runtimeUnreachable` is the other outcome that says nothing about the
+ *  repository: the container's control port never answered the SDK's connect
+ *  (`runtimeUnreachableReason`), so no command ran at all — the resident
+ *  escalates on its persisted count instead of recording a command failure.
  *  Everything else is the repo's own build failing. */
 export interface RefreshFailure {
   /** The reason. An interruption's is prefixed `refresh-interrupted:` and is
@@ -124,10 +128,13 @@ export interface RefreshFailure {
    *  whose retry re-enters the step, and the row keeps its state (the word
    *  shows on the instance row's `lastStep` and in the log). A full disk is
    *  `disk-full:` (`residentDisk.ts` — the cycle's entry gate and the recycle
-   *  decision key on it); real failures keep `<step>-failed:`. */
+   *  decision key on it); an unanswered control port is `runtime-unreachable:`
+   *  with the attempt count (the ladder below decides what the resident does
+   *  about it); real failures keep `<step>-failed:`. */
   reason: string;
   interrupted: boolean;
   diskFull: boolean;
+  runtimeUnreachable: boolean;
 }
 
 /** Root argv that kills every process the build user still owns and waits
@@ -202,7 +209,16 @@ const INTERRUPTION_SIGNATURE = /\bexit 143\b|Session terminated|SIGTERM/;
 export const RUNTIME_REPLACEMENT_WORDING =
   /previous runtime incarnation|interrupted because the runtime changed|runtime identity is no longer active|sandbox lifetime is no longer current|platform was updating the sandbox runtime|no longer identifies pid|process supervisor is closed|container is not running, consider calling start/i;
 
-/** `freeKiB` is the `df` probe's answer (`parseDfFreeKiB`), taken AFTER the
+/** `runtimeUnreachable` is the caller's word that the failure was the SDK's
+ *  connect abort at the exec choke point (the Worker's typed check over the
+ *  error and its cause chain, `isRuntimeUnreachableSignal`) with the count it
+ *  persisted: the outcome is decided before anything else — no command ran, so
+ *  neither the message nor a disk probe is evidence — and the reason is the
+ *  named one, never the SDK's bare `The operation was aborted`. Without that
+ *  word the classifier does not guess from the wording: an abort message on
+ *  its own stays the step's failure, exactly as it did before the ladder.
+ *
+ *  `freeKiB` is the `df` probe's answer (`parseDfFreeKiB`), taken AFTER the
  *  step failed and only consulted when the message itself carries no errno:
  *  a message saying ENOSPC is disk-full outright (the disk is the actionable
  *  fact, whatever else the message says); a kill signature without it is an
@@ -213,23 +229,153 @@ export function classifyRefreshFailure(input: {
   step: string;
   message: string;
   freeKiB?: number | null;
+  runtimeUnreachable?: { count: number };
 }): RefreshFailure {
   const { step, message } = input;
+  if (input.runtimeUnreachable) {
+    return {
+      interrupted: false,
+      diskFull: false,
+      runtimeUnreachable: true,
+      reason: runtimeUnreachableReason(input.runtimeUnreachable.count),
+    };
+  }
   if (isDiskFullMessage(message)) {
     return {
       interrupted: false,
       diskFull: true,
+      runtimeUnreachable: false,
       reason: diskFullReason({ step, message, freeKiB: input.freeKiB ?? null }),
     };
   }
   const timedOut = /\(timed out\)/.test(message);
   if (!timedOut && (INTERRUPTION_SIGNATURE.test(message) || RUNTIME_REPLACEMENT_WORDING.test(message))) {
-    return { interrupted: true, diskFull: false, reason: `refresh-interrupted: ${step} ${message}` };
+    return {
+      interrupted: true,
+      diskFull: false,
+      runtimeUnreachable: false,
+      reason: `refresh-interrupted: ${step} ${message}`,
+    };
   }
   if (input.freeKiB !== undefined && input.freeKiB !== null && input.freeKiB < DISK_FULL_FREE_KIB) {
-    return { interrupted: false, diskFull: true, reason: diskFullReason({ step, message, freeKiB: input.freeKiB }) };
+    return {
+      interrupted: false,
+      diskFull: true,
+      runtimeUnreachable: false,
+      reason: diskFullReason({ step, message, freeKiB: input.freeKiB }),
+    };
+  }
+  return { interrupted: false, diskFull: false, runtimeUnreachable: false, reason: `${step}-failed: ${message}` };
+}
+
+// -- the runtime that never answers --------------------------------------------
+
+/** The Sandbox SDK's connect timeout (`DEFAULT_CONNECT_TIMEOUT_MS` in its
+ *  container-control connection, @cloudflare/sandbox@0.13.0-next.751.1): how
+ *  long ONE WebSocket upgrade to the container's control port 3000 may take
+ *  before the SDK aborts it. A module constant there, not an option — the
+ *  30 s is the SDK's, not ours; pinned by a test that reads the installed
+ *  dist, so an SDK bump that moves it fails the build, not a reason string. */
+export const SDK_CONNECT_TIMEOUT_MS = 30_000;
+
+/** The SDK's env knob for how long the physical start waits for the control
+ *  port to accept a request before the first connect (`portReadyTimeoutMS`,
+ *  read from this var, 10 s to 600 s; its default is 90 s). The wake path's
+ *  first exec after a start is bounded by that wait PLUS one connect timeout:
+ *  a slow boot (a 2.65 GB image on a cold host) spends its time in the port
+ *  wait, so a start given `WAKE_PORT_READY_MS` is not mistaken for an
+ *  unreachable runtime. The value lives in the resident's wrangler template
+ *  (`vars`), pinned to the constant by a test. */
+export const SDK_PORT_READY_ENV = "SANDBOX_PORT_TIMEOUT_MS";
+export const WAKE_PORT_READY_MS = 3 * 60_000;
+
+/** The DO storage key the SDK keeps its runtime identity under
+ *  (`RUNTIME_RECORD_KEY` in its runtime lifecycle; not exported). The
+ *  resident forgets it before it destroys a container: the SDK's `destroy()`
+ *  skips its runtime cleanup when no identity is stored — against a silent
+ *  control port that cleanup would only wait out its bound — and a destroy
+ *  that fails midway leaves no identity behind to be re-adopted. `stop()` and
+ *  `destroy()` delete it themselves (`invalidate`); the explicit delete is the
+ *  guard for the path where they do not get that far. Pinned to the installed
+ *  SDK by a test. */
+export const SDK_RUNTIME_RECORD_KEY = "currentRuntimeIdentity";
+
+/** The DOMException the SDK's connect abort raises: `AbortError`, message
+ *  `The operation was aborted`. Anchored on the whole sentence so a command's
+ *  own `Aborted (core dumped)` never matches. */
+export const RUNTIME_UNREACHABLE_WORDING = /\bThe operation was aborted\b/;
+
+/** Is this one link of an error's cause chain the SDK's connect abort? By
+ *  name first (the DOMException's `AbortError`), by the DOMException's message
+ *  when a wrapper copied only that. Applied by the Worker to the SPAWN-phase
+ *  error alone — after its replacement check, since a replaced runtime is a
+ *  different fact (`RUNTIME_REPLACEMENT_WORDING`, disjoint by construction) —
+ *  never to a command's own output, which is a `StepError` with an exit code. */
+export function isRuntimeUnreachableSignal(link: unknown): boolean {
+  if (link === null || typeof link !== "object") return false;
+  const { name, message } = link as { name?: unknown; message?: unknown };
+  if (name === "AbortError") return true;
+  return typeof message === "string" && RUNTIME_UNREACHABLE_WORDING.test(message);
+}
+
+/** The escalation ladder over the resident's persisted count of consecutive
+ *  unanswered connects (the row is cleared by any exec whose process spawned).
+ *  Each rung is what the refresh instance does when a step's exec finds the
+ *  control port silent AGAIN at that count:
+ *    re-arm   (1–2)  `degraded(runtime-unreachable …)`, the step thrown to the
+ *                    engine whose retry re-enters it thirty seconds on — the
+ *                    short re-arm a `refresh-interrupted` gets;
+ *    stop     (3)    the container is sent SIGTERM (`stop()`), the incarnation
+ *                    swapped, the retry starts it again — cheap, and enough
+ *                    for a runtime that still honours signals;
+ *    recreate (4–5)  the SDK's runtime identity is forgotten
+ *                    (`SDK_RUNTIME_RECORD_KEY`) and the VM destroyed
+ *                    (`destroy()`: SIGKILL, a fresh disk — where `stop()` is a
+ *                    SIGTERM a wedged runtime ignores, as the incident's admin
+ *                    stop showed), every snapshot and entry backup kept, the
+ *                    incarnation swapped; the retry's wake path finds no
+ *                    runtime, flips `restoring` and restores mirror, checkout
+ *                    and deps from R2 — minutes, not the thirty-minute rebuild;
+ *    down     (≥ 6)  a recreated container did not answer either: the resident
+ *                    goes `down(runtime-unreachable …)`, a reason the watchdog's
+ *                    auto-rebuild strikes apply to, so the rebuild — destroy
+ *                    plus reprovision from the code host — is the last resort,
+ *                    not the first. */
+export const RUNTIME_UNREACHABLE_STOP_AT = 3;
+export const RUNTIME_UNREACHABLE_RECREATE_AT = 4;
+export const RUNTIME_UNREACHABLE_DOWN_AT = 6;
+
+export type RuntimeUnreachableRung = "re-arm" | "stop" | "recreate" | "down";
+
+export function runtimeUnreachableRung(count: number): RuntimeUnreachableRung {
+  if (!Number.isFinite(count) || count < 1) {
+    throw new RangeError(`runtime-unreachable rung needs a count of at least 1, got ${count}`);
   }
-  return { interrupted: false, diskFull: false, reason: `${step}-failed: ${message}` };
+  if (count >= RUNTIME_UNREACHABLE_DOWN_AT) return "down";
+  if (count >= RUNTIME_UNREACHABLE_RECREATE_AT) return "recreate";
+  if (count >= RUNTIME_UNREACHABLE_STOP_AT) return "stop";
+  return "re-arm";
+}
+
+const RUNTIME_UNREACHABLE_ACTION: Readonly<Record<RuntimeUnreachableRung, string>> = {
+  "re-arm": "the step is retried",
+  stop: "the container was stopped (SIGTERM); the retry starts it again",
+  recreate:
+    "the container was destroyed and the SDK's runtime identity forgotten, snapshots kept; the retry restores the checkout from the snapshot",
+  down: "a recreated container did not answer either; only a rebuild follows",
+};
+
+/** The reason a silent control port is recorded under: the port, the SDK's
+ *  connect timeout and the attempt out of the down threshold — and, when a
+ *  rung acted, what it did and what the retry does next. Never the SDK's bare
+ *  `The operation was aborted`. */
+export function runtimeUnreachableReason(count: number, rung?: RuntimeUnreachableRung): string {
+  const base = `runtime-unreachable: the container's control port did not answer within ${SDK_CONNECT_TIMEOUT_MS / 1000} s (attempt ${count} of ${RUNTIME_UNREACHABLE_DOWN_AT})`;
+  return rung ? `${base} — ${RUNTIME_UNREACHABLE_ACTION[rung]}` : base;
+}
+
+export function isRuntimeUnreachableReason(reason: string): boolean {
+  return /^runtime-unreachable: /.test(reason);
 }
 
 /** What the wake path does with a failed restore. `down` is the rule: the

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-YrRKtxsS.js",
+    "file": "assets/dist-B7BVkB7x.js",
     "name": "dist",
     "src": "../node_modules/@pierre/diffs/dist/index.js",
     "isDynamicEntry": true,
@@ -2562,16 +2562,16 @@
       "_seed-DeKSHrt2.js"
     ]
   },
-  "_StatusDot-BmFHnV8m.js": {
-    "file": "assets/StatusDot-BmFHnV8m.js",
+  "_StatusDot-D8Wwt1KC.js": {
+    "file": "assets/StatusDot-D8Wwt1KC.js",
     "name": "StatusDot",
     "imports": [
       "_seed-DeKSHrt2.js",
-      "_Tooltip-DoThP2fW.js"
+      "_Tooltip-DpDK7jWZ.js"
     ]
   },
-  "_Tooltip-DoThP2fW.js": {
-    "file": "assets/Tooltip-DoThP2fW.js",
+  "_Tooltip-DpDK7jWZ.js": {
+    "file": "assets/Tooltip-DpDK7jWZ.js",
     "name": "Tooltip",
     "imports": [
       "_AppShell-lYVcj-k7.js",
@@ -2789,7 +2789,7 @@
     ]
   },
   "src/main.ts": {
-    "file": "assets/main-D6nzMf0k.js",
+    "file": "assets/main-BFkEOy3K.js",
     "name": "main",
     "src": "src/main.ts",
     "isEntry": true,
@@ -2807,7 +2807,7 @@
       "_NotFoundPage-BzWS4Ca1.js"
     ],
     "css": [
-      "assets/main-CuENKPdD.css"
+      "assets/main-DCH3Mezs.css"
     ],
     "assets": [
       "assets/instrument-sans-latin-ext-wght-normal-B5bTHO_g.woff2",
@@ -2841,19 +2841,19 @@
     ]
   },
   "src/pages/ResidentDetailPage.vue": {
-    "file": "assets/ResidentDetailPage-CM5nWw-Z.js",
+    "file": "assets/ResidentDetailPage-CvwjhjlG.js",
     "name": "ResidentDetailPage",
     "src": "src/pages/ResidentDetailPage.vue",
     "isDynamicEntry": true,
     "imports": [
       "_AppShell-lYVcj-k7.js",
       "_seed-DeKSHrt2.js",
-      "_StatusDot-BmFHnV8m.js",
+      "_StatusDot-D8Wwt1KC.js",
       "_residentDiskBudget-BMBKlYRH.js"
     ]
   },
   "src/pages/ResidentsIndexPage.vue": {
-    "file": "assets/ResidentsIndexPage-BKBnuvp3.js",
+    "file": "assets/ResidentsIndexPage-DoN6XuNx.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-BmFHnV8m.js",
+      "_StatusDot-D8Wwt1KC.js",
       "_residentDiskBudget-BMBKlYRH.js",
       "_indexFormat-B-pd4r7Y.js"
     ]
   },
   "src/pages/RunRoutePage.vue": {
-    "file": "assets/RunRoutePage-Bu4CwEzt.js",
+    "file": "assets/RunRoutePage-FzLNexjF.js",
     "name": "RunRoutePage",
     "src": "src/pages/RunRoutePage.vue",
     "isDynamicEntry": true,
     "imports": [
       "_AppShell-lYVcj-k7.js",
       "_seed-DeKSHrt2.js",
-      "_Tooltip-DoThP2fW.js",
+      "_Tooltip-DpDK7jWZ.js",
       "src/main.ts",
       "_wallClock-61NpVkY6.js",
       "_NotFoundPage-BzWS4Ca1.js",
@@ -2890,31 +2890,31 @@
     ]
   },
   "src/pages/RunsIndexPage.vue": {
-    "file": "assets/RunsIndexPage-w2jJP5xu.js",
+    "file": "assets/RunsIndexPage-DhSUbF9k.js",
     "name": "RunsIndexPage",
     "src": "src/pages/RunsIndexPage.vue",
     "isDynamicEntry": true,
     "imports": [
       "_AppShell-lYVcj-k7.js",
       "_seed-DeKSHrt2.js",
-      "_Tooltip-DoThP2fW.js",
+      "_Tooltip-DpDK7jWZ.js",
       "_wallClock-61NpVkY6.js",
       "_RunsTabs-DEICQ4FY.js",
-      "_StatusDot-BmFHnV8m.js",
+      "_StatusDot-D8Wwt1KC.js",
       "_indexFormat-B-pd4r7Y.js",
       "_favicon-CWPcvWvp.js",
       "_localIso-L06jV29p.js"
     ]
   },
   "src/pages/ScheduledPage.vue": {
-    "file": "assets/ScheduledPage-D3-k9DPz.js",
+    "file": "assets/ScheduledPage-Bq0Yg4nT.js",
     "name": "ScheduledPage",
     "src": "src/pages/ScheduledPage.vue",
     "isDynamicEntry": true,
     "imports": [
       "_AppShell-lYVcj-k7.js",
       "_seed-DeKSHrt2.js",
-      "_Tooltip-DoThP2fW.js",
+      "_Tooltip-DpDK7jWZ.js",
       "_wallClock-61NpVkY6.js",
       "_RunsTabs-DEICQ4FY.js",
       "_indexFormat-B-pd4r7Y.js",