@vellumai/cli 0.11.6 → 0.11.7-staging.2

package/AGENTS.md

@@ -12,7 +12,7 @@ Commands here operate on or across **assistant instances** — creating, startin
 
 For commands scoped to a **single running assistant's** local state (config, memory, contacts), see `assistant/src/cli/AGENTS.md`.
 
-Examples: `hatch`, `wake`, `sleep`, `retire`, `ps`, `ssh` belong here. `config`, `contacts`, `memory` belong in `assistant/src/cli/`.
+Examples: `hatch`, `wake`, `sleep`, `retire`, `ps`, `ssh` belong here. `config`, `memory` belong in `assistant/src/cli/`. Contact ACL writes belong on `gateway contacts` (via `vellum exec --service gateway`), not on `assistant contacts` or `vellum gateway`.
 
 ## Assistant targeting convention
 
@@ -57,6 +57,8 @@ The CLI is a generic lifecycle manager. It must **never** contain references to
 
 Cross-package imports into `skills/` are forbidden. The CLI is distributed as an npm package; anything outside `cli/` is not included in the tarball and will fail to resolve at runtime.
 
+Workspace packages that `cli/src` never imports may still be listed in `package.json` `dependencies` and `bundledDependencies` when a bundled dependency depends on them (for example `@vellumai/avatar-manifest`, pulled in by `@vellumai/local-mode`); `bundledDependencies` only nests a `file:` dep when it is a direct dependency of the CLI.
+
 ## Boundary: No `.vellum/` directory access
 
 The CLI must **never** read from or write to the `.vellum/` directory (e.g. `~/.vellum/protected/`, `<instanceDir>/.vellum/`). That directory structure is an **assistant daemon / gateway implementation detail**. The CLI's job is to spawn those processes and pass configuration via environment variables — not to reach into their internal storage.

package/knip.json

@@ -9,6 +9,7 @@
   ],
   "project": ["src/**/*.ts", "src/**/*.tsx"],
   "ignoreDependencies": [
+    "@vellumai/avatar-manifest",
     "@vellumai/environments",
     "@vellumai/ipc-server-utils",
     "@vellumai/local-mode",

package/node_modules/@vellumai/avatar-manifest/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "@vellumai/avatar-manifest",
+  "version": "0.0.1",
+  "private": true,
+  "license": "MIT",
+  "type": "module",
+  "exports": {
+    ".": "./src/index.ts"
+  },
+  "scripts": {
+    "typecheck": "bunx tsc --noEmit",
+    "test": "bun test src/"
+  },
+  "devDependencies": {
+    "@types/bun": "1.3.11",
+    "typescript": "5.9.3"
+  }
+}

package/node_modules/@vellumai/avatar-manifest/src/__tests__/manifest.test.ts

@@ -0,0 +1,173 @@
+import { describe, expect, test } from "bun:test";
+
+import {
+  AVATAR_FIELD_MAX_LENGTH,
+  deriveAvatarFromLegacyFiles,
+  parseAvatarManifest,
+  resolveAvatarFromFiles,
+} from "../manifest.js";
+
+const overlong = "x".repeat(AVATAR_FIELD_MAX_LENGTH + 1);
+
+const traits = { bodyShape: "round", eyeStyle: "dot", color: "#abc" };
+const image = { updatedAt: "2026-01-01T00:00:00.000Z", etag: "abc" };
+
+describe("parseAvatarManifest", () => {
+  test("accepts a character manifest", () => {
+    expect(
+      parseAvatarManifest({ kind: "character", traits, source: "builder" }),
+    ).toEqual({ kind: "character", traits, source: "builder", image: null });
+  });
+
+  test("accepts an image manifest", () => {
+    expect(parseAvatarManifest({ kind: "image", image })).toEqual({
+      kind: "image",
+      traits: null,
+      source: null,
+      image,
+    });
+  });
+
+  test("accepts kind none without a payload", () => {
+    expect(parseAvatarManifest({ kind: "none" })).toEqual({
+      kind: "none",
+      traits: null,
+      source: null,
+      image: null,
+    });
+  });
+
+  test("rejects an overlong trait or image field", () => {
+    expect(
+      parseAvatarManifest({
+        kind: "character",
+        traits: { ...traits, color: overlong },
+      }),
+    ).toBeNull();
+    expect(
+      parseAvatarManifest({
+        kind: "image",
+        image: { ...image, etag: overlong },
+      }),
+    ).toBeNull();
+    expect(
+      parseAvatarManifest({
+        kind: "character",
+        traits: { ...traits, color: "x".repeat(AVATAR_FIELD_MAX_LENGTH) },
+      }),
+    ).not.toBeNull();
+  });
+
+  test("normalizes an unknown source to null", () => {
+    expect(
+      parseAvatarManifest({ kind: "image", image, source: "unknown" }),
+    ).toEqual({ kind: "image", traits: null, source: null, image });
+    expect(parseAvatarManifest({ kind: "none", source: 7 })).toEqual({
+      kind: "none",
+      traits: null,
+      source: null,
+      image: null,
+    });
+  });
+
+  test("drops payload irrelevant to the kind", () => {
+    expect(
+      parseAvatarManifest({ kind: "image", image, traits: { bodyShape: 1 } }),
+    ).toEqual({ kind: "image", traits: null, source: null, image });
+    expect(
+      parseAvatarManifest({ kind: "character", traits, image: "stale" }),
+    ).toEqual({ kind: "character", traits, source: null, image: null });
+    expect(parseAvatarManifest({ kind: "none", traits, image })).toEqual({
+      kind: "none",
+      traits: null,
+      source: null,
+      image: null,
+    });
+  });
+
+  test.each([
+    ["non-object", "nope"],
+    ["missing kind", {}],
+    ["invalid kind", { kind: "sprite", traits }],
+    ["character without traits", { kind: "character" }],
+    [
+      "character with incomplete traits",
+      { kind: "character", traits: { bodyShape: "round" } },
+    ],
+    ["image without meta", { kind: "image" }],
+    ["image with empty etag", { kind: "image", image: { ...image, etag: "" } }],
+  ])("rejects %s", (_label, value) => {
+    expect(parseAvatarManifest(value)).toBeNull();
+  });
+});
+
+describe("deriveAvatarFromLegacyFiles", () => {
+  test("overlong traits are invalid", () => {
+    expect(
+      deriveAvatarFromLegacyFiles({
+        traitsJson: { ...traits, bodyShape: overlong },
+        hasImage: true,
+      }),
+    ).toEqual({ kind: "image" });
+  });
+
+  test("valid traits win over a present image", () => {
+    expect(
+      deriveAvatarFromLegacyFiles({ traitsJson: traits, hasImage: true }),
+    ).toEqual({ kind: "character", traits });
+  });
+
+  test("invalid traits fall back to the image", () => {
+    expect(
+      deriveAvatarFromLegacyFiles({
+        traitsJson: { bodyShape: 1 },
+        hasImage: true,
+      }),
+    ).toEqual({ kind: "image" });
+  });
+
+  test("nothing usable yields none", () => {
+    expect(
+      deriveAvatarFromLegacyFiles({ traitsJson: undefined, hasImage: false }),
+    ).toEqual({ kind: "none" });
+  });
+});
+
+describe("resolveAvatarFromFiles", () => {
+  test("a valid manifest decides regardless of sidecars", () => {
+    expect(
+      resolveAvatarFromFiles({
+        manifestJson: { kind: "none" },
+        traitsJson: traits,
+        hasImage: true,
+      }),
+    ).toEqual({ kind: "none" });
+    expect(
+      resolveAvatarFromFiles({
+        manifestJson: { kind: "image", image },
+        traitsJson: traits,
+        hasImage: true,
+      }),
+    ).toEqual({ kind: "image", image });
+  });
+
+  test("a partial image manifest falls back to traits-first derivation", () => {
+    expect(
+      resolveAvatarFromFiles({
+        manifestJson: { kind: "image" },
+        traitsJson: traits,
+        hasImage: true,
+      }),
+    ).toEqual({ kind: "character", traits });
+  });
+
+  test("a legacy image carries no manifest metadata", () => {
+    expect(
+      resolveAvatarFromFiles({
+        manifestJson: undefined,
+        traitsJson: undefined,
+        hasImage: true,
+      }),
+    ).toEqual({ kind: "image", image: null });
+  });
+});

package/node_modules/@vellumai/avatar-manifest/src/__tests__/read.test.ts

@@ -0,0 +1,114 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import {
+  mkdirSync,
+  mkdtempSync,
+  rmSync,
+  symlinkSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { AVATAR_SIDECAR_MAX_BYTES, readWorkspaceAvatar } from "../read.js";
+
+const traits = { bodyShape: "round", eyeStyle: "dot", color: "#abc" };
+
+describe("readWorkspaceAvatar", () => {
+  let workspaceDir: string;
+  let avatarDir: string;
+
+  const write = (name: string, contents: string): void => {
+    mkdirSync(avatarDir, { recursive: true });
+    writeFileSync(join(avatarDir, name), contents);
+  };
+
+  beforeEach(() => {
+    workspaceDir = mkdtempSync(join(tmpdir(), "avatar-manifest-"));
+    avatarDir = join(workspaceDir, "data", "avatar");
+  });
+
+  afterEach(() => {
+    rmSync(workspaceDir, { recursive: true, force: true });
+  });
+
+  test("missing avatar dir yields none", () => {
+    expect(readWorkspaceAvatar(workspaceDir)).toEqual({ kind: "none" });
+  });
+
+  test("manifest character returns its traits", () => {
+    write("avatar.json", JSON.stringify({ kind: "character", traits }));
+    write("avatar-image.png", "png");
+    expect(readWorkspaceAvatar(workspaceDir)).toEqual({
+      kind: "character",
+      traits,
+    });
+  });
+
+  test("image resolves to the PNG path", () => {
+    write("avatar-image.png", "png");
+    expect(readWorkspaceAvatar(workspaceDir)).toEqual({
+      kind: "image",
+      imagePath: join(avatarDir, "avatar-image.png"),
+    });
+  });
+
+  test("corrupt manifest falls back to the traits sidecar", () => {
+    write("avatar.json", "{ not json");
+    write("character-traits.json", JSON.stringify(traits));
+    expect(readWorkspaceAvatar(workspaceDir)).toEqual({
+      kind: "character",
+      traits,
+    });
+  });
+
+  test("oversized sidecars are treated as absent", () => {
+    const padded = JSON.stringify({
+      kind: "character",
+      traits,
+      pad: "x".repeat(AVATAR_SIDECAR_MAX_BYTES),
+    });
+    write("avatar.json", padded);
+    write("character-traits.json", JSON.stringify({ ...traits, pad: padded }));
+    expect(readWorkspaceAvatar(workspaceDir)).toEqual({ kind: "none" });
+  });
+
+  test("a sidecar at the cap still reads", () => {
+    const body = JSON.stringify({ kind: "character", traits, pad: "" });
+    write(
+      "avatar.json",
+      body.replace(
+        '"pad":""',
+        `"pad":"${"x".repeat(AVATAR_SIDECAR_MAX_BYTES - body.length)}"`,
+      ),
+    );
+    expect(readWorkspaceAvatar(workspaceDir)).toEqual({
+      kind: "character",
+      traits,
+    });
+  });
+
+  test("a symlinked avatar dir is treated as absent", () => {
+    const foreign = mkdtempSync(join(tmpdir(), "foreign-avatar-"));
+    writeFileSync(
+      join(foreign, "character-traits.json"),
+      JSON.stringify({
+        bodyShape: "blob",
+        eyeStyle: "curious",
+        color: "green",
+      }),
+    );
+    mkdirSync(join(workspaceDir, "data"), { recursive: true });
+    symlinkSync(foreign, avatarDir);
+    expect(readWorkspaceAvatar(workspaceDir)).toEqual({ kind: "none" });
+    rmSync(foreign, { recursive: true, force: true });
+  });
+
+  test("symlinked sidecars are treated as absent", () => {
+    const outside = join(workspaceDir, "outside.json");
+    writeFileSync(outside, JSON.stringify({ kind: "character", traits }));
+    mkdirSync(avatarDir, { recursive: true });
+    symlinkSync(outside, join(avatarDir, "avatar.json"));
+    symlinkSync(outside, join(avatarDir, "character-traits.json"));
+    expect(readWorkspaceAvatar(workspaceDir)).toEqual({ kind: "none" });
+  });
+});

package/node_modules/@vellumai/avatar-manifest/src/index.ts

@@ -0,0 +1,29 @@
+/**
+ * @vellumai/avatar-manifest: the single source of truth for the on-disk
+ * avatar layout of an assistant workspace (`<workspace>/data/avatar`) and
+ * how its files resolve to an avatar.
+ *
+ * The daemon owns the files (it writes the manifest and sidecars); hosts
+ * such as the desktop app read them directly so a sleeping assistant still
+ * has an avatar in the chooser. Both go through the parsing and legacy
+ * derivation here so they cannot disagree. Leaf package: node builtins only.
+ */
+export {
+  AVATAR_IMAGE_FILENAME,
+  AVATAR_MANIFEST_FILENAME,
+  AVATAR_TRAITS_FILENAME,
+  resolveAvatarDir,
+} from "./layout.js";
+export {
+  deriveAvatarFromLegacyFiles,
+  parseAvatarManifest,
+} from "./manifest.js";
+export type {
+  AvatarImageMeta,
+  AvatarKind,
+  AvatarSource,
+  AvatarState,
+  CharacterTraits,
+} from "./manifest.js";
+export { readWorkspaceAvatar } from "./read.js";
+export type { WorkspaceAvatar } from "./read.js";

package/node_modules/@vellumai/avatar-manifest/src/layout.ts

@@ -0,0 +1,18 @@
+import { join } from "node:path";
+
+/** Path segments of the avatar directory below the workspace directory. */
+const AVATAR_DIR_SEGMENTS: readonly string[] = ["data", "avatar"];
+
+/** Avatar state manifest. */
+export const AVATAR_MANIFEST_FILENAME = "avatar.json";
+
+/** Legacy sidecar holding the persisted character traits. */
+export const AVATAR_TRAITS_FILENAME = "character-traits.json";
+
+/** The avatar PNG (uploaded, or rendered from the character traits). */
+export const AVATAR_IMAGE_FILENAME = "avatar-image.png";
+
+/** The avatar directory for a workspace (`<workspace>/data/avatar`). */
+export function resolveAvatarDir(workspaceDir: string): string {
+  return join(workspaceDir, ...AVATAR_DIR_SEGMENTS);
+}

package/node_modules/@vellumai/avatar-manifest/src/manifest.ts

@@ -0,0 +1,156 @@
+export type AvatarKind = "character" | "image" | "none";
+export type AvatarSource = "builder" | "upload" | "ai";
+
+export interface CharacterTraits {
+  bodyShape: string;
+  eyeStyle: string;
+  color: string;
+}
+
+export interface AvatarImageMeta {
+  updatedAt: string;
+  etag: string;
+}
+
+/** The persisted manifest (`avatar.json`). */
+export interface AvatarState {
+  kind: AvatarKind;
+  traits: CharacterTraits | null;
+  source: AvatarSource | null;
+  image: AvatarImageMeta | null;
+}
+
+const AVATAR_KINDS: ReadonlySet<string> = new Set<AvatarKind>([
+  "character",
+  "image",
+  "none",
+]);
+
+const AVATAR_SOURCES: ReadonlySet<string> = new Set<AvatarSource>([
+  "builder",
+  "upload",
+  "ai",
+]);
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return !!value && typeof value === "object";
+}
+
+/** Longest string any manifest field may carry (trait ids, etags, timestamps). */
+export const AVATAR_FIELD_MAX_LENGTH = 256;
+
+function isBoundedString(value: unknown): value is string {
+  return (
+    typeof value === "string" &&
+    value.length > 0 &&
+    value.length <= AVATAR_FIELD_MAX_LENGTH
+  );
+}
+
+/** Narrows an unknown value to valid CharacterTraits (presence and length only). */
+function isValidCharacterTraits(value: unknown): value is CharacterTraits {
+  return (
+    isRecord(value) &&
+    isBoundedString(value.bodyShape) &&
+    isBoundedString(value.eyeStyle) &&
+    isBoundedString(value.color)
+  );
+}
+
+/** Narrows an unknown value to valid AvatarImageMeta (presence and length only). */
+function isValidAvatarImageMeta(value: unknown): value is AvatarImageMeta {
+  return (
+    isRecord(value) &&
+    isBoundedString(value.updatedAt) &&
+    isBoundedString(value.etag)
+  );
+}
+
+/**
+ * Validates a parsed `avatar.json`. Returns `null` for a non-object, an
+ * invalid or missing `kind`, or a valid `kind` whose per-kind payload is
+ * missing or malformed, so callers fall back to legacy derivation instead
+ * of surfacing an avatar with null traits/image. An unknown `source` and any
+ * payload irrelevant to the kind normalize to `null` rather than passing
+ * through, so the result always satisfies the wire shape.
+ */
+export function parseAvatarManifest(value: unknown): AvatarState | null {
+  if (!isRecord(value)) {
+    return null;
+  }
+  if (typeof value.kind !== "string" || !AVATAR_KINDS.has(value.kind)) {
+    return null;
+  }
+  const kind = value.kind as AvatarKind;
+  const source =
+    typeof value.source === "string" && AVATAR_SOURCES.has(value.source)
+      ? (value.source as AvatarSource)
+      : null;
+  if (kind === "character") {
+    if (!isValidCharacterTraits(value.traits)) {
+      return null;
+    }
+    return { kind, traits: value.traits, source, image: null };
+  }
+  if (kind === "image") {
+    if (!isValidAvatarImageMeta(value.image)) {
+      return null;
+    }
+    return { kind, traits: null, source, image: value.image };
+  }
+  return { kind, traits: null, source, image: null };
+}
+
+type LegacyAvatarDerivation =
+  | { kind: "character"; traits: CharacterTraits }
+  | { kind: "image" }
+  | { kind: "none" };
+
+/**
+ * Derives the avatar from the legacy sidecar files when there is no usable
+ * manifest. Traits-first: valid traits win even when the PNG also exists,
+ * because the builder writes the rendered PNG after the traits file, so
+ * mtimes cannot tell a built character from an uploaded image.
+ */
+export function deriveAvatarFromLegacyFiles(input: {
+  traitsJson: unknown;
+  hasImage: boolean;
+}): LegacyAvatarDerivation {
+  if (isValidCharacterTraits(input.traitsJson)) {
+    return { kind: "character", traits: input.traitsJson };
+  }
+  return input.hasImage ? { kind: "image" } : { kind: "none" };
+}
+
+type ResolvedAvatar =
+  | { kind: "character"; traits: CharacterTraits }
+  | { kind: "image"; image: AvatarImageMeta | null }
+  | { kind: "none" };
+
+/**
+ * Resolves the avatar from the parsed avatar files: the manifest when it is
+ * valid, otherwise the legacy derivation. `image` carries the manifest's
+ * metadata when the manifest decided, and is null for a legacy PNG.
+ */
+export function resolveAvatarFromFiles(input: {
+  manifestJson: unknown;
+  traitsJson: unknown;
+  hasImage: boolean;
+}): ResolvedAvatar {
+  const manifest = parseAvatarManifest(input.manifestJson);
+  if (manifest) {
+    switch (manifest.kind) {
+      case "character":
+        return {
+          kind: "character",
+          traits: manifest.traits as CharacterTraits,
+        };
+      case "image":
+        return { kind: "image", image: manifest.image };
+      case "none":
+        return { kind: "none" };
+    }
+  }
+  const legacy = deriveAvatarFromLegacyFiles(input);
+  return legacy.kind === "image" ? { kind: "image", image: null } : legacy;
+}

package/node_modules/@vellumai/avatar-manifest/src/read.ts

@@ -0,0 +1,109 @@
+import {
+  closeSync,
+  constants,
+  existsSync,
+  fstatSync,
+  lstatSync,
+  openSync,
+  readFileSync,
+  realpathSync,
+} from "node:fs";
+import { basename, dirname, join, sep } from "node:path";
+
+import {
+  AVATAR_IMAGE_FILENAME,
+  AVATAR_MANIFEST_FILENAME,
+  AVATAR_TRAITS_FILENAME,
+  resolveAvatarDir,
+} from "./layout.js";
+import { type CharacterTraits, resolveAvatarFromFiles } from "./manifest.js";
+
+export type WorkspaceAvatar =
+  | { kind: "character"; traits: CharacterTraits }
+  | { kind: "image"; imagePath: string }
+  | { kind: "none" };
+
+/** Largest sidecar a host parses; a bigger one counts as absent. */
+export const AVATAR_SIDECAR_MAX_BYTES = 64 * 1024;
+
+function isWithin(root: string, target: string): boolean {
+  return target === root || target.startsWith(root + sep);
+}
+
+/**
+ * Sidecars are read through one validated descriptor: the parent must
+ * resolve beneath the real workspace (a symlinked avatar dir is rejected),
+ * the file must be a regular file at or under the cap, and the open uses
+ * O_NOFOLLOW with a post-open recheck so a swap between check and read
+ * cannot substitute another file. Anything else counts as absent.
+ */
+function readJsonFile(workspaceDir: string, filePath: string): unknown {
+  let fd: number | undefined;
+  try {
+    const realRoot = realpathSync(workspaceDir);
+    const realDir = realpathSync(dirname(filePath));
+    if (!isWithin(realRoot, realDir)) {
+      return undefined;
+    }
+    const realPath = join(realDir, basename(filePath));
+    const linkStats = lstatSync(realPath);
+    if (!linkStats.isFile() || linkStats.size > AVATAR_SIDECAR_MAX_BYTES) {
+      return undefined;
+    }
+    fd = openSync(realPath, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));
+    const stats = fstatSync(fd);
+    if (
+      !stats.isFile() ||
+      stats.dev !== linkStats.dev ||
+      stats.ino !== linkStats.ino ||
+      stats.size > AVATAR_SIDECAR_MAX_BYTES
+    ) {
+      return undefined;
+    }
+    const reopened = realpathSync(filePath);
+    if (!isWithin(realRoot, reopened)) {
+      return undefined;
+    }
+    const reopenedStats = lstatSync(reopened);
+    if (
+      !reopenedStats.isFile() ||
+      reopenedStats.dev !== stats.dev ||
+      reopenedStats.ino !== stats.ino
+    ) {
+      return undefined;
+    }
+    const text = readFileSync(fd, "utf-8");
+    if (Buffer.byteLength(text) > AVATAR_SIDECAR_MAX_BYTES) {
+      return undefined;
+    }
+    return JSON.parse(text) as unknown;
+  } catch {
+    return undefined;
+  } finally {
+    if (fd !== undefined) {
+      closeSync(fd);
+    }
+  }
+}
+
+/**
+ * Reads the avatar of a workspace directly off disk. Unreadable or corrupt
+ * files count as absent. For an image avatar the caller reads the PNG at
+ * `imagePath` itself, applying its own size policy; the file may be missing.
+ */
+export function readWorkspaceAvatar(workspaceDir: string): WorkspaceAvatar {
+  const avatarDir = resolveAvatarDir(workspaceDir);
+  const imagePath = join(avatarDir, AVATAR_IMAGE_FILENAME);
+  const resolved = resolveAvatarFromFiles({
+    manifestJson: readJsonFile(
+      workspaceDir,
+      join(avatarDir, AVATAR_MANIFEST_FILENAME),
+    ),
+    traitsJson: readJsonFile(
+      workspaceDir,
+      join(avatarDir, AVATAR_TRAITS_FILENAME),
+    ),
+    hasImage: existsSync(imagePath),
+  });
+  return resolved.kind === "image" ? { kind: "image", imagePath } : resolved;
+}

package/node_modules/@vellumai/avatar-manifest/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "types": ["bun"]
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}

package/node_modules/@vellumai/environments/package.json

@@ -6,7 +6,8 @@
   "type": "module",
   "exports": {
     ".": "./src/index.ts",
-    "./seeds": "./src/seeds.ts"
+    "./seeds": "./src/seeds.ts",
+    "./shell": "./src/shell.ts"
   },
   "scripts": {
     "typecheck": "bunx tsc --noEmit",