@openparachute/hub 0.5.13-rc.13 → 0.5.13-rc.21

package/src/__tests__/install.test.ts

@@ -556,6 +556,246 @@ describe("install", () => {
     }
   });
 
+  // hub#337 — channel resolution (--channel flag + PARACHUTE_INSTALL_CHANNEL env var).
+  // Precedence: --tag > --channel > env > "latest" default.
+
+  test("default channel: bare bun-add (no @latest suffix) when nothing requested (back-compat)", async () => {
+    // Back-compat: pre-hub#337 `parachute install vault` ran `bun add -g
+    // @openparachute/vault` with no suffix. The env-default plumbing keeps
+    // emitting the bare spec when nothing's explicitly chosen — bun
+    // resolves bare names to @latest anyway, so this is a no-op for npm,
+    // but keeps logs byte-identical with the pre-#337 shape.
+    const { path, cleanup } = makeTempPath();
+    try {
+      const calls: string[][] = [];
+      const code = await install("vault", {
+        runner: async (cmd) => {
+          calls.push([...cmd]);
+          return 0;
+        },
+        manifestPath: path,
+        startService: async () => 0,
+        isLinked: () => false,
+        portProbe: async () => false,
+        log: () => {},
+        // No env override → defaults to process.env. We explicitly pass
+        // a stub object so a real-shell `PARACHUTE_INSTALL_CHANNEL=…` can't
+        // leak into the test.
+        envOverride: {},
+      });
+      expect(code).toBe(0);
+      expect(calls[0]).toEqual(["bun", "add", "-g", "@openparachute/vault"]);
+    } finally {
+      cleanup();
+    }
+  });
+
+  test("PARACHUTE_INSTALL_CHANNEL=rc env composes <pkg>@rc for bun add", async () => {
+    // Cluster-wide cascade: when the platform sets the env var, every
+    // `parachute install <svc>` lands on the rc dist-tag without a flag.
+    // The Render-deploy shape — hub container on rc → all modules
+    // installed via /admin/modules also on rc.
+    const { path, cleanup } = makeTempPath();
+    try {
+      const calls: string[][] = [];
+      const logs: string[] = [];
+      const code = await install("vault", {
+        runner: async (cmd) => {
+          calls.push([...cmd]);
+          return 0;
+        },
+        manifestPath: path,
+        startService: async () => 0,
+        isLinked: () => false,
+        portProbe: async () => false,
+        log: (l) => logs.push(l),
+        envOverride: { PARACHUTE_INSTALL_CHANNEL: "rc" },
+      });
+      expect(code).toBe(0);
+      expect(calls[0]).toEqual(["bun", "add", "-g", "@openparachute/vault@rc"]);
+      expect(logs.join("\n")).toMatch(/Installing @openparachute\/vault@rc/);
+    } finally {
+      cleanup();
+    }
+  });
+
+  test("--channel rc flag wins over PARACHUTE_INSTALL_CHANNEL=latest env", async () => {
+    // Per-call flag is the operator's deliberate intent; it beats the
+    // platform default.
+    const { path, cleanup } = makeTempPath();
+    try {
+      const calls: string[][] = [];
+      const code = await install("vault", {
+        runner: async (cmd) => {
+          calls.push([...cmd]);
+          return 0;
+        },
+        manifestPath: path,
+        startService: async () => 0,
+        isLinked: () => false,
+        portProbe: async () => false,
+        log: () => {},
+        channel: "rc",
+        envOverride: { PARACHUTE_INSTALL_CHANNEL: "latest" },
+      });
+      expect(code).toBe(0);
+      expect(calls[0]).toEqual(["bun", "add", "-g", "@openparachute/vault@rc"]);
+    } finally {
+      cleanup();
+    }
+  });
+
+  test("--channel latest flag wins over PARACHUTE_INSTALL_CHANNEL=rc env", async () => {
+    const { path, cleanup } = makeTempPath();
+    try {
+      const calls: string[][] = [];
+      const code = await install("vault", {
+        runner: async (cmd) => {
+          calls.push([...cmd]);
+          return 0;
+        },
+        manifestPath: path,
+        startService: async () => 0,
+        isLinked: () => false,
+        portProbe: async () => false,
+        log: () => {},
+        channel: "latest",
+        envOverride: { PARACHUTE_INSTALL_CHANNEL: "rc" },
+      });
+      expect(code).toBe(0);
+      expect(calls[0]).toEqual(["bun", "add", "-g", "@openparachute/vault@latest"]);
+    } finally {
+      cleanup();
+    }
+  });
+
+  test("--tag wins over both --channel and the env var (programmatic pin)", async () => {
+    // `--tag` is the exact-pin escape hatch (e.g. `--tag 0.3.0-rc.1`),
+    // wins over both operator-facing flag and env default. Mirrors the
+    // upgrade-command shape (hub#338) where tag is the programmatic
+    // override above all channel resolution.
+    const { path, cleanup } = makeTempPath();
+    try {
+      const calls: string[][] = [];
+      const code = await install("vault", {
+        runner: async (cmd) => {
+          calls.push([...cmd]);
+          return 0;
+        },
+        manifestPath: path,
+        startService: async () => 0,
+        isLinked: () => false,
+        portProbe: async () => false,
+        log: () => {},
+        tag: "0.3.0-rc.1",
+        channel: "latest",
+        envOverride: { PARACHUTE_INSTALL_CHANNEL: "rc" },
+      });
+      expect(code).toBe(0);
+      expect(calls[0]).toEqual(["bun", "add", "-g", "@openparachute/vault@0.3.0-rc.1"]);
+    } finally {
+      cleanup();
+    }
+  });
+
+  test("garbage PARACHUTE_INSTALL_CHANNEL value falls back to latest with a warning (no crash)", async () => {
+    // Operator typo (`PARACHUTE_INSTALL_CHANNEL=banana`) shouldn't crash
+    // a Render container at boot. Warn loudly, then fall back to the
+    // safe default so installs keep working.
+    const { path, cleanup } = makeTempPath();
+    try {
+      const calls: string[][] = [];
+      const logs: string[] = [];
+      const code = await install("vault", {
+        runner: async (cmd) => {
+          calls.push([...cmd]);
+          return 0;
+        },
+        manifestPath: path,
+        startService: async () => 0,
+        isLinked: () => false,
+        portProbe: async () => false,
+        log: (l) => logs.push(l),
+        envOverride: { PARACHUTE_INSTALL_CHANNEL: "banana" },
+      });
+      expect(code).toBe(0);
+      // Falls back to "@latest" — explicit because the env var WAS set (just
+      // to a bad value), so we make the resolution visible in the spec.
+      expect(calls[0]).toEqual(["bun", "add", "-g", "@openparachute/vault@latest"]);
+      const joined = logs.join("\n");
+      expect(joined).toMatch(/PARACHUTE_INSTALL_CHANNEL="banana" is not a valid channel/);
+      expect(joined).toMatch(/Falling back to "latest"/);
+    } finally {
+      cleanup();
+    }
+  });
+
+  test("--channel is moot when the package is already bun-linked (link short-circuit wins)", async () => {
+    // Same shape as the --tag short-circuit test: local-link beats remote
+    // dist-tag resolution. No `bun add` invocation at all.
+    const { path, cleanup } = makeTempPath();
+    try {
+      const calls: string[][] = [];
+      const logs: string[] = [];
+      const code = await install("scribe", {
+        runner: async (cmd) => {
+          calls.push([...cmd]);
+          return 0;
+        },
+        manifestPath: path,
+        startService: async () => 0,
+        isLinked: () => true,
+        portProbe: async () => false,
+        log: (l) => logs.push(l),
+        channel: "rc",
+        envOverride: { PARACHUTE_INSTALL_CHANNEL: "rc" },
+      });
+      expect(code).toBe(0);
+      expect(calls).toHaveLength(0);
+      expect(logs.join("\n")).toMatch(/already linked globally/);
+    } finally {
+      cleanup();
+    }
+  });
+
+  test("local-path install ignores --channel + env (filesystem source, not npm)", async () => {
+    // The local-path branch installs from the operator's checkout via
+    // `bun add -g <abspath>`; there's no npm dist-tag to resolve. Channel
+    // resolution is bypassed entirely.
+    const { path, cleanup } = makeTempPath();
+    const pkgDir = mkdtempSync(join(tmpdir(), "pcli-localpkg-"));
+    try {
+      const calls: string[][] = [];
+      const code = await install(pkgDir, {
+        runner: async (cmd) => {
+          calls.push([...cmd]);
+          return 0;
+        },
+        manifestPath: path,
+        startService: async () => 0,
+        isLinked: () => false,
+        portProbe: async () => false,
+        log: () => {},
+        readManifest: async () => ({
+          name: "demo",
+          manifestName: "@local/demo",
+          port: 1951,
+          paths: ["/demo"],
+          health: "/healthz",
+        }),
+        readPackageName: () => "@local/demo",
+        channel: "rc",
+        envOverride: { PARACHUTE_INSTALL_CHANNEL: "rc" },
+      });
+      expect(code).toBe(0);
+      // No `@rc` suffix — the absolute path passes through verbatim.
+      expect(calls[0]).toEqual(["bun", "add", "-g", pkgDir]);
+    } finally {
+      cleanup();
+      rmSync(pkgDir, { recursive: true, force: true });
+    }
+  });
+
   test("linked vault still runs init and defers to init's manifest write", async () => {
     const { path, cleanup } = makeTempPath();
     try {
@@ -1180,7 +1420,6 @@ describe("install", () => {
         readManifest: async () => ({
           name: "widget",
           manifestName: "@acme/widget",
-          kind: "api",
           port: 1950,
           paths: ["/widget"],
           health: "/healthz",
@@ -1238,7 +1477,6 @@ describe("install", () => {
         readManifest: async () => ({
           name: "vault",
           manifestName: "@evil/squatter",
-          kind: "api",
           port: 1950,
           paths: ["/vault"],
           health: "/healthz",
@@ -1271,7 +1509,6 @@ describe("install", () => {
         readManifest: async () => ({
           name: "demo",
           manifestName: "@local/demo",
-          kind: "api",
           port: 1951,
           paths: ["/demo"],
           health: "/healthz",
@@ -1323,7 +1560,6 @@ describe("install", () => {
         readManifest: async () => ({
           name: "demo",
           manifestName: "@local/demo",
-          kind: "api",
           port: 1951,
           paths: ["/demo"],
           health: "/healthz",
@@ -1367,7 +1603,6 @@ describe("install", () => {
         readManifest: async () => ({
           name: "demo",
           manifestName: "@local/demo",
-          kind: "api",
           port: 1951,
           paths: ["/demo"],
           health: "/healthz",
@@ -1400,7 +1635,6 @@ describe("install", () => {
         readManifest: async () => ({
           name: "widget",
           manifestName: "@vendor/widget",
-          kind: "api",
           port: 1952,
           paths: ["/widget"],
           health: "/widget/health",
@@ -1418,16 +1652,18 @@ describe("install", () => {
   });
 
   test("third-party with diverging name/manifestName keys services.json by name (hub#85)", async () => {
-    // Repro for parachute-hub#85: parachute-agent ships `name: "agent",
-    // manifestName: "parachute-agent"`. Install used to seed services.json
-    // under `parachute-agent` (the npm label) while lifecycle looks up by
-    // `agent` (the canonical short) → "unknown service". Fix: services.json
-    // key is always `manifest.name` for third-party.
+    // Repro for parachute-hub#85: a module ships `name: "someapp",
+    // manifestName: "parachute-someapp"`. Install used to seed services.json
+    // under `parachute-someapp` (the npm label) while lifecycle looks up by
+    // `someapp` (the canonical short) → "unknown service". Fix: services.json
+    // key is always `manifest.name` for third-party. Original repro was
+    // against parachute-agent before it was retired (2026-05-20); the same
+    // shape applies to any third-party module with diverging name/manifestName.
     const { path, configDir, cleanup } = makeTempPath();
     try {
       const startCalls: string[] = [];
       const logs: string[] = [];
-      const code = await install("parachute-agent", {
+      const code = await install("parachute-someapp", {
         runner: async () => 0,
         manifestPath: path,
         configDir,
@@ -1439,29 +1675,28 @@ describe("install", () => {
         portProbe: async () => false,
         log: (l) => logs.push(l),
         readManifest: async () => ({
-          name: "agent",
-          manifestName: "parachute-agent",
-          kind: "api",
+          name: "someapp",
+          manifestName: "parachute-someapp",
           port: 1945,
-          paths: ["/agent"],
-          health: "/agent/health",
+          paths: ["/someapp"],
+          health: "/someapp/health",
           startCmd: ["bun", "server.ts"],
         }),
-        findGlobalInstall: () => "/fake/prefix/parachute-agent/package.json",
+        findGlobalInstall: () => "/fake/prefix/parachute-someapp/package.json",
       });
       expect(code).toBe(0);
       // services.json is keyed by `name`, not `manifestName`.
-      expect(findService("agent", path)?.name).toBe("agent");
-      expect(findService("parachute-agent", path)).toBeUndefined();
+      expect(findService("someapp", path)?.name).toBe("someapp");
+      expect(findService("parachute-someapp", path)).toBeUndefined();
       // Auto-start receives the canonical short name (= manifest.name).
-      expect(startCalls).toEqual(["agent"]);
+      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.
       const joined = logs.join("\n");
-      expect(joined).toMatch(/Seeded services\.json entry for agent/);
-      expect(joined).toMatch(/agent registered on port \d+/);
-      expect(joined).not.toMatch(/Seeded services\.json entry for parachute-agent/);
+      expect(joined).toMatch(/Seeded services\.json entry for someapp/);
+      expect(joined).toMatch(/someapp registered on port \d+/);
+      expect(joined).not.toMatch(/Seeded services\.json entry for parachute-someapp/);
     } finally {
       cleanup();
     }

package/src/__tests__/lifecycle.test.ts

@@ -80,7 +80,6 @@ function seedThirdParty(
   const manifest = {
     name,
     manifestName: opts.manifestName ?? name,
-    kind: "api" as const,
     port: opts.port ?? 1944,
     paths: [`/${name}`],
     health: `/${name}/health`,
@@ -498,14 +497,14 @@ describe("parachute start", () => {
     // gets cwd=installDir so manifest-declared relative paths work.
     const h = makeHarness();
     try {
-      const installDir = join(h.configDir, "_pkg-agent");
-      seedThirdParty(h.manifestPath, h.configDir, "agent", {
+      const installDir = join(h.configDir, "_pkg-someapp");
+      seedThirdParty(h.manifestPath, h.configDir, "someapp", {
         installDir,
         startCmd: ["bun", "web/server/src/server.ts"],
         port: 1944,
       });
       const spawner = makeSpawner([8080]);
-      const code = await start("agent", {
+      const code = await start("someapp", {
         configDir: h.configDir,
         manifestPath: h.manifestPath,
         spawner,
@@ -515,7 +514,7 @@ describe("parachute start", () => {
       expect(spawner.calls).toHaveLength(1);
       expect(spawner.calls[0]?.cmd).toEqual(["bun", "web/server/src/server.ts"]);
       expect(spawner.calls[0]?.cwd).toBe(installDir);
-      expect(readPid("agent", h.configDir)).toBe(8080);
+      expect(readPid("someapp", h.configDir)).toBe(8080);
     } finally {
       h.cleanup();
     }
@@ -580,8 +579,8 @@ describe("parachute start", () => {
     const h = makeHarness();
     try {
       seedVault(h.manifestPath);
-      const installDir = join(h.configDir, "_pkg-agent");
-      seedThirdParty(h.manifestPath, h.configDir, "agent", {
+      const installDir = join(h.configDir, "_pkg-someapp");
+      seedThirdParty(h.manifestPath, h.configDir, "someapp", {
         installDir,
         startCmd: ["bun", "server.ts"],
         port: 1944,
@@ -964,21 +963,21 @@ describe("parachute logs", () => {
   test("third-party module name with installDir is recognised", async () => {
     const h = makeHarness();
     try {
-      const installDir = join(h.configDir, "_pkg-agent");
-      seedThirdParty(h.manifestPath, h.configDir, "agent", {
+      const installDir = join(h.configDir, "_pkg-someapp");
+      seedThirdParty(h.manifestPath, h.configDir, "someapp", {
         installDir,
         startCmd: ["bun", "server.ts"],
       });
-      const p = ensureLogPath("agent", h.configDir);
-      writeFileSync(p, "agent line 1\nagent line 2\n");
+      const p = ensureLogPath("someapp", h.configDir);
+      writeFileSync(p, "someapp line 1\nsomeapp line 2\n");
       const lines: string[] = [];
-      const code = await logs("agent", {
+      const code = await logs("someapp", {
         configDir: h.configDir,
         manifestPath: h.manifestPath,
         log: (l) => lines.push(l),
       });
       expect(code).toBe(0);
-      expect(lines).toEqual(["agent line 1", "agent line 2"]);
+      expect(lines).toEqual(["someapp line 1", "someapp line 2"]);
     } finally {
       h.cleanup();
     }
@@ -1014,6 +1013,84 @@ describe("parachute logs", () => {
       h.cleanup();
     }
   });
+
+  test("running daemon + missing log file: surfaces alive-but-no-log shape (hub#335)", async () => {
+    // Aaron's #335 reproducer shape: parachute-app daemon was running
+    // (curl proxied 200s, pidfile alive) but `parachute logs app` printed
+    // `parachute start app to begin` — telling the operator to start a
+    // service that was already up. The fix: when the log file is missing
+    // but a live pidfile exists, surface the running pid + the path we
+    // expected instead of the misleading start-hint.
+    const h = makeHarness();
+    try {
+      seedVault(h.manifestPath);
+      writePid("vault", 9999, h.configDir);
+      const lines: string[] = [];
+      const code = await logs("vault", {
+        configDir: h.configDir,
+        manifestPath: h.manifestPath,
+        // pid 9999 is "alive" — simulates the running daemon case.
+        alive: () => true,
+        log: (l) => lines.push(l),
+      });
+      expect(code).toBe(0);
+      const out = lines.join("\n");
+      expect(out).toMatch(/vault is running \(pid 9999\)/);
+      expect(out).toMatch(/no log file/);
+      expect(out).not.toMatch(/parachute start vault/);
+    } finally {
+      h.cleanup();
+    }
+  });
+
+  test("stale pidfile + missing log file: falls through to start hint", async () => {
+    // The other half of the disambiguation: pidfile exists but the process
+    // is gone (stale pidfile, or cleanly shut down). That's effectively
+    // "not running," so the original `parachute start` hint is still the
+    // right message.
+    const h = makeHarness();
+    try {
+      seedVault(h.manifestPath);
+      writePid("vault", 9999, h.configDir);
+      const lines: string[] = [];
+      const code = await logs("vault", {
+        configDir: h.configDir,
+        manifestPath: h.manifestPath,
+        // pid 9999 is "dead" — `processState` returns `stopped`.
+        alive: () => false,
+        log: (l) => lines.push(l),
+      });
+      expect(code).toBe(0);
+      expect(lines.join("\n")).toMatch(/no logs yet for vault/);
+    } finally {
+      h.cleanup();
+    }
+  });
+
+  test("log file exists: prints tail regardless of pidfile state (hub#335)", async () => {
+    // The happy path Aaron's title calls out: when the log file exists,
+    // we tail it — independent of whether the pidfile is present. A
+    // running daemon's logs are useful; a stopped daemon's prior logs are
+    // useful too (post-mortem). Pidfile state only changes the message
+    // when the file is missing.
+    const h = makeHarness();
+    try {
+      const p = ensureLogPath("vault", h.configDir);
+      writeFileSync(p, "vault line a\nvault line b\n");
+      // No pidfile written — verify we still print the tail.
+      const lines: string[] = [];
+      const code = await logs("vault", {
+        configDir: h.configDir,
+        manifestPath: h.manifestPath,
+        alive: () => false,
+        log: (l) => lines.push(l),
+      });
+      expect(code).toBe(0);
+      expect(lines).toEqual(["vault line a", "vault line b"]);
+    } finally {
+      h.cleanup();
+    }
+  });
 });
 
 describe("process-group lifecycle (hub#88)", () => {

package/src/__tests__/module-manifest.test.ts

@@ -12,7 +12,6 @@ import {
 const VALID = {
   name: "demo",
   manifestName: "@example/demo",
-  kind: "api",
   port: 1950,
   paths: ["/demo"],
   health: "/healthz",
@@ -22,7 +21,6 @@ describe("validateModuleManifest", () => {
   test("accepts a minimal valid manifest", () => {
     const m = validateModuleManifest(VALID, "test");
     expect(m.name).toBe("demo");
-    expect(m.kind).toBe("api");
     expect(m.port).toBe(1950);
     expect(m.paths).toEqual(["/demo"]);
     expect(m.health).toBe("/healthz");
@@ -35,7 +33,6 @@ describe("validateModuleManifest", () => {
 
   test("rejects missing required fields", () => {
     expect(() => validateModuleManifest({ ...VALID, name: undefined }, "x")).toThrow(/name/);
-    expect(() => validateModuleManifest({ ...VALID, kind: "weird" }, "x")).toThrow(/kind/);
     expect(() => validateModuleManifest({ ...VALID, port: -1 }, "x")).toThrow(/port/);
     expect(() => validateModuleManifest({ ...VALID, port: 99999 }, "x")).toThrow(/port/);
     expect(() => validateModuleManifest({ ...VALID, paths: "not-array" }, "x")).toThrow(/paths/);
@@ -44,6 +41,25 @@ describe("validateModuleManifest", () => {
     );
   });
 
+  // hub#301 Phase C/D (#330): the `kind` field is fully retired. Hub doesn't
+  // read it anymore; module.json values are silently ignored. Validation just
+  // doesn't inspect the field — present, absent, valid string, typo, wrong
+  // type — none of it errors and none of it surfaces on the parsed manifest.
+  test("kind values in module.json are silently ignored (hub#330)", () => {
+    // No matter what the author wrote, the validator passes through without
+    // throwing and the parsed manifest exposes no `kind` field.
+    expect(() => validateModuleManifest({ ...VALID, kind: "frontend" }, "x")).not.toThrow();
+    expect(() => validateModuleManifest({ ...VALID, kind: "api" }, "x")).not.toThrow();
+    expect(() => validateModuleManifest({ ...VALID, kind: "tool" }, "x")).not.toThrow();
+    expect(() => validateModuleManifest({ ...VALID, kind: "static" }, "x")).not.toThrow();
+    expect(() => validateModuleManifest({ ...VALID, kind: 42 }, "x")).not.toThrow();
+    expect(() => validateModuleManifest({ ...VALID, kind: null }, "x")).not.toThrow();
+    // The parsed manifest type has no `kind` field at all — confirm the
+    // validator doesn't smuggle it through as a hidden property.
+    const m = validateModuleManifest({ ...VALID, kind: "frontend" }, "x");
+    expect((m as { kind?: unknown }).kind).toBeUndefined();
+  });
+
   test("rejects invalid name shape", () => {
     expect(() => validateModuleManifest({ ...VALID, name: "Demo" }, "x")).toThrow(/name/);
     expect(() => validateModuleManifest({ ...VALID, name: "1demo" }, "x")).toThrow(/name/);

package/src/__tests__/post-install.test.ts

@@ -176,7 +176,6 @@ describe("refreshWellKnown", () => {
             ? {
                 name: "notes",
                 manifestName: "parachute-notes",
-                kind: "frontend",
                 port: 5173,
                 paths: ["/notes"],
                 health: "/notes/health",
@@ -260,7 +259,6 @@ describe("finalizeModuleInstall", () => {
       const manifest = {
         name: "vault",
         manifestName: "parachute-vault",
-        kind: "api" as const,
         port: 1940,
         paths: ["/vault/default"],
         health: "/vault/default/health",

package/src/__tests__/scope-registry.test.ts

@@ -140,7 +140,7 @@ describe("loadDeclaredScopes", () => {
   test("readModuleScopes receives installDir from services.json (closes #85 follow-up)", () => {
     // Regression: scope-registry was looking up by services.json `name` in
     // bun-globals. For third-party modules where name (canonical short like
-    // "agent") differs from the npm package name on disk ("nanoagent" for
+    // "someapp") differs from the npm package name on disk ("nanoapp" for
     // forks), that lookup fails and the module's scopes are never declared.
     // installDir from hub#84 is the correct path source.
     const { manifestPath, cleanup } = tmp();
@@ -150,12 +150,12 @@ describe("loadDeclaredScopes", () => {
         JSON.stringify({
           services: [
             {
-              name: "agent",
+              name: "someapp",
               port: 1944,
-              paths: ["/agent"],
+              paths: ["/someapp"],
               health: "/api/health",
               version: "0.0.0-linked",
-              installDir: "/Users/test/ParachuteComputer/parachute-agent",
+              installDir: "/Users/test/ParachuteComputer/parachute-someapp",
             },
           ],
         }),
@@ -165,15 +165,15 @@ describe("loadDeclaredScopes", () => {
         manifestPath,
         readModuleScopes: (pkg, installDir) => {
           calls.push({ pkg, installDir });
-          return pkg === "agent" ? ["agent:read", "agent:write", "agent:admin"] : null;
+          return pkg === "someapp" ? ["someapp:read", "someapp:write", "someapp:admin"] : null;
         },
       });
       expect(calls).toEqual([
-        { pkg: "agent", installDir: "/Users/test/ParachuteComputer/parachute-agent" },
+        { pkg: "someapp", installDir: "/Users/test/ParachuteComputer/parachute-someapp" },
       ]);
-      expect(declared.has("agent:read")).toBe(true);
-      expect(declared.has("agent:write")).toBe(true);
-      expect(declared.has("agent:admin")).toBe(true);
+      expect(declared.has("someapp:read")).toBe(true);
+      expect(declared.has("someapp:write")).toBe(true);
+      expect(declared.has("someapp:admin")).toBe(true);
     } finally {
       cleanup();
     }