mercury-agent 0.18.2 → 0.19.0

package/examples/extensions/morning/lib/upload.ts

@@ -0,0 +1,584 @@
+/**
+ * Expense file upload, host-side.
+ *
+ * Morning's upload is two hops and both live here, in one broker action:
+ *
+ *   1. `GET {uploadBase}/file-upload/v1/url` → a pre-signed S3 POST.
+ *   2. `POST <that url>` → multipart/form-data, no Authorization header.
+ *
+ * They are not two verbs, and that is deliberate: the pre-signed POST is valid
+ * for 60 SECONDS. A model that had to decide between two verbs would spend the
+ * window deciding. Nothing between the two hops may block on anything slow.
+ *
+ * Uploading always creates an expense DRAFT, which Morning parses itself and a
+ * human approves in Morning's UI. That is why this needs no
+ * `accountingClassification` — the field that keeps `POST /expenses` out of the
+ * extension — and why the human gate here is real rather than prompted.
+ *
+ * The container never sends bytes. It names a path RELATIVE to its own space
+ * workspace and the host reads it. `resolveInSpace` below is the only thing
+ * standing between that and an arbitrary-file-read primitive handed to a
+ * prompt-injectable agent, so read its comment before changing it.
+ */
+
+import { lstat, readFile, realpath, stat } from "node:fs/promises";
+import path from "node:path";
+import {
+  extToMime,
+  hasExecutableHeader,
+  isAllowedExtension,
+} from "mercury-agent/core/media";
+import { hostsFor, type MorningEnvironment } from "./hosts.js";
+
+/** Same bound as the rest of the extension; nothing upstream sets one. */
+const UPLOAD_TIMEOUT_MS = 30_000;
+
+/** Morning's own constant for this flow — `source` must be 5. */
+const UPLOAD_SOURCE = 5;
+
+export interface CapabilityResult {
+  status?: number;
+  data: unknown;
+}
+
+export interface UploadContext {
+  env: MorningEnvironment;
+  spaceId: string;
+  /**
+   * Root of all space workspaces, already project-resolved by the caller.
+   * `<spacesDir>/<spaceId>/` is the confinement boundary.
+   */
+  spacesDir: string;
+  fetchImpl?: typeof fetch;
+  /** Host-side logger. Refusals are logged here, never returned in detail. */
+  logDenial?: (message: string, detail: Record<string, unknown>) => void;
+}
+
+/**
+ * Token access, supplied by the caller so this module does not reach for the
+ * database. `getToken(true)` must bypass any cache — it is what makes the one
+ * 401 retry below meaningful.
+ */
+export interface TokenProvider {
+  getToken(
+    forceRefresh: boolean,
+  ): Promise<
+    { ok: true; token: string } | { ok: false; result: CapabilityResult }
+  >;
+  /** Called when Morning rejects a freshly minted token, so statusCheck can see it. */
+  recordAuthError(message: string): void;
+}
+
+/**
+ * The three outcomes of resolving a caller-supplied path.
+ *
+ * `refused` and `missing` are deliberately distinct, and the line between them
+ * is what keeps this from being a filesystem oracle: `missing` is returned ONLY
+ * for a path that is structurally sound and lexically inside the caller's own
+ * space. Confirming such a path is empty tells the caller nothing it did not
+ * already know — it named the path. Everything else, including any path that
+ * resolves outside the space, is a single indistinguishable `refused`.
+ */
+export type ResolveOutcome =
+  | { ok: true; absPath: string }
+  | { ok: false; reason: "refused" | "missing" };
+
+const REFUSED = { ok: false, reason: "refused" } as const;
+const MISSING = { ok: false, reason: "missing" } as const;
+
+/**
+ * Resolve a container-supplied relative path inside one space's workspace.
+ *
+ * Three properties, each of which has been a real bug somewhere:
+ *
+ *  - **Absence denies.** An empty, missing or non-string path is refused before
+ *    anything touches the filesystem. A guard whose absent case falls through
+ *    to allow is not a guard (see
+ *    `docs/debug/moderate/08-2026/2026-08-27-body-size-limit-skipped-without-content-length.md`).
+ *  - **Symlinks are resolved BEFORE the comparison, not after.** `inbox/` is
+ *    written by a lower-trust boundary, so a symlink there pointing at the
+ *    host's `.env` is precisely the attack. Comparing the pre-resolution path
+ *    would pass it.
+ *  - **The comparison is path-segment-wise, never a string prefix.** With a bare
+ *    `startsWith`, space `a` reaches everything in space `abc`.
+ */
+export async function resolveInSpace(
+  spacesDir: string,
+  spaceId: string,
+  rawPath: unknown,
+): Promise<ResolveOutcome> {
+  if (typeof rawPath !== "string") return REFUSED;
+  const candidate = rawPath.trim();
+  if (!candidate) return REFUSED;
+
+  // Cheap structural rejections first, before any I/O. Not the real guard —
+  // the realpath comparison below is — but they keep obvious junk out of the
+  // filesystem calls and make the intent readable.
+  if (path.isAbsolute(candidate)) return REFUSED;
+  if (candidate.split(/[\\/]/).includes("..")) return REFUSED;
+
+  // Resolve the base's own symlinks first (a spacesDir under /var on macOS is
+  // one), then build the target from the resolved base so the two are
+  // comparable.
+  let realBase: string;
+  try {
+    realBase = await realpath(path.resolve(spacesDir, spaceId));
+  } catch {
+    return REFUSED;
+  }
+
+  const target = path.resolve(realBase, candidate);
+  // Lexical containment before touching the target: a path that is outside
+  // even on paper is refused without a filesystem probe.
+  if (!isInside(realBase, target)) return REFUSED;
+
+  let realTarget: string;
+  try {
+    realTarget = await realpath(target);
+  } catch {
+    return (await isPlainTypo(realBase, target)) ? MISSING : REFUSED;
+  }
+
+  // The decisive check, AFTER symlink resolution — this is the one that catches
+  // a link in `inbox/` pointing anywhere else on the host.
+  if (!isInside(realBase, realTarget)) return REFUSED;
+  return { ok: true, absPath: realTarget };
+}
+
+/**
+ * `realpath` failed on a path that is lexically inside the space. Is that a
+ * plain typo, or something planted?
+ *
+ * Only a typo may be reported as `missing`, because the 404/400 split is
+ * otherwise a one-bit existence oracle for arbitrary host paths: a container
+ * can write symlinks into its own workspace, so it could plant a link to any
+ * path, read the status code, and learn whether the target exists. No content
+ * escapes either way — the containment check still holds for anything that
+ * resolves — but an oracle is exactly what the "never echo the resolved path"
+ * rule exists to prevent, so the two conditions below close it.
+ *
+ *  1. Nothing may exist at the name at all. `lstat` sees a dangling symlink
+ *     where `realpath` does not, and a dangling symlink is never a typo.
+ *  2. The parent directory must itself resolve inside the space, or a symlinked
+ *     intermediate directory is doing the escaping.
+ */
+async function isPlainTypo(realBase: string, target: string): Promise<boolean> {
+  try {
+    await lstat(target);
+    return false; // Something is there; realpath refused to follow it.
+  } catch {
+    // Genuinely nothing at that name — carry on to the parent check.
+  }
+  try {
+    return isInside(realBase, await realpath(path.dirname(target)));
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Is `target` the same as, or beneath, `base`?
+ *
+ * `path.relative` rather than a string compare: it normalises separators and
+ * yields a result starting with `..` exactly when the target sits outside, so
+ * `/spaces/abc` is correctly outside `/spaces/a`. An empty result means the two
+ * are the same path, which is not a file and so not acceptable either — the
+ * caller's `stat` rejects it, but returning true here keeps this function about
+ * containment alone.
+ */
+function isInside(base: string, target: string): boolean {
+  const rel = path.relative(base, target);
+  if (rel === "") return true;
+  if (rel.startsWith("..")) return false;
+  return !path.isAbsolute(rel);
+}
+
+interface LoadedFile {
+  bytes: Buffer;
+  name: string;
+}
+
+/**
+ * Read and validate the file once.
+ *
+ * The buffer is read a single time and reused for the header check, the size
+ * check and the upload body, so the bytes that were validated are exactly the
+ * bytes that get sent. Re-reading before the upload would leave a window for a
+ * swap by whatever wrote the file.
+ */
+async function loadFile(
+  absPath: string,
+  displayName: string,
+): Promise<LoadedFile | CapabilityResult> {
+  let info: Awaited<ReturnType<typeof stat>>;
+  try {
+    info = await stat(absPath);
+  } catch {
+    return { status: 404, data: { error: `No such file: ${displayName}` } };
+  }
+  if (!info.isFile()) {
+    return { status: 400, data: { error: `Not a file: ${displayName}` } };
+  }
+
+  const name = path.basename(absPath);
+  if (!isAllowedExtension(name)) {
+    return {
+      status: 415,
+      data: {
+        error: `Refusing to upload ${displayName}: the file type is not one Mercury handles.`,
+      },
+    };
+  }
+
+  let bytes: Buffer;
+  try {
+    bytes = await readFile(absPath);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return {
+      status: 404,
+      data: { error: `Could not read ${displayName}: ${message}` },
+    };
+  }
+
+  if (hasExecutableHeader(bytes)) {
+    return {
+      status: 415,
+      data: {
+        error: `Refusing to upload ${displayName}: its first bytes are an executable header, whatever the extension says.`,
+      },
+    };
+  }
+
+  return { bytes, name };
+}
+
+function isResult(v: unknown): v is CapabilityResult {
+  return typeof v === "object" && v !== null && "data" in v;
+}
+
+interface PresignedPost {
+  url: string;
+  fields: Record<string, string>;
+  maxFileSize: number;
+}
+
+/**
+ * Outcome of step 1. The upstream status is kept separate from the error the
+ * caller would return, because the retry decision turns on the status alone and
+ * collapsing everything into a 502 would hide the one case worth retrying.
+ */
+type PresignOutcome =
+  | { ok: true; presigned: PresignedPost }
+  | { ok: false; httpStatus: number | null; result: CapabilityResult };
+
+/**
+ * Step 1 — ask Morning for a pre-signed POST.
+ *
+ * Not `callOnce`: a different base, query parameters rather than a JSON body,
+ * and success is 201 rather than 200.
+ */
+async function requestUploadUrl(
+  ctx: UploadContext,
+  token: string,
+  expenseId: string | null,
+): Promise<PresignOutcome> {
+  const { uploadBase } = hostsFor(ctx.env);
+  const data = expenseId
+    ? { id: expenseId, source: UPLOAD_SOURCE, state: "expense" }
+    : { source: UPLOAD_SOURCE };
+  const query = new URLSearchParams({
+    context: "expense",
+    data: JSON.stringify(data),
+  });
+  const fetchImpl = ctx.fetchImpl ?? fetch;
+
+  let res: Response;
+  try {
+    res = await fetchImpl(`${uploadBase}/file-upload/v1/url?${query}`, {
+      method: "GET",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${token}`,
+      },
+      signal: AbortSignal.timeout(UPLOAD_TIMEOUT_MS),
+    });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return {
+      ok: false,
+      httpStatus: null,
+      result: {
+        status: 502,
+        data: {
+          error: `Could not reach Morning (${ctx.env}): ${message}`,
+          transport: true,
+        },
+      },
+    };
+  }
+
+  const raw = await res.text().catch(() => "");
+  let body: unknown = raw;
+  try {
+    body = raw ? JSON.parse(raw) : null;
+  } catch {
+    // Not JSON — keep the raw text for the error below.
+  }
+
+  // 201 is the documented success. Treat any other 2xx as success too rather
+  // than pinning the exact code, but anything else is Morning saying no.
+  if (!res.ok) {
+    return {
+      ok: false,
+      httpStatus: res.status,
+      result: {
+        status: res.status === 429 ? 429 : 502,
+        data: {
+          error: "Morning refused to issue an upload URL.",
+          httpStatus: res.status,
+          morning: body,
+        },
+      },
+    };
+  }
+
+  const parsed = body as Partial<PresignedPost> | null;
+  if (
+    !parsed ||
+    typeof parsed.url !== "string" ||
+    typeof parsed.fields !== "object" ||
+    parsed.fields === null
+  ) {
+    return {
+      ok: false,
+      httpStatus: res.status,
+      result: {
+        status: 502,
+        data: {
+          error:
+            "Morning returned an upload URL in a shape this extension does not understand.",
+          // Key names only, never the body. A malformed-but-2xx response can
+          // still carry `url` and `fields`, and those are a bearer capability
+          // for the bucket that must not reach the container.
+          keys: Object.keys((body ?? {}) as Record<string, unknown>),
+        },
+      },
+    };
+  }
+
+  return {
+    ok: true,
+    presigned: {
+      url: parsed.url,
+      fields: parsed.fields as Record<string, string>,
+      // Absent or nonsensical → 0, which the caller reads as "no stated cap".
+      maxFileSize:
+        typeof parsed.maxFileSize === "number" && parsed.maxFileSize > 0
+          ? parsed.maxFileSize
+          : 0,
+    },
+  };
+}
+
+/**
+ * Step 2 — the pre-signed POST itself.
+ *
+ * Every field Morning returned goes in first, in the order returned, and `file`
+ * goes LAST: an S3 pre-signed POST ignores anything after the file part, so a
+ * field appended afterwards is silently dropped and the signature fails.
+ *
+ * No Authorization header. The signature is in the fields; sending a bearer
+ * token to a bucket would leak it to a third party for no benefit.
+ *
+ * NOT retried. A POST that failed midway may already have created a draft, and
+ * a blind retry risks a duplicate expense against real books. Report instead.
+ */
+async function putToBucket(
+  ctx: UploadContext,
+  presigned: PresignedPost,
+  file: LoadedFile,
+): Promise<CapabilityResult | null> {
+  const form = new FormData();
+  for (const [key, value] of Object.entries(presigned.fields)) {
+    form.append(key, String(value));
+  }
+  // Give the part its real content type. Morning's `fields` carry no
+  // Content-Type condition, so an untyped part would not break the signature —
+  // but it would reach the parser as application/octet-stream, and being parsed
+  // is the entire point of an expense draft.
+  form.append(
+    "file",
+    new Blob([new Uint8Array(file.bytes)], { type: extToMime(file.name) }),
+    file.name,
+  );
+
+  const fetchImpl = ctx.fetchImpl ?? fetch;
+  let res: Response;
+  try {
+    res = await fetchImpl(presigned.url, {
+      method: "POST",
+      body: form,
+      signal: AbortSignal.timeout(UPLOAD_TIMEOUT_MS),
+    });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return {
+      status: 502,
+      data: {
+        error: `The upload did not complete: ${message}`,
+        transport: true,
+      },
+    };
+  }
+
+  if (res.status === 403) {
+    // The overwhelmingly likely cause, and the one the user can act on.
+    return {
+      status: 502,
+      data: {
+        error:
+          "The upload link expired before the file finished uploading (it is valid for 60 seconds). Send the file again.",
+        expired: true,
+      },
+    };
+  }
+
+  // S3 is not described by Morning's OpenAPI document, so the exact success
+  // code is not spec-verified. A pre-signed POST with no `success_action_status`
+  // answers 204; accept any 2xx rather than pinning it.
+  if (!res.ok) {
+    // Only S3's <Code> element, never the raw body. An error document can echo
+    // request material — policy content among it — and the pre-signed fields are
+    // a bearer capability for the bucket that must not reach the container.
+    const body = await res.text().catch(() => "");
+    const code = body.match(/<Code>([^<]{1,64})<\/Code>/)?.[1];
+    return {
+      status: 502,
+      data: {
+        error: "The storage service rejected the upload.",
+        httpStatus: res.status,
+        ...(code ? { code } : {}),
+        transport: true,
+      },
+    };
+  }
+
+  return null;
+}
+
+/**
+ * The `expense-upload` verb.
+ *
+ * Tokens come from the caller, but the one-401-retry policy lives here, because
+ * only this module knows which of the two hops is safe to repeat. Step 1 is
+ * idempotent — it just asks for a URL — so a stale cached token costs one
+ * re-mint. Step 2 is never retried at all: a POST that failed midway may
+ * already have created a draft.
+ */
+export async function expenseUpload(
+  ctx: UploadContext,
+  body: Record<string, unknown>,
+  tokens: TokenProvider,
+): Promise<CapabilityResult> {
+  const rawPath = body.path;
+  const displayName = typeof rawPath === "string" ? rawPath : "(no path)";
+
+  const resolved = await resolveInSpace(ctx.spacesDir, ctx.spaceId, rawPath);
+  if (!resolved.ok) {
+    // WARN host-side with the detail, generic to the caller. A silent refusal
+    // is indistinguishable from "never happened" in the host log, and an
+    // informative one is a filesystem oracle for the container.
+    ctx.logDenial?.("morning expense-upload: path not usable", {
+      spaceId: ctx.spaceId,
+      requested: displayName,
+      reason: resolved.reason,
+    });
+    if (resolved.reason === "missing") {
+      // A typo should read as a typo. Telling the model the file is simply not
+      // there is what makes it list `inbox/` instead of guessing again.
+      return {
+        status: 404,
+        data: { error: `No such file: ${displayName}` },
+      };
+    }
+    return {
+      status: 400,
+      data: {
+        error:
+          "expense-upload needs a path to a file inside this space's workspace, such as inbox/receipt.pdf.",
+      },
+    };
+  }
+
+  const loaded = await loadFile(resolved.absPath, displayName);
+  if (isResult(loaded)) return loaded;
+
+  const expenseId =
+    typeof body.expenseId === "string" && body.expenseId.trim()
+      ? body.expenseId.trim()
+      : null;
+
+  // One retry, matching `apiCall`'s policy: the token is either stale (a single
+  // re-mint fixes it) or the credentials are rejected (a loop would hammer the
+  // endpoint and still fail). The second 401 is recorded so `statusCheck` stops
+  // reporting "connected" through a real auth failure.
+  let presigned: PresignedPost | undefined;
+  for (const attempt of [0, 1]) {
+    const token = await tokens.getToken(attempt === 1);
+    if (!token.ok) return token.result;
+
+    const outcome = await requestUploadUrl(ctx, token.token, expenseId);
+    if (outcome.ok) {
+      presigned = outcome.presigned;
+      break;
+    }
+    if (outcome.httpStatus === 401) {
+      if (attempt === 0) continue;
+      tokens.recordAuthError(
+        `Morning returned 401 after a token refresh (${ctx.env}).`,
+      );
+    }
+    return outcome.result;
+  }
+  if (!presigned) {
+    // Unreachable: the loop either breaks with a value or returns.
+    return {
+      status: 502,
+      data: { error: "Morning did not issue an upload URL.", transport: true },
+    };
+  }
+
+  // Between the two legs, and only here: the cap is Morning's own number, not a
+  // guess, so it cannot be checked before step 1 returns it. Checking it before
+  // step 2 means an oversized file fails instantly rather than burning the
+  // 60-second window on an upload that was always going to be refused.
+  if (
+    presigned.maxFileSize > 0 &&
+    loaded.bytes.length > presigned.maxFileSize
+  ) {
+    return {
+      status: 413,
+      data: {
+        error: `${loaded.name} is ${loaded.bytes.length} bytes; Morning accepts at most ${presigned.maxFileSize}.`,
+        maxFileSize: presigned.maxFileSize,
+      },
+    };
+  }
+
+  const failed = await putToBucket(ctx, presigned, loaded);
+  if (failed) return failed;
+
+  return {
+    data: {
+      uploaded: true,
+      mode: expenseId ? "attached" : "draft",
+      expenseId,
+      file: loaded.name,
+      // Said plainly because it is the thing that misleads: Morning has ACCEPTED
+      // the file, not finished with it. Parsing is asynchronous and its outcome
+      // arrives on a webhook no extension can receive.
+      note: "Morning accepted the file. It is parsed asynchronously — use expense-draft-search to see whether the draft appeared.",
+    },
+  };
+}

package/examples/extensions/morning/skill/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: morning
-description: Issue and look up tax documents in Morning (Green Invoice) — invoices, receipts, quotes — and find or create clients. Use when someone asks to issue, produce or send an invoice or receipt, asks what was invoiced in a period, or asks about a client's documents. Fires on חשבונית, חשבונית מס, קבלה, הצעת מחיר, תוציא חשבונית, תפיק חשבונית, לשלוח חשבונית, מורנינג, גרין אינבויס, חשבונית ירוקה, invoice, receipt, quote, bill a client. Not for expenses, supplier documents or uploading a receipt photo — those are not supported yet, say so.
+description: Issue and look up tax documents in Morning (Green Invoice) — invoices, receipts, quotes — find or create clients, and upload a supplier receipt as an expense draft. Use when someone asks to issue, produce or send an invoice or receipt, asks what was invoiced in a period, asks about a client's documents, or sends a receipt or supplier invoice to file. Fires on חשבונית, חשבונית מס, קבלה, הצעת מחיר, תוציא חשבונית, תפיק חשבונית, לשלוח חשבונית, מורנינג, גרין אינבויס, חשבונית ירוקה, הוצאה, קבלה מספק, תעלה קבלה, תכניס את הקבלה, invoice, receipt, quote, bill a client, expense, upload a receipt, file this receipt. Not for entering an expense by hand or payment collection — those are not supported yet, say so.
 allowed-tools: Bash
 ---
 
@@ -52,6 +52,32 @@ behaviour and not an error to work around.
 | Issue a document | `document-create` | preview body + `"issueToken":"…"` |
 | Find documents | `document-search` | `mrctl capability morning document-search '{"fromDate":"2026-09-01","toDate":"2026-09-30"}'` |
 | Get download links | `document-links` | `mrctl capability morning document-links '{"id":"<document id>"}'` |
+| Upload a receipt (expense) | `expense-upload` | `mrctl capability morning expense-upload '{"path":"inbox/receipt.pdf"}'` |
+| Check uploaded receipts | `expense-draft-search` | `mrctl capability morning expense-draft-search '{"fromDate":"2026-09-01"}'` |
+
+### Uploading a receipt someone sent
+
+A file the user sends arrives in `inbox/`. Pass its path **relative to the
+current workspace** — never an absolute path, and never the file's contents:
+
+```bash
+mrctl capability morning expense-upload '{"path":"inbox/receipt-2026-09-06.pdf"}'
+```
+
+To attach the scan to an expense that already exists in Morning, add its id:
+
+```bash
+mrctl capability morning expense-upload '{"path":"inbox/receipt.pdf","expenseId":"<expense id>"}'
+```
+
+**A successful upload means Morning accepted the file, not that the expense
+exists.** Morning reads the receipt asynchronously and creates a *draft*, which
+a human approves in Morning's own interface. Say that — "it is in Morning
+waiting for approval" — rather than "the expense was created". To see whether
+the draft appeared, use `expense-draft-search`; the answer may take a minute.
+
+Do not upload the same receipt twice to "make sure". Duplicates become two
+drafts a human then has to untangle. Check with `expense-draft-search` instead.
 
 ### Document body
 
@@ -139,6 +165,10 @@ not reissue — the document is already there.
 
 ## Not supported yet
 
-Expenses, supplier documents, uploading a receipt or invoice photo, and payment
-collection are not available through this skill. If asked, say so plainly rather
-than attempting a workaround.
+Creating an expense from typed-in details (`POST /expenses`), editing or closing
+an existing expense, and payment collection are not available through this
+skill. If asked, say so plainly rather than attempting a workaround.
+
+Uploading a receipt file *is* supported — see `expense-upload` above. What is
+not supported is entering an expense by hand: that needs an accounting
+classification, which is the bookkeeper's judgment call, not the assistant's.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mercury-agent",
-  "version": "0.18.2",
+  "version": "0.19.0",
   "description": "Personal AI assistant for chat platforms (WhatsApp, Slack, Discord, Telegram)",
   "license": "MIT",
   "author": "Avishai Tsabari",
@@ -24,6 +24,10 @@
       "types": "./src/core/global-admin.ts",
       "default": "./src/core/global-admin.ts"
     },
+    "./core/media": {
+      "types": "./src/core/media.ts",
+      "default": "./src/core/media.ts"
+    },
     "./core/model-leg": {
       "types": "./src/core/model-leg.ts",
       "default": "./src/core/model-leg.ts"
@@ -80,8 +84,8 @@
     "typecheck": "bunx tsc --noEmit",
     "typecheck:scripts": "bunx tsc --noEmit -p tsconfig.scripts.json",
     "typecheck:examples": "bunx tsc --noEmit -p tsconfig.examples.json",
-    "lint": "bunx biome check src/ tests/ scripts/space-profile.ts scripts/football-harness.ts scripts/football-audit.ts scripts/ops-preflight.ts examples/extensions/archive/ examples/extensions/feed-watch/ examples/extensions/napkin/ examples/extensions/pinchtab/ examples/extensions/overview/ examples/extensions/longview/ examples/extensions/yahoo-mail/ examples/extensions/morning/",
-    "lint:fix": "bunx biome check --fix src/ tests/ scripts/space-profile.ts scripts/football-harness.ts scripts/football-audit.ts scripts/ops-preflight.ts examples/extensions/archive/ examples/extensions/feed-watch/ examples/extensions/napkin/ examples/extensions/pinchtab/ examples/extensions/overview/ examples/extensions/longview/ examples/extensions/yahoo-mail/ examples/extensions/morning/",
+    "lint": "bunx biome check src/ tests/ scripts/space-profile.ts scripts/football-harness.ts scripts/football-audit.ts scripts/ops-preflight.ts scripts/archive-erase-space.ts examples/extensions/archive/ examples/extensions/feed-watch/ examples/extensions/gws/ examples/extensions/napkin/ examples/extensions/pinchtab/ examples/extensions/overview/ examples/extensions/longview/ examples/extensions/yahoo-mail/ examples/extensions/morning/",
+    "lint:fix": "bunx biome check --fix src/ tests/ scripts/space-profile.ts scripts/football-harness.ts scripts/football-audit.ts scripts/ops-preflight.ts examples/extensions/archive/ examples/extensions/feed-watch/ examples/extensions/gws/ examples/extensions/napkin/ examples/extensions/pinchtab/ examples/extensions/overview/ examples/extensions/longview/ examples/extensions/yahoo-mail/ examples/extensions/morning/",
     "check:silent-catch": "bun run scripts/check-silent-catch.ts",
     "check:sync-calls": "bun run scripts/check-sync-calls.ts",
     "check:dep-floors": "bun run scripts/check-dep-floors.ts",