privateer-agent 0.12.8 → 0.12.10

package/src/cli/chat.ts

@@ -44,8 +44,10 @@ async function main() {
   const {
     accountPosture,
     rememberAccountCredential,
+    persistAccountCredential,
     dropPersistedAccountCredential,
   } = await import("../providers/account.ts");
+  const { modelRegistryOf } = await import("../providers/piAuthStore.ts");
   const { agentVersion } = await import("../config/version.ts");
   const { pickerCatalog, hiddenAccountNotice, hiddenAccountTitleSuffix } = await import("../providers/modelCatalog.ts");
   const { resolveDefaultModel, resolveSignedInModel, savedPiDefaultSpec } = await import("../providers/defaultModel.ts");
@@ -448,7 +450,7 @@ async function main() {
     try { await priv.revokeLocalSessions(); } catch { /* best effort — server TTL is the fallback */ }
     // Ownership-checked: auth.json is machine-global, so removing an entry another
     // running terminal minted would strand it (see providers/account.ts).
-    try { dropPersistedAccountCredential({ modelRegistry: { authStorage: services.authStorage } }); } catch { /* nothing persisted */ }
+    try { await dropPersistedAccountCredential(); } catch { /* nothing persisted */ }
   }
   const onSignal = (): void => { void cleanup().finally(() => process.exit(0)); };
   process.once("SIGINT", onSignal);
@@ -459,14 +461,14 @@ async function main() {
   if (provider === "privateer") {
     try {
       const creds = await priv.acquireAccountCredential();
-      (services.authStorage as any).set("privateer", { type: "oauth", ...creds });
+      await persistAccountCredential(creds);
       rememberAccountCredential(creds); // claim it, so cleanup drops OUR entry and only ours
     } catch (e) {
       console.log(`${RED}Account channel unavailable: ${(e as Error).message}${RESET}`);
     }
   }
 
-  const model = (services.modelRegistry as any).find(provider, modelId);
+  const model = (modelRegistryOf(services) as any).find(provider, modelId);
   if (!model) {
     console.log(`${RED}Model ${provider}/${modelId} not found.${RESET} Set PRIVATEER_MODEL=provider/id and check the key is in .env.`);
     rl.close();
@@ -633,7 +635,7 @@ async function main() {
   // is filtered out until the credential is armed).
   const SIGN_IN_HINT = "Run /login.";
   async function modelCatalog() {
-    return pickerCatalog(services.modelRegistry as any);
+    return pickerCatalog(modelRegistryOf(services) as any);
   }
 
   // Switch the live session's model in place (history preserved — see
@@ -644,7 +646,7 @@ async function main() {
     const at = sp.indexOf("/");
     if (at < 0) { const m = "Usage: /model provider/id"; console.log(`${RED}${m}${RESET}`); if (remote) relay?.sendNotice(m); return; }
     const p = sp.slice(0, at), id = sp.slice(at + 1);
-    const model = (session.modelRegistry as any).find?.(p, id) ?? (services.modelRegistry as any).find?.(p, id);
+    const model = (session.modelRegistry as any).find?.(p, id) ?? (modelRegistryOf(services) as any).find?.(p, id);
     if (!model) { const m = `Model ${sp} not found — try /models.`; console.log(`${RED}${m}${RESET}`); if (remote) relay?.sendNotice(m); return; }
     try {
       await session.setModel(model);

package/src/harbor/index.ts

@@ -17,8 +17,11 @@ import { type GateController } from "../ext/permissionGate.ts";
 import { moatResourceOptions } from "../config/moat.ts";
 import {
   rememberAccountCredential,
+  persistAccountCredential,
   dropPersistedAccountCredential,
 } from "../providers/account.ts";
+// Pi-free static graph by design — see the header of piAuthStore.ts.
+import { modelRegistryOf } from "../providers/piAuthStore.ts";
 import { resolveDefaultModel } from "../providers/defaultModel.ts";
 import { RelayClient, type TaskSpec } from "../remote/relayClient.ts";
 import { createLiveTaskSession, type LiveTaskHandle } from "../remote/liveTaskSession.ts";
@@ -849,7 +852,7 @@ export class Harbor {
       rmSync(join(agentDir(), "mcp-cache.json"), { force: true });
       const services = await this.buildSessionServices(cwd, []);
       const { provider, modelId } = parseSpec(modelSpec);
-      const model = (services.modelRegistry as any).find(provider, modelId);
+      const model = (modelRegistryOf(services) as any).find(provider, modelId);
       if (!model) return;
       const { session } = await createAgentSessionFromServices({
         services,
@@ -882,18 +885,16 @@ export class Harbor {
     let out = "";
     let status: "ok" | "error" = "ok";
     let error: string | undefined;
-    let servicesRef: { authStorage?: { remove?: (p: string) => void; get?: (p: string) => unknown } } | null = null;
     let spawnedAccount = false;
     const { tools: allowedTools, directToolsEnv, notes } = await this.resolveRunTools(spec.tools, spec.cwd, spec.model);
     try {
       const services = await this.buildSessionServices(spec.cwd, directToolsEnv);
-      servicesRef = services as any;
 
       const { provider, modelId } = parseSpec(spec.model);
       if (provider === "privateer") {
         try {
           const creds = await acquireAccountCredential();
-          (services.authStorage as any).set("privateer", { type: "oauth", ...creds });
+          await persistAccountCredential(creds);
           rememberAccountCredential(creds); // claim it, so the teardown drops OUR entry only
           spawnedAccount = true;
         } catch (e) {
@@ -901,7 +902,7 @@ export class Harbor {
         }
       }
 
-      const model = (services.modelRegistry as any).find(provider, modelId);
+      const model = (modelRegistryOf(services) as any).find(provider, modelId);
       if (!model) {
         status = "error";
         error = `model ${provider}/${modelId} not found`;
@@ -935,7 +936,7 @@ export class Harbor {
         try { await revokeAccountSession(); } catch { /* best effort — server TTL is the fallback */ }
         // Ownership-checked: an interactive terminal on this machine shares auth.json,
         // and its entry must survive a harbor run's teardown (see providers/account.ts).
-        try { dropPersistedAccountCredential({ modelRegistry: { authStorage: servicesRef?.authStorage } }); } catch { /* nothing persisted */ }
+        try { await dropPersistedAccountCredential(); } catch { /* nothing persisted */ }
       }
     }
     return { out, status, error, notes };

package/src/providers/account.ts

@@ -28,6 +28,7 @@ import { globalDir } from "../config/paths.ts";
 import { canOpenBrowser, openInBrowser } from "../util/openBrowser.ts";
 import { interpretReport, teePosture, tierFromTeePosture, type PrivacyTier } from "pi-privacy";
 import { ACCOUNT_DEFAULT_MODEL_ID, ACCOUNT_NEAR_MODEL_ID, ensurePiDefaultModel } from "./defaultModel.ts";
+import { piAuthStore } from "./piAuthStore.ts";
 import {
   sealedEnabled,
   sealedProviderFor,
@@ -780,16 +781,11 @@ async function accountCredential(): Promise<AccountCredential> {
   return slot.inFlight;
 }
 
-// `ctx` is Pi's ExtensionContext; the auth store hangs off its model registry (the same
-// path privateer-brand uses to DROP the credential on sign-out).
+// `ctx` is Pi's ExtensionContext. It used to carry the auth store too
+// (ctx.modelRegistry.authStorage) — pi 0.84 removed it, and the surviving
+// ModelRegistry facade has no credential surface at all, so the store is resolved
+// from piAuthStore() instead and `ctx` is now only ever consulted for UI.
 type SeedContext = {
-  modelRegistry?: {
-    authStorage?: {
-      set?: (provider: string, cred: unknown) => void;
-      get?: (provider: string) => unknown;
-      remove?: (provider: string) => void;
-    };
-  };
   model?: { provider?: string; id?: string };
   hasUI?: boolean;
   ui?: { notify?: (message: string, level: string) => void };
@@ -809,10 +805,12 @@ export async function armAccountCredential(
   opts: { notify?: boolean } = {},
 ): Promise<boolean> {
   if (!hasCredentials()) return false;
-  const store = (ctx as SeedContext)?.modelRegistry?.authStorage;
-  if (typeof store?.set !== "function") return false;
   try {
-    store.set("privateer", { type: "oauth", ...(await accountCredential()) });
+    // `modify` is the store's only write path: it hands us the current entry and
+    // takes the replacement back. We ignore the current one — a freshly minted
+    // child credential always supersedes whatever is on disk.
+    const cred = await accountCredential();
+    await (await piAuthStore()).modify("privateer", async () => ({ type: "oauth", ...cred }));
     return true;
   } catch (e) {
     // The account channel is NOT armed: a dead machine login (401 → credentials cleared
@@ -831,6 +829,17 @@ export async function armAccountCredential(
   }
 }
 
+// Write an already-acquired account credential into Pi's auth store.
+//
+// The entrypoints that mint their own child credential (chat, acp, harbor, the live
+// task session) used to poke `services.authStorage.set(...)` directly. pi 0.84 removed
+// that property and made the store's only write path an async `modify`, so the poke
+// lives here now — one place that knows the shape, next to the ownership rules that
+// govern the same entry.
+export async function persistAccountCredential(creds: AccountCredential): Promise<void> {
+  await (await piAuthStore()).modify("privateer", async () => ({ type: "oauth", ...creds }));
+}
+
 // Drop Pi's PERSISTED account credential (the `privateer` entry in auth.json) — but
 // ONLY when it's the one this process minted. Every exit path pairs a session revoke
 // with this drop (the contract in auth/privateer.ts): Pi reuses the persisted
@@ -849,31 +858,32 @@ export async function armAccountCredential(
 // machine's whole token family — every terminal's session included. Those callers have
 // also already wiped the local credentials, so the ownership memo is gone by then and an
 // ownership-checked drop would refuse and strand a dead entry on disk.
-export function dropPersistedAccountCredential(ctx: unknown, opts: { force?: boolean } = {}): boolean {
-  const store = (ctx as SeedContext)?.modelRegistry?.authStorage;
+export async function dropPersistedAccountCredential(
+  opts: { force?: boolean } = {},
+): Promise<boolean> {
+  const store = await piAuthStore();
   const mine = ownedAccountCredential()?.access;
   // Every caller revokes this process's session immediately before calling us, so drop
   // the memo whatever happens to the entry on disk — otherwise a later arm() in this
   // process (a harbor run's session_start, say) could re-persist the revoked token.
   armSlot().cred = undefined;
-  if (typeof store?.remove !== "function") return false;
   try {
-    if (opts.force) {
-      /* whole family revoked — the entry is dead for every terminal, drop it */
-    } else if (typeof store.get === "function") {
-      const persisted = store.get("privateer") as { access?: unknown } | undefined;
+    if (!opts.force) {
+      // Not force: read the entry back and only drop it if it is ours. This read is
+      // the whole safety property — it is what sees the entry a CONCURRENT terminal
+      // wrote, and auth.json is re-read from disk when its revision changes, so this
+      // observes other processes rather than a stale in-process copy.
+      const persisted = (await store.read("privateer")) as { access?: unknown } | undefined;
       if (!persisted) return false; // nothing persisted — nothing to drop
       // Some other terminal's session. Leave it: it's the key that terminal is using.
       if (typeof persisted.access === "string" && persisted.access !== mine) return false;
-    } else if (!mine) {
-      // Older Pi with no readable auth store AND we never minted anything — we have no
-      // basis to claim the entry, so leave it alone rather than break another terminal.
-      return false;
     }
-    store.remove("privateer");
+    // force: the whole token family is revoked, so the entry is dead for every
+    // terminal and ownership is irrelevant.
+    await store.delete("privateer");
     return true;
   } catch {
-    return false; // older Pi shape / unwritable store — the server TTL is the fallback
+    return false; // unwritable store — the server TTL is the fallback
   }
 }
 
@@ -889,12 +899,10 @@ export function dropPersistedAccountCredential(ctx: unknown, opts: { force?: boo
 // refresh path (refreshToken), and pre-empting it would mint a second session row.
 export async function ensureAccountArmed(ctx: unknown): Promise<void> {
   if (!hasCredentials()) return;
-  const store = (ctx as SeedContext)?.modelRegistry?.authStorage;
-  if (typeof store?.get !== "function") return; // can't tell — leave it to session_start
   try {
-    if (store.get("privateer")) return;
+    if (await (await piAuthStore()).read("privateer")) return;
   } catch {
-    return;
+    return; // can't tell — leave it to the next session_start
   }
   await armAccountCredential(ctx, { notify: false });
 }

package/src/providers/piAuthStore.ts

@@ -0,0 +1,129 @@
+// Access to Pi's credential store and model registry after the 0.84 refactor.
+//
+// pi-coding-agent 0.84 folded credential storage and the model registry into a single
+// `ModelRuntime` and removed both from `AgentSessionServices`. Two things that used to
+// hang off `services` no longer do:
+//
+//   services.authStorage   -> gone; the runtime owns a private CredentialStore
+//   services.modelRegistry -> gone; superseded by services.modelRuntime
+//
+// This module is the single place that knows about that change, so the account channel
+// and the entrypoints don't each grow their own workaround.
+//
+// ⚠️ NOTHING HERE MAY STATICALLY IMPORT PI. This module is pulled in by
+// providers/account.ts, which is itself statically imported by extensions and by the
+// harbor — and whose static graph is deliberately Pi-free, because Pi must not load
+// before boot.ts has installed the env and the dispatcher (the same contract session.ts
+// documents). So the one place a Pi class is genuinely needed loads it dynamically, and
+// everything else is duck-typed off objects Pi already handed us.
+
+import { join } from "node:path";
+
+import { agentDir as defaultAgentDir } from "../config/paths.ts";
+
+/** The agent dir Pi is actually using — boot pins PI_CODING_AGENT_DIR to ours. */
+function resolveAgentDir(agentDir?: string): string {
+  return agentDir ?? process.env.PI_CODING_AGENT_DIR ?? defaultAgentDir();
+}
+
+/** The subset of Pi's CredentialStore the account channel uses. All async in 0.84. */
+export type PiCredentialStore = {
+  read(providerId: string): Promise<unknown>;
+  modify(providerId: string, fn: (current: unknown) => Promise<unknown>): Promise<unknown>;
+  delete(providerId: string): Promise<void>;
+};
+
+let cached: { path: string; store: Promise<PiCredentialStore> } | undefined;
+let override: Promise<PiCredentialStore> | undefined;
+
+/**
+ * Pi's credential store for auth.json — the same file, format and class the ModelRuntime
+ * uses. `AuthStorage` IS that class: model-runtime.js defaults to
+ * `DefaultAuthStorage.create(authPath)`, where DefaultAuthStorage is this exact export,
+ * and it already implements the public CredentialStore interface. 0.84 merely stopped
+ * re-exporting it, so our pi patch puts the export back — which keeps us on Pi's own
+ * store and file format instead of reimplementing either.
+ *
+ * Why ModelRuntime isn't enough: it exposes login/logout/listCredentials but no way to
+ * WRITE an OAuth credential, and pi-ai exports only InMemoryCredentialStore. The account
+ * channel must write one, because Pi persists an OAuth credential only for a login IT
+ * drove — never for our device-code flow.
+ *
+ * Holding a second instance over the same path is safe and is not a shortcut: auth.json
+ * is machine-global and shared by every terminal on the box, so the store is already
+ * built for concurrent access (per-path shared read state, a file-revision check on
+ * read, serialized `modify` writes). A second instance in this process is just one more
+ * reader/writer, exactly like another terminal — which is the case the ownership check
+ * in account.ts exists to handle.
+ */
+export function piAuthStore(agentDir?: string): Promise<PiCredentialStore> {
+  if (override) return override;
+  const path = join(resolveAgentDir(agentDir), "auth.json");
+  if (cached?.path !== path) {
+    cached = {
+      path,
+      store: import("@earendil-works/pi-coding-agent").then((pi) => {
+        // `AuthStorage` reaches the index through OUR pi patch (0.84 stopped exporting
+        // it), and patches are best-effort — `bin/apply-patches.mjs` degrades to stock
+        // pi when it cannot write to node_modules, the `sudo npm i -g` case. This is
+        // the one place left that genuinely needs the patched export: only pi's own
+        // class knows auth.json's locking, revision checks and file format, and pi's
+        // package exports map blocks the deep path it still lives at. So say what
+        // happened. Unpatched, the alternative is `undefined.create is not a function`
+        // at whatever moment the account channel first writes a credential.
+        const ctor = (pi as { AuthStorage?: { create(p: string): PiCredentialStore } }).AuthStorage;
+        if (!ctor) {
+          throw new Error(
+            "pi's AuthStorage export is missing — the privateer patch for " +
+              "@earendil-works/pi-coding-agent has not been applied to this install. " +
+              "Run `privateer` once with write access to node_modules (a root-owned " +
+              "global install needs sudo), or reinstall with a release bundle.",
+          );
+        }
+        return ctor.create(path);
+      }),
+    };
+  }
+  return cached.store;
+}
+
+/**
+ * Substitute the store. Tests only.
+ *
+ * The account channel's ownership rules used to be testable by handing the functions a
+ * ctx with a fake store on it; the store is resolved internally now, so this is the seam
+ * that replaces it. Pass undefined to restore the real one.
+ */
+export function setPiAuthStoreForTests(store: PiCredentialStore | undefined): void {
+  override = store ? Promise.resolve(store) : undefined;
+  cached = undefined;
+}
+
+/** The registry-shaped reads our callers make. Matches the old ModelRegistry facade. */
+export type RegistryLike = {
+  find(provider: string, modelId: string): unknown;
+  getAll(): readonly unknown[];
+  getAvailable(): Promise<readonly unknown[]>;
+};
+
+/**
+ * A registry-shaped view of a session's services.
+ *
+ * 0.84 kept `ModelRegistry` as a synchronous facade over `ModelRuntime` (that is how
+ * extensions still see it) but stopped putting one on `services`. We deliberately do NOT
+ * construct one: importing the class would drag Pi into this module's static graph. The
+ * runtime is a live object Pi already gave us, so three delegating methods reproduce
+ * exactly the surface our callers used — `find` is `getModel` renamed.
+ */
+export function modelRegistryOf(services: { modelRuntime?: unknown } | null | undefined): RegistryLike {
+  const runtime = services?.modelRuntime as {
+    getModel(p: string, id: string): unknown;
+    getModels(): readonly unknown[];
+    getAvailable(): Promise<readonly unknown[]>;
+  } | undefined;
+  return {
+    find: (provider, modelId) => runtime?.getModel(provider, modelId),
+    getAll: () => runtime?.getModels() ?? [],
+    getAvailable: async () => (await runtime?.getAvailable()) ?? [],
+  };
+}

package/src/remote/liveTaskSession.ts

@@ -20,7 +20,9 @@ import { agentVersion } from "../config/version.ts";
 import { createEngineEventAdapter } from "../bridge/engineAdapter.ts";
 import { isRemoteUnsafeTool, type GateController } from "../ext/permissionGate.ts";
 import { moatResourceOptions } from "../config/moat.ts";
-import { rememberAccountCredential, dropPersistedAccountCredential } from "../providers/account.ts";
+import { rememberAccountCredential, persistAccountCredential, dropPersistedAccountCredential } from "../providers/account.ts";
+// Pi-free static graph by design — see the header of piAuthStore.ts.
+import { modelRegistryOf } from "../providers/piAuthStore.ts";
 import { RelayClient, type TaskSpec } from "./relayClient.ts";
 import { RemoteBridge } from "./remoteBridge.ts";
 import { AttachmentStore, type StoredAttachment } from "../util/attachmentStore.ts";
@@ -70,7 +72,6 @@ export async function createLiveTaskSession(spec: TaskSpec, deps: LiveTaskDeps):
   let initialPromptSent = false;
   let stopped = false;
   let spawnedAccount = false;
-  let servicesRef: { authStorage?: { remove?: (p: string) => void; get?: (p: string) => unknown } } | null = null;
 
   let attachTimer: ReturnType<typeof setTimeout> | undefined;
   let lifeTimer: ReturnType<typeof setTimeout> | undefined;
@@ -117,7 +118,7 @@ export async function createLiveTaskSession(spec: TaskSpec, deps: LiveTaskDeps):
       try { await revokeAccountSession(); } catch { /* server TTL is the fallback */ }
       // Ownership-checked: auth.json is shared machine-wide, so a live task's teardown
       // must not delete an interactive terminal's entry (see providers/account.ts).
-      try { dropPersistedAccountCredential({ modelRegistry: { authStorage: servicesRef?.authStorage } }); } catch { /* nothing persisted */ }
+      try { await dropPersistedAccountCredential(); } catch { /* nothing persisted */ }
     }
     deps.onClosed(termId);
     deps.log(`live task ${termId} closed`);
@@ -218,13 +219,12 @@ export async function createLiveTaskSession(spec: TaskSpec, deps: LiveTaskDeps):
       })) as any),
     },
   });
-  servicesRef = services as any;
 
   const { provider, modelId } = deps.parseSpec(modelSpec);
   if (provider === "privateer") {
     try {
       const creds = await spawnAccountCredentials();
-      (services.authStorage as any).set("privateer", { type: "oauth", ...creds });
+      await persistAccountCredential(creds);
       rememberAccountCredential(creds); // claim it, so stop() drops OUR entry only
       spawnedAccount = true;
     } catch (e) {
@@ -236,7 +236,7 @@ export async function createLiveTaskSession(spec: TaskSpec, deps: LiveTaskDeps):
   // just spawned + closes the relay), or a throw would leak an orphaned account "device"
   // until its token TTL. Everything post-account-spawn runs under one guard.
   try {
-  const model = (services.modelRegistry as any).find(provider, modelId);
+  const model = (modelRegistryOf(services) as any).find(provider, modelId);
   if (!model) {
     throw new Error(`model ${provider}/${modelId} not found`);
   }

package/src/session.ts

@@ -16,8 +16,18 @@ import {
   SessionManager,
   SettingsManager,
   ModelRegistry,
-  AuthStorage,
+  ModelRuntime,
 } from "@earendil-works/pi-coding-agent";
+// From pi-ai, deliberately, not pi-coding-agent's `AuthStorage.inMemory()`. 0.84
+// stopped exporting AuthStorage and our pi patch puts the export back — which is
+// fine for the one caller that genuinely needs the file-backed store
+// (providers/piAuthStore.ts) and wrong here, because patches are best-effort by
+// design: `bin/apply-patches.mjs` degrades to stock pi when it cannot write to
+// node_modules (the `sudo npm i -g` case it calls out). A static import of a
+// patched-in export turns that graceful degradation into a hard ERR_IMPORT crash
+// on every session start. pi-ai exports this store unpatched and it implements the
+// same CredentialStore interface, so nothing about the session changes.
+import { InMemoryCredentialStore } from "@earendil-works/pi-ai";
 
 import { agentDir as defaultAgentDir } from "./config/paths.ts";
 import { createEngineEventAdapter } from "./bridge/engineAdapter.ts";
@@ -46,15 +56,23 @@ export interface PrivateerSession {
 export async function createSession(opts: CreateSessionOptions): Promise<PrivateerSession> {
   const AGENT_DIR = opts.agentDir ?? process.env.PI_CODING_AGENT_DIR ?? defaultAgentDir();
 
-  const authStorage = AuthStorage.inMemory();
-  const modelRegistry = ModelRegistry.create(authStorage, `${AGENT_DIR}/models.json`);
-  if (typeof (modelRegistry as any).refresh === "function") await (modelRegistry as any).refresh();
-  else if (typeof (modelRegistry as any).loadModels === "function")
-    await (modelRegistry as any).loadModels();
+  // pi 0.84: ModelRegistry.create(authStorage, modelsPath) is gone. The registry is now
+  // a synchronous facade over a ModelRuntime, and the runtime is what owns credentials —
+  // so the store this session used to hand to the registry is injected into the runtime
+  // instead. Still in-memory: a headless session must not touch the machine's auth.json.
+  const authStorage = new InMemoryCredentialStore();
+  const modelRuntime = await ModelRuntime.create({
+    credentials: authStorage,
+    modelsPath: `${AGENT_DIR}/models.json`,
+  });
+  const modelRegistry = new ModelRegistry(modelRuntime);
+  // Explicit, and awaited: find() below is synchronous, so models.json has to be loaded
+  // before it runs or the lookup fails on a cold cache.
+  await modelRegistry.refresh();
 
   const model = modelRegistry.find(opts.provider, opts.modelId);
   if (!model) {
-    const ids = ((modelRegistry as any).getAll?.() ?? []).map(
+    const ids = (modelRegistry.getAll() ?? []).map(
       (m: any) => `${m.provider}/${m.id}`,
     );
     throw new Error(
@@ -75,8 +93,7 @@ export async function createSession(opts: CreateSessionOptions): Promise<Private
     cwd: opts.cwd,
     agentDir: AGENT_DIR,
     model,
-    authStorage,
-    modelRegistry,
+    modelRuntime,
     settingsManager,
     sessionManager: SessionManager.inMemory(opts.cwd),
     resourceLoader: loader,