@openparachute/hub 0.7.7-rc.8 → 0.7.7

package/src/__tests__/hub-settings.test.ts

@@ -12,30 +12,38 @@ import { join } from "node:path";
 import { hubDbPath, openHubDb } from "../hub-db.ts";
 import {
   DEFAULT_MODULE_INSTALL_CHANNEL,
+  DEFAULT_ROOT_MODE,
   DEFAULT_ROOT_REDIRECT,
   FIRST_CLIENT_AUTO_APPROVE_WINDOW_MS,
   MODULE_INSTALL_CHANNELS,
+  PARACHUTE_HUB_ROOT_MODE_ENV,
   PARACHUTE_HUB_ROOT_REDIRECT_ENV,
   PARACHUTE_INSTALL_CHANNEL_ENV,
   PARACHUTE_MODULE_CHANNEL_ENV,
+  ROOT_MODES,
   SETUP_EXPOSE_MODES,
   consumeFirstClientAutoApproveWindow,
   deleteSetting,
   getHubOrigin,
   getModuleInstallChannel,
+  getRootMode,
   getRootRedirect,
   getSetting,
   isFirstClientAutoApproveWindowOpen,
   isModuleInstallChannel,
   isNotesRedirectDisabled,
+  isRootMode,
   isSafeRedirectPath,
   isSetupExposeMode,
   openFirstClientAutoApproveWindow,
+  resolveRootMode,
+  resolveRootModeDetailed,
   resolveRootRedirect,
   resolveRootRedirectDetailed,
   setHubOrigin,
   setModuleInstallChannel,
   setNotesRedirectDisabled,
+  setRootMode,
   setRootRedirect,
   setSetting,
 } from "../hub-settings.ts";
@@ -363,9 +371,9 @@ describe("hub-settings — module install channel bootstrap", () => {
       // First read with env=rc — env wins, returns "rc". DB stays empty
       // (no auto-write to DB when env is set, per the design that
       // preserves the SPA's last-write as the env-unset fallback).
-      expect(
-        getModuleInstallChannel(db, { env: { [PARACHUTE_INSTALL_CHANNEL_ENV]: "rc" } }),
-      ).toBe("rc");
+      expect(getModuleInstallChannel(db, { env: { [PARACHUTE_INSTALL_CHANNEL_ENV]: "rc" } })).toBe(
+        "rc",
+      );
       // Second read with env=latest — env wins again (would have returned
       // "rc" under the old DB-after-first-seed behavior).
       expect(
@@ -386,9 +394,9 @@ describe("hub-settings — module install channel bootstrap", () => {
     const db = openHubDb(hubDbPath(dir));
     try {
       // PARACHUTE_INSTALL_CHANNEL — canonical name (matches install.ts).
-      expect(
-        getModuleInstallChannel(db, { env: { [PARACHUTE_INSTALL_CHANNEL_ENV]: "rc" } }),
-      ).toBe("rc");
+      expect(getModuleInstallChannel(db, { env: { [PARACHUTE_INSTALL_CHANNEL_ENV]: "rc" } })).toBe(
+        "rc",
+      );
       // PARACHUTE_MODULE_CHANNEL — legacy alias, still recognized.
       const db2 = openHubDb(join(mkdtempSync(join(tmpdir(), "phub-hsalt-")), "hub.db"));
       try {
@@ -801,3 +809,99 @@ describe("hub-settings — root_redirect storage + resolution", () => {
     expect(resolveRootRedirect(null, { env })).toBe("/surface/from-env");
   });
 });
+
+describe("hub-settings — root_mode storage + resolution", () => {
+  let dir: string;
+  beforeEach(() => {
+    dir = mkdtempSync(join(tmpdir(), "hub-settings-root-mode-"));
+  });
+  afterEach(() => rmSync(dir, { recursive: true, force: true }));
+
+  const noEnv: NodeJS.ProcessEnv = {};
+  const silent = () => {};
+
+  test("isRootMode + ROOT_MODES", () => {
+    expect(ROOT_MODES).toEqual(["redirect", "serve-app"]);
+    expect(isRootMode("redirect")).toBe(true);
+    expect(isRootMode("serve-app")).toBe(true);
+    expect(isRootMode("serveapp")).toBe(false);
+    expect(isRootMode(42)).toBe(false);
+  });
+
+  test("getRootMode round-trips serve-app via setRootMode", () => {
+    const db = openHubDb(hubDbPath(dir));
+    try {
+      expect(getRootMode(db)).toBeNull();
+      setRootMode(db, "serve-app");
+      expect(getRootMode(db)).toBe("serve-app");
+    } finally {
+      db.close();
+    }
+  });
+
+  test("setRootMode(null) and setRootMode('redirect') both clear the row (default = absence)", () => {
+    const db = openHubDb(hubDbPath(dir));
+    try {
+      setRootMode(db, "serve-app");
+      setRootMode(db, null);
+      expect(getRootMode(db)).toBeNull();
+      setRootMode(db, "serve-app");
+      setRootMode(db, "redirect"); // the default is stored as absence
+      expect(getRootMode(db)).toBeNull();
+      expect(getSetting(db, "root_mode")).toBeUndefined();
+    } finally {
+      db.close();
+    }
+  });
+
+  test("resolves to the redirect default when neither DB nor env is set", () => {
+    const db = openHubDb(hubDbPath(dir));
+    try {
+      expect(resolveRootMode(db, { env: noEnv })).toBe(DEFAULT_ROOT_MODE);
+      expect(resolveRootModeDetailed(db, { env: noEnv })).toEqual({
+        value: "redirect",
+        source: "default",
+      });
+    } finally {
+      db.close();
+    }
+  });
+
+  test("env override applies when no DB row; DB overrides env (DB is tier-1)", () => {
+    const db = openHubDb(hubDbPath(dir));
+    try {
+      const env = { [PARACHUTE_HUB_ROOT_MODE_ENV]: "serve-app" };
+      expect(resolveRootModeDetailed(db, { env })).toEqual({ value: "serve-app", source: "env" });
+      setRootMode(db, "serve-app");
+      // A DB "serve-app" over an env "redirect" resolves to db.
+      expect(
+        resolveRootModeDetailed(db, { env: { [PARACHUTE_HUB_ROOT_MODE_ENV]: "redirect" } }),
+      ).toEqual({ value: "serve-app", source: "db" });
+    } finally {
+      db.close();
+    }
+  });
+
+  test("an invalid DB row / env value is ignored → falls back to the redirect default", () => {
+    const db = openHubDb(hubDbPath(dir));
+    try {
+      setSetting(db, "root_mode", "bogus"); // hand-edited row bypassing write validation
+      expect(resolveRootMode(db, { env: noEnv, warn: silent })).toBe("redirect");
+      expect(getRootMode(db)).toBeNull(); // getRootMode also guards the invalid value
+      const env = { [PARACHUTE_HUB_ROOT_MODE_ENV]: "nonsense" };
+      expect(resolveRootModeDetailed(db, { env, warn: silent })).toEqual({
+        value: "redirect",
+        source: "default",
+      });
+    } finally {
+      db.close();
+    }
+  });
+
+  test("a null db (no state) resolves from env / default only", () => {
+    expect(resolveRootMode(null, { env: noEnv })).toBe("redirect");
+    expect(resolveRootMode(null, { env: { [PARACHUTE_HUB_ROOT_MODE_ENV]: "serve-app" } })).toBe(
+      "serve-app",
+    );
+  });
+});

package/src/__tests__/hub.test.ts

@@ -239,6 +239,35 @@ describe("renderHub — signed-out slimming (operator feedback)", () => {
   });
 });
 
+describe("renderHub — Get started tiles are uis[]-driven (W2-12)", () => {
+  // The tile logic runs client-side inside the discovery IIFE; these pins
+  // assert the emitted script's SHAPE (the JS-parses check above guards its
+  // validity). The section is uis[]-driven — one tile per active uis[]
+  // sub-unit, whichever mount identity (/surface/notes or
+  // /surface/parachute) an install serves — with the pre-W2-12 hardcoded
+  // "Open Notes" tile demoted to a fallback for surface-host rows that
+  // predate uis{} self-registration.
+  const html = renderHub({
+    session: { displayName: "operator", csrfToken: "csrf-w212" },
+  });
+
+  test("the discovery script iterates uis[] sub-units", () => {
+    expect(html).toContain("svc.uis");
+    // Inactive sub-units are skipped; absent status counts as active.
+    expect(html).toContain("ui.status");
+  });
+
+  test("the legacy 'Open Notes' hardcode survives only as the no-uis fallback", () => {
+    // Still present (pre-uis surface-host installs keep their CTA) …
+    expect(html).toContain("Open Notes");
+    expect(html).toContain("'/surface/notes/'");
+    // … but no longer keyed on the bare presence of parachute-surface as
+    // the PRIMARY path: the uis[] loop renders first, the hasSurface check
+    // only backstops an empty tile list.
+    expect(html).toContain("Legacy fallback");
+  });
+});
+
 describe("renderHub — signed-in indicator (rc.13)", () => {
   test("session user → 'Signed in as <name>' + inline POST form with CSRF", () => {
     const html = renderHub({

package/src/__tests__/install.test.ts

@@ -1,8 +1,17 @@
-import { describe, expect, test } from "bun:test";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 import { existsSync, mkdtempSync, readFileSync, realpathSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { defaultStartLifecycleOpts, install } from "../commands/install.ts";
+import { hubDbPath, openHubDb } from "../hub-db.ts";
+import {
+  PARACHUTE_HUB_ROOT_MODE_ENV,
+  PARACHUTE_HUB_ROOT_REDIRECT_ENV,
+  getRootMode,
+  getRootRedirect,
+  setRootMode,
+  setRootRedirect,
+} from "../hub-settings.ts";
 import { findService, upsertService } from "../services-manifest.ts";
 
 function makeTempPath(): { path: string; configDir: string; cleanup: () => void } {
@@ -62,6 +71,71 @@ describe("install", () => {
     }
   });
 
+  test("refuses `install agent` without invoking bun or the deprecated binary", async () => {
+    const { path, cleanup } = makeTempPath();
+    try {
+      const calls: string[][] = [];
+      const logs: string[] = [];
+      const code = await install("agent", {
+        runner: async (cmd) => {
+          calls.push([...cmd]);
+          return 0;
+        },
+        manifestPath: path,
+        startService: async () => 0,
+        isLinked: () => false,
+        portProbe: async () => false,
+        log: (line) => logs.push(line),
+      });
+      expect(code).toBe(1);
+      expect(calls).toEqual([]);
+      expect(logs.join("\n")).toMatch(/parachute-agent was retired/);
+      expect(logs.join("\n")).toMatch(/Vault and Surface/);
+    } finally {
+      cleanup();
+    }
+  });
+
+  test("refuses explicit retired Agent npm package names before invoking bun", async () => {
+    for (const packageName of [
+      "@openparachute/agent",
+      "@openparachute/agent@0.9.0",
+      "@openparachute/channel",
+    ]) {
+      const calls: string[][] = [];
+      const logs: string[] = [];
+      const code = await install(packageName, {
+        runner: async (cmd) => {
+          calls.push([...cmd]);
+          return 0;
+        },
+        log: (line) => logs.push(line),
+      });
+      expect(code).toBe(1);
+      expect(calls).toEqual([]);
+      expect(logs.join("\n")).toMatch(/parachute-agent was retired/);
+    }
+  });
+
+  test("refuses a local checkout whose package metadata is a retired Agent package", async () => {
+    const pkgDir = mkdtempSync(join(tmpdir(), "pcli-retired-agent-"));
+    try {
+      const calls: string[][] = [];
+      const code = await install(pkgDir, {
+        runner: async (cmd) => {
+          calls.push([...cmd]);
+          return 0;
+        },
+        readPackageName: () => "@openparachute/agent",
+        log: () => {},
+      });
+      expect(code).toBe(1);
+      expect(calls).toEqual([]);
+    } finally {
+      rmSync(pkgDir, { recursive: true, force: true });
+    }
+  });
+
   test("runs bun add -g then init; seeds manifest when service didn't write one", async () => {
     const { path, cleanup } = makeTempPath();
     try {
@@ -408,7 +482,7 @@ describe("install", () => {
   test("ADOPT-KILLS an attributable same-module orphan on the canonical port + reclaims it (#609)", async () => {
     // Wipe-recovery: `rm -rf ~/.parachute` + re-`init` leaves the supervised
     // vault child running on :1940. The fresh install must reclaim the canonical
-    // port (adopt-kill the attributable orphan) rather than port-walk to 1944.
+    // port (adopt-kill the attributable orphan) rather than port-walk to 1945.
     const { path, configDir, cleanup } = makeTempPath();
     try {
       const logs: string[] = [];
@@ -1636,9 +1710,10 @@ describe("install", () => {
         log: (l) => logs.push(l),
       });
       expect(code).toBe(0);
-      // First reservation slot is 1944.
+      // Agent retirement released 1941, so it is now the first unassigned
+      // canonical slot available to the fallback walker.
       const entry = findService("parachute-vault", path);
-      expect(entry?.port).toBe(1944);
+      expect(entry?.port).toBe(1941);
       expect(logs.join("\n")).toMatch(/canonical port 1940 is in use/);
       // .env is not touched.
       const envPath = join(configDir, "vault", ".env");
@@ -1865,6 +1940,33 @@ describe("install", () => {
     }
   });
 
+  test("refuses third-party metadata that declares a retired Agent manifest identity", async () => {
+    const { path, cleanup } = makeTempPath();
+    try {
+      const logs: string[] = [];
+      const code = await install("@vendor/agent-wrapper", {
+        runner: async () => 0,
+        manifestPath: path,
+        isLinked: () => false,
+        log: (line) => logs.push(line),
+        readManifest: async () => ({
+          name: "claw",
+          manifestName: "@vendor/agent-wrapper",
+          port: 1952,
+          paths: ["/claw"],
+          health: "/claw/health",
+        }),
+        findGlobalInstall: () =>
+          "/fake/bun-globals/node_modules/@vendor/agent-wrapper/package.json",
+      });
+      expect(code).toBe(1);
+      expect(findService("claw", path)).toBeUndefined();
+      expect(logs.join("\n")).toMatch(/parachute-agent was retired/);
+    } finally {
+      cleanup();
+    }
+  });
+
   test("npm-installed third-party module persists installDir from bun globals", async () => {
     // hub#83: for `parachute install <npm-pkg>`, installDir is dirname of
     // the package.json that findGlobalInstall returns. Without this,
@@ -1940,7 +2042,8 @@ describe("install", () => {
       expect(startCalls).toEqual(["someapp"]);
       // Log lines speak in the canonical short name too. Port comes from
       // assignServicePort (third-party gets the first unassigned canonical
-      // slot, currently 1944), not the manifest's port hint.
+      // slot, currently 1945 — 1944 is parachute-app's canonical assigned
+      // slot as of hub-parity P5), not the manifest's port hint.
       const joined = logs.join("\n");
       expect(joined).toMatch(/Seeded services\.json entry for someapp/);
       expect(joined).toMatch(/someapp registered on port \d+/);
@@ -2316,3 +2419,254 @@ describe("hub#573 — install auto-start converges on supervised detection", ()
     expect(opts.log).toBe(log);
   });
 });
+
+// `parachute install app` defaults the hub's origin root to SERVE the app
+// (root_mode = serve-app) on first install — SET-IF-UNSET ONLY, and only when
+// the root behavior is entirely pristine default (no mode row/env AND no
+// redirect row/env). Supersedes the prior hub-parity P5 behavior (which wrote
+// root_redirect = /app/). Every test here injects `rootRedirectDb` (a hub.db
+// opened in the same disposable tempdir `makeTempPath()` already isolates) so no
+// real `~/.parachute/hub.db` is ever touched — never drive this against the
+// operator's live install.
+describe("app-only serve-app set-if-unset default", () => {
+  // The write gates on the RESOLVED mode + redirect being `default` (no DB row,
+  // no env). Neutralize any ambient PARACHUTE_HUB_ROOT_MODE / _REDIRECT (Aaron's
+  // box, CI) so the default-tier tests are deterministic; the env-set tests
+  // below manage their own values inside their own bodies.
+  let savedRedirectEnv: string | undefined;
+  let savedModeEnv: string | undefined;
+  beforeEach(() => {
+    savedRedirectEnv = process.env[PARACHUTE_HUB_ROOT_REDIRECT_ENV];
+    savedModeEnv = process.env[PARACHUTE_HUB_ROOT_MODE_ENV];
+    delete process.env[PARACHUTE_HUB_ROOT_REDIRECT_ENV];
+    delete process.env[PARACHUTE_HUB_ROOT_MODE_ENV];
+  });
+  afterEach(() => {
+    for (const [name, saved] of [
+      [PARACHUTE_HUB_ROOT_REDIRECT_ENV, savedRedirectEnv],
+      [PARACHUTE_HUB_ROOT_MODE_ENV, savedModeEnv],
+    ] as const) {
+      if (saved === undefined) delete process.env[name];
+      else process.env[name] = saved;
+    }
+  });
+
+  test("fresh install (pristine root) flips root_mode to serve-app", async () => {
+    const { path, configDir, cleanup } = makeTempPath();
+    try {
+      const db = openHubDb(hubDbPath(configDir));
+      const logs: string[] = [];
+      try {
+        const code = await install("app", {
+          runner: async () => 0,
+          manifestPath: path,
+          configDir,
+          startService: async () => 0,
+          isLinked: () => false,
+          portProbe: async () => false,
+          rootRedirectDb: db,
+          log: (l) => logs.push(l),
+        });
+        expect(code).toBe(0);
+        expect(getRootMode(db)).toBe("serve-app");
+        // The redirect row is NOT written — serve-app takes over `/` directly.
+        expect(getRootRedirect(db)).toBeNull();
+        expect(logs.join("\n")).toMatch(/front page.*now serves the Parachute app/);
+      } finally {
+        db.close();
+      }
+    } finally {
+      cleanup();
+    }
+  });
+
+  test("a pre-set root_redirect is left alone — mode NOT flipped", async () => {
+    const { path, configDir, cleanup } = makeTempPath();
+    try {
+      const db = openHubDb(hubDbPath(configDir));
+      const logs: string[] = [];
+      try {
+        setRootRedirect(db, "/surface/reading-room");
+        const code = await install("app", {
+          runner: async () => 0,
+          manifestPath: path,
+          configDir,
+          startService: async () => 0,
+          isLinked: () => false,
+          portProbe: async () => false,
+          rootRedirectDb: db,
+          log: (l) => logs.push(l),
+        });
+        expect(code).toBe(0);
+        // The operator's prior choice survives byte-for-byte; no mode flip.
+        expect(getRootRedirect(db)).toBe("/surface/reading-room");
+        expect(getRootMode(db)).toBeNull();
+        expect(logs.join("\n")).not.toMatch(/now serves the Parachute app/);
+      } finally {
+        db.close();
+      }
+    } finally {
+      cleanup();
+    }
+  });
+
+  test("an existing install with the old /app/ redirect keeps redirecting (back-compat)", async () => {
+    // A hub that ran the PRIOR app-install code has root_redirect = /app/ in its
+    // DB (source = db → not default). Re-running `install app` must NOT flip it
+    // to serve-app — it keeps 302-ing to /app/, exactly as before. This is the
+    // "existing installs unchanged" guarantee.
+    const { path, configDir, cleanup } = makeTempPath();
+    try {
+      const db = openHubDb(hubDbPath(configDir));
+      const logs: string[] = [];
+      try {
+        setRootRedirect(db, "/app/");
+        const code = await install("app", {
+          runner: async () => 0,
+          manifestPath: path,
+          configDir,
+          startService: async () => 0,
+          isLinked: () => false,
+          portProbe: async () => false,
+          rootRedirectDb: db,
+          log: (l) => logs.push(l),
+        });
+        expect(code).toBe(0);
+        expect(getRootMode(db)).toBeNull();
+        expect(getRootRedirect(db)).toBe("/app/");
+        expect(logs.join("\n")).not.toMatch(/now serves the Parachute app/);
+      } finally {
+        db.close();
+      }
+    } finally {
+      cleanup();
+    }
+  });
+
+  test("installing a different module never touches the root settings", async () => {
+    const { path, configDir, cleanup } = makeTempPath();
+    try {
+      const db = openHubDb(hubDbPath(configDir));
+      try {
+        const code = await install("notes", {
+          runner: async () => 0,
+          manifestPath: path,
+          configDir,
+          startService: async () => 0,
+          isLinked: () => false,
+          portProbe: async () => false,
+          rootRedirectDb: db,
+          log: () => {},
+        });
+        expect(code).toBe(0);
+        expect(getRootRedirect(db)).toBeNull();
+        expect(getRootMode(db)).toBeNull();
+      } finally {
+        db.close();
+      }
+    } finally {
+      cleanup();
+    }
+  });
+
+  test("an ENV-configured redirect (no DB row) is left alone — no mode flip (N1)", async () => {
+    // Container deploys pin the landing page via PARACHUTE_HUB_ROOT_REDIRECT,
+    // not a DB row. Flipping to serve-app would silently override their
+    // configured landing (serve-app wins over redirect at `/`). The gate reads
+    // the RESOLVED redirect source; with the env set that's `env`, not
+    // `default`, so we leave it alone.
+    const { path, configDir, cleanup } = makeTempPath();
+    const prevEnv = process.env[PARACHUTE_HUB_ROOT_REDIRECT_ENV];
+    try {
+      process.env[PARACHUTE_HUB_ROOT_REDIRECT_ENV] = "/surface/team-room";
+      const db = openHubDb(hubDbPath(configDir));
+      const logs: string[] = [];
+      try {
+        const code = await install("app", {
+          runner: async () => 0,
+          manifestPath: path,
+          configDir,
+          startService: async () => 0,
+          isLinked: () => false,
+          portProbe: async () => false,
+          rootRedirectDb: db,
+          log: (l) => logs.push(l),
+        });
+        expect(code).toBe(0);
+        // No mode row written — the env-configured landing survives.
+        expect(getRootMode(db)).toBeNull();
+        expect(getRootRedirect(db)).toBeNull();
+        expect(logs.join("\n")).not.toMatch(/now serves the Parachute app/);
+      } finally {
+        db.close();
+      }
+    } finally {
+      if (prevEnv === undefined) {
+        delete process.env[PARACHUTE_HUB_ROOT_REDIRECT_ENV];
+      } else {
+        process.env[PARACHUTE_HUB_ROOT_REDIRECT_ENV] = prevEnv;
+      }
+      cleanup();
+    }
+  });
+
+  test("an ENV-configured mode (no DB row) is left alone — no clobber", async () => {
+    // PARACHUTE_HUB_ROOT_MODE=redirect on a container that deliberately wants
+    // the redirect front door. The gate sees the resolved mode source as `env`,
+    // not `default`, so it does NOT write a serve-app row.
+    const { path, configDir, cleanup } = makeTempPath();
+    const prevEnv = process.env[PARACHUTE_HUB_ROOT_MODE_ENV];
+    try {
+      process.env[PARACHUTE_HUB_ROOT_MODE_ENV] = "redirect";
+      const db = openHubDb(hubDbPath(configDir));
+      const logs: string[] = [];
+      try {
+        const code = await install("app", {
+          runner: async () => 0,
+          manifestPath: path,
+          configDir,
+          startService: async () => 0,
+          isLinked: () => false,
+          portProbe: async () => false,
+          rootRedirectDb: db,
+          log: (l) => logs.push(l),
+        });
+        expect(code).toBe(0);
+        expect(getRootMode(db)).toBeNull();
+        expect(logs.join("\n")).not.toMatch(/now serves the Parachute app/);
+      } finally {
+        db.close();
+      }
+    } finally {
+      if (prevEnv === undefined) {
+        delete process.env[PARACHUTE_HUB_ROOT_MODE_ENV];
+      } else {
+        process.env[PARACHUTE_HUB_ROOT_MODE_ENV] = prevEnv;
+      }
+      cleanup();
+    }
+  });
+
+  test("production gate: without rootRedirectDb + a tempdir manifestPath, the write is skipped (not attempted)", async () => {
+    // Mirrors the existing `guidanceProbeAllowed` discriminant elsewhere in
+    // install.ts: a test with a tempdir manifestPath and no explicit opt-in
+    // must never open the real ~/.parachute/hub.db. There's nothing to open
+    // here at all — the assertion is simply that install still completes
+    // cleanly with the DB-touching branch skipped.
+    const { path, configDir, cleanup } = makeTempPath();
+    try {
+      const code = await install("app", {
+        runner: async () => 0,
+        manifestPath: path,
+        configDir,
+        startService: async () => 0,
+        isLinked: () => false,
+        portProbe: async () => false,
+        log: () => {},
+      });
+      expect(code).toBe(0);
+    } finally {
+      cleanup();
+    }
+  });
+});

package/src/__tests__/migrate.test.ts

@@ -56,7 +56,9 @@ describe("safelistEntries", () => {
     expect(s.has("vault")).toBe(true);
     expect(s.has("notes")).toBe(true);
     expect(s.has("scribe")).toBe(true);
-    expect(s.has("agent")).toBe(true);
+    expect(s.has("agent")).toBe(false);
+    expect(KNOWN_ARCHIVABLE_DIRS.has("agent")).toBe(true);
+    expect(KNOWN_ARCHIVABLE_DIRS.has("channel")).toBe(true);
     // Internal
     expect(s.has("hub")).toBe(true);
     // CLI state