@codeworksh/harness 0.0.1-dev.20260923102526 → 0.0.1-dev.20260925125142

package/effect.d.mts

@@ -1284,9 +1284,13 @@ declare const defaultLayer: Layer.Layer<Service$9, Config.ConfigError, never>;
 declare const layerWith: (input: Partial<Interface$8>) => Layer.Layer<Service$9, Config.ConfigError, never>;
 import * as import__codeworksh_plugin_settings from "@codeworksh/plugin/settings";
 declare namespace settings_d_exports {
-  export { Interface$7 as Interface, Options$4 as Options, Service$8 as Service, settings_d_exports as Settings, SettingsError, schema_d_exports$4.defaults as defaults, layer$7 as layer, load$1 as load, parse$1 as parse, paths, projectRoot };
+  export { Interface$7 as Interface, Options$4 as Options, Service$8 as Service, settings_d_exports as Settings, SettingsError, schema_d_exports$4.defaults as defaults, layer$7 as layer, load$1 as load, modules, parse$1 as parse, paths, projectRoot, userConfigDir };
 }
 interface Options$4 {
+  /**
+   * `--user-config-dir`, already absolute ({@link userConfigDir}): the directory whose settings
+   * file replaces the user layer's.
+   */
   readonly userConfigDir?: string;
   /**
    * The host directory this load discovers the project layer from, supplied by the caller --
@@ -1302,6 +1306,12 @@ interface Options$4 {
    */
   readonly hostDir?: string | undefined;
 }
+/**
+ * An app-level `--user-config-dir` as the absolute directory it names: `~` is the user's home, and
+ * a relative spelling is relative to `hostCwd` -- never to a session's `hostDir`, which is not
+ * where the flag was typed.
+ */
+declare const userConfigDir: (raw: string, hostCwd: string) => string;
 /**
  * The project a directory is in: the nearest ancestor holding a `.codework` **directory**.
  *
@@ -1336,9 +1346,8 @@ declare function paths(input: {
   readonly home: string;
   /** The project root, from {@link projectRoot}. */
   readonly root?: string | undefined;
-  /** What a relative `--user-config-dir` is resolved against. */
-  readonly from?: string | undefined;
-  readonly custom?: string | undefined;
+  /** `--user-config-dir`, absolute ({@link userConfigDir}): replaces the home's settings. */
+  readonly userConfigDir?: string | undefined;
 }): ReadonlyArray<ReadonlyArray<string>>;
 declare const SettingsError_base: Schema.Class<SettingsError, Schema.TaggedStruct<"SettingsError", {
   readonly path: Schema.String;
@@ -1565,6 +1574,16 @@ declare const load$1: (options: Options$4 & {
   })[];
   declared: readonly schema_d_exports$4.Declared[];
 }, SettingsError, never>;
+/**
+ * Each module reference once, owned by the **last** file to declare it (D6).
+ *
+ * The owner is not bookkeeping: its `.npmrc` chain keys the store artifact. The CLI that installs
+ * a reference and the runtime that loads it must pick the same owner, or `plugin update` refreshes
+ * an artifact the runtime never reads. Only a string entry loads a module, so only a string entry
+ * owns one -- a `{ package }` patch in another file configures it and must not move its registry.
+ * A reference keeps the position of its first declaration.
+ */
+declare const modules: (declared: ReadonlyArray<schema_d_exports$4.Declared>) => ReadonlyMap<string, schema_d_exports$4.Declared>;
 declare const layer$7: (options?: Omit<Options$4, "hostDir">) => Layer.Layer<Service$8, never, Service$9>;
 import * as import__codeworksh_plugin_plugin from "@codeworksh/plugin/plugin";
 declare namespace registry_d_exports {
@@ -1686,6 +1705,11 @@ type Fetchable = Exclude<Target, {
 declare const parse: (reference: string, from: string) => Effect.Effect<Target, SourceError>;
 //#endregion
 //#region src/plugin/loader.d.ts
+/**
+ * The name a local package declares, read without importing it: the alias the catalog registers
+ * for it, so a `{ package }` entry and a command naming the package both reach it.
+ */
+declare const localName: (location: string) => Effect.Effect<string | undefined>;
 interface Options$3 {
   readonly cache: string;
   /**
@@ -2060,27 +2084,37 @@ declare class Service$5 extends Service_base$4 {}
  * `references` says which entries the config pass walks. It is a function of the settings that
  * exchange read, so a caller that pinned an explicit list keeps it and everyone else follows the
  * files.
+ *
+ * `pool` is the **process view**: what boot loaded from the user layers. A session in a project
+ * runs from that project's own view, a pool created from the process view the first time the
+ * project is seen and moved only by its own sessions. The same spec can be owned by different
+ * files -- and so name different registries -- in two views; one shared pool could hold only one of
+ * those builds, and sessions in different projects would keep evicting each other's.
  */
 declare const layer$4: (options: Options$2, pool: Ref.Ref<Pool>, references: (settings: schema_d_exports$4.Info) => ReadonlyArray<PluginRef>,
 /**
  * The exchange-boundary check: the new pool when the store has moved, nothing when it has not.
  * State does not know what a store is, so whoever built the pool answers this.
  */
-follow: (refs: ReadonlyArray<PluginRef>, current: Pool, settings: schema_d_exports$4.Info) => Effect.Effect<Option.Option<Pool>, {
+follow: (refs: ReadonlyArray<PluginRef>, current: Pool, settings: schema_d_exports$4.Info,
+/** The view's project root, whose host directory the view resolves against. */
+root: string | undefined) => Effect.Effect<Option.Option<Pool>, {
   readonly message: string;
 }>,
 /**
  * A full load pass, told to re-import even where nothing looks different. Resolve-only, like
  * `follow`: reload re-imports what is on disk, it does not fetch.
  *
- * It takes no references and reads its own settings, because the set it must produce is the
- * *process's* -- every module any session might name -- and State only ever sees one session's
- * view. Handing it `references` from here would quietly narrow the pool to whatever the
- * caller's project declares, and drop every other project's plugins on the floor.
+ * It takes a view rather than references and reads that view's settings itself, because the set
+ * it must produce is the view's -- every module any of its sessions has named -- and State only
+ * ever sees one session. Handing it `references` from here would quietly narrow the pool to
+ * whatever the caller declares, and drop what the view's other sessions loaded on the floor.
  */
-rebuild: () => Effect.Effect<Pool, {
+rebuild: (root: string | undefined, current: Pool) => Effect.Effect<Pool, {
   readonly message: string;
-}>) => Layer.Layer<Service$5, never, Service$17 | Service$16 | Service$8 | Service$7 | Service$6>;
+}>,
+/** The view a session in `hostDir` runs from: its project root, or the process view. */
+viewOf?: (hostDir: string | undefined) => Effect.Effect<string | undefined>) => Layer.Layer<Service$5, never, Service$17 | Service$16 | Service$8 | Service$7 | Service$6>;
 declare namespace run_d_exports {
   export { Interface$3 as Interface, LLMStreamError, ModelCatalogError, ModelNotFoundError, ProviderAuthenticationError, ProviderAuthorizationError, ProviderConfigurationError, ProviderContentPolicyError, ProviderError, ProviderFailureReason, ProviderInvalidRequestError, ProviderInvalidResponseError, ProviderModelUnavailableError, ProviderQuotaError, ProviderRateLimitError, ProviderTimeoutError, ProviderTransportError, ProviderUnavailableError, ProviderUnknownError, RunError, run_d_exports as Runner, SandboxDirectoryNotFoundError, Service$4 as Service };
 }
@@ -3183,13 +3217,21 @@ interface Options {
   readonly database?: string;
   /**
    * The process-level host directory: the default sandbox mount, the `.npmrc`/parse fallback
-   * for plugin references no file declared, and the base a relative `--user-config-dir`
+   * for plugin references no file declared, and the base a relative `home` or `userConfigDir`
    * resolves against. Defaults to the OS process's directory. It is never a project-settings
-   * root -- that discovery belongs to a session's `hostDir`.
+   * root -- that discovery belongs to a session's `hostDir` -- and never a sandbox `cwd`.
    */
   readonly hostCwd?: string;
+  /**
+   * `--home`: the shared, user-wide home -- `~/.codework` by default -- holding the user
+   * settings, credentials, plugin cache and data.
+   */
   readonly home?: string;
-  /** user provided directory containing the highest-priority config. */
+  /**
+   * `--user-config-dir`: a hard override of the user settings file only. Its `settings.jsonc`
+   * is read *instead of* the home's; the project layer still sits above it, and everything else
+   * the home holds stays in the home.
+   */
   readonly userConfigDir?: string;
   readonly sandboxes?: ReadonlyArray<Entry$1>;
   readonly llm?: Open;
@@ -23391,6 +23433,15 @@ interface Entry extends Marker {
   /** A `file:` URL for the entrypoint, ready to import. */
   readonly url: string;
 }
+/**
+ * The **full** SHA-256 of the source identity: canonical spec plus effective registry for a
+ * registry package, and the canonical spec alone for git.
+ *
+ * Not truncated. The fast path proves a hit by checking that a marker *exists* rather than by
+ * decoding it, and the index is keyed by digest alone, so a truncated digest would let a collision
+ * return the wrong package silently.
+ */
+declare const digest: (target: Fetchable, cache: string, from: string) => Effect.Effect<string, InstallError | import("effect/PlatformError").PlatformError, never>;
 /**
  * Disk-only lookup. No network, no install -- this is what boot uses, and the reason booting
  * offline works.
@@ -23490,7 +23541,7 @@ declare const update: <A>(target: Fetchable, cache: string, options: {
   readonly validated?: A & ({} | null);
 }, InstallError | LoadError | StoreError, never>;
 declare namespace index_d_exports {
-  export { Checked, Config$1 as Config, Entry, Events, Fetchable, InstallError, LoadError, plugin_d_exports.Mount as Mount, plugin_d_exports.Plugin as Plugin, PluginOptions, PluginRef, PluginRegistry, Probe, schema_d_exports$1 as Prompt, PromptResolver, SetupError, SharedPluginContext, SourceError, StoreError, Target, schema_d_exports$3 as Tool, Updated, anchor, canonical, check, plugin_d_exports.define as define, definition, inspect, parse, probe, resolve, required as resolveCached, lock as settingsLock, update };
+  export { Checked, Config$1 as Config, Entry, Events, Fetchable, InstallError, LoadError, plugin_d_exports.Mount as Mount, plugin_d_exports.Plugin as Plugin, PluginOptions, PluginRef, PluginRegistry, Probe, schema_d_exports$1 as Prompt, PromptResolver, SetupError, SharedPluginContext, SourceError, StoreError, Target, schema_d_exports$3 as Tool, Updated, anchor, canonical, check, plugin_d_exports.define as define, definition, digest as identity, inspect, localName, parse, probe, resolve, required as resolveCached, lock as settingsLock, update };
 }
 type DateTimeUtcFromMillis = import__codeworksh_plugin_schema.DateTimeUtcFromMillis;
 type EventSchema = import__codeworksh_plugin_event.EventSchema;

package/effect.mjs

@@ -6746,6 +6746,12 @@ const Manifest = Schema.Struct({
 	name: Schema.optional(Schema.String),
 	exports: Schema.optional(Schema.Unknown)
 });
+const readManifest = (manifestPath) => fileSystem.readFileString(manifestPath).pipe(Effect.flatMap(Schema.decodeUnknownEffect(Schema.fromJsonString(Manifest))));
+/**
+* The name a local package declares, read without importing it: the alias the catalog registers
+* for it, so a `{ package }` entry and a command naming the package both reach it.
+*/
+const localName = (location) => readManifest(hostPath.join(location, "package.json")).pipe(Effect.map((manifest) => manifest.name), Effect.orElseSucceed(() => void 0));
 const localUrl = Effect.fn("PluginLoader.localUrl")(function* (location, origin) {
 	const escapes = (message) => new SourceError({
 		reason: "plugin-escapes-root",
@@ -6756,7 +6762,7 @@ const localUrl = Effect.fn("PluginLoader.localUrl")(function* (location, origin)
 	if ((yield* fileSystem.stat(location)).type !== "Directory") return { url: yield* Effect.try(() => resolveModule(location, hostPath.dirname(location))) };
 	const manifestPath = hostPath.join(location, "package.json");
 	if (!(yield* fileSystem.exists(manifestPath))) return { url: yield* Effect.try(() => resolveModule("./index", location)) };
-	const manifest = yield* fileSystem.readFileString(manifestPath).pipe(Effect.flatMap(Schema.decodeUnknownEffect(Schema.fromJsonString(Manifest))));
+	const manifest = yield* readManifest(manifestPath);
 	if (manifest.exports !== void 0) {
 		const name = manifest.name;
 		if (!name) return yield* escapes("a local package with exports must declare its name");
@@ -7032,7 +7038,9 @@ const select = Effect.fn("PluginCatalog.select")(function* (references, pool) {
 * walks those entries against the loaded set. Two things can be settled right there, and they are
 * the same question asked twice:
 *
-* 1. a settings entry names a module that is not loaded, and the store holds it;
+* 1. a settings entry names a module that is not loaded, and the store holds it -- or it is loaded
+*    from another file's artifact than the one that owns it in this view, and the store holds
+*    the owner's;
 * 2. a loaded module is not the newest generation the store has.
 *
 * The second is what makes `plugin update` finish. Without it the question is "is this entry
@@ -7051,8 +7059,16 @@ const select = Effect.fn("PluginCatalog.select")(function* (references, pool) {
 const follow = Effect.fn("PluginCatalog.follow")(function* (references, pool, options, filed) {
 	let moved = false;
 	for (const reference of references) {
-		if (typeof reference !== "string" || pool.aliases.has(reference)) continue;
-		if (Option.isSome(yield* filed(reference, anchor$1(options.declared?.get(reference), options.hostDir)))) {
+		if (typeof reference !== "string") continue;
+		const owner = options.declared?.get(reference);
+		const from = anchor$1(owner, options.hostDir);
+		const id = pool.aliases.get(reference);
+		if (id !== void 0) {
+			const origin = pool.origins.get(id);
+			if (owner === void 0 || origin?.reference !== reference) continue;
+			if (anchor$1(origin.file, options.hostDir) === from) continue;
+		}
+		if (Option.isSome(yield* filed(reference, from))) {
 			moved = true;
 			break;
 		}
@@ -7785,7 +7801,7 @@ const make$4 = (tools) => {
 			if (before.value !== void 0 && !Schema.is(schema_exports$2.ToolBeforeResult)(before.value)) return yield* failureOutcome(call, Cause.die(/* @__PURE__ */ new Error("beforeToolCall returned an invalid result")), "beforeToolCall failed");
 			if (before.value?.block) {
 				const now = yield* Effect.clockWith((clock) => clock.currentTimeMillis);
-				return errored(call, [text(before.value.reason || "Tool execution was blocked")], now);
+				return errored(call, [text(before.value?.reason || "Tool execution was blocked")], now);
 			}
 		}
 		const latest = yield* Ref.make(Option.none());
@@ -8101,10 +8117,18 @@ var settings_exports = /* @__PURE__ */ __exportAll({
 	defaults: () => schema_exports$3.defaults,
 	layer: () => layer$5,
 	load: () => load$1,
+	modules: () => modules,
 	parse: () => parse$1,
 	paths: () => paths,
-	projectRoot: () => projectRoot
+	projectRoot: () => projectRoot,
+	userConfigDir: () => userConfigDir
 });
+/**
+* An app-level `--user-config-dir` as the absolute directory it names: `~` is the user's home, and
+* a relative spelling is relative to `hostCwd` -- never to a session's `hostDir`, which is not
+* where the flag was typed.
+*/
+const userConfigDir = (raw, hostCwd) => hostPath.resolve(hostCwd, expandTilde(raw, hostPath));
 /** The settings files a directory may hold, in the order it is searched. */
 const settingsIn = (directory) => [hostPath.join(directory, "settings.jsonc"), hostPath.join(directory, "settings.json")];
 /** A directory and every ancestor above it, nearest first. */
@@ -8154,13 +8178,7 @@ const projectRoot = Effect.fn("Settings.projectRoot")(function* (from, home) {
 * no project layer at all, which is what a session with no host directory gets.
 */
 function paths(input) {
-	const expanded = input.custom === void 0 ? void 0 : expandTilde(input.custom, hostPath);
-	const explicit = expanded === void 0 ? void 0 : input.from === void 0 ? expanded : hostPath.resolve(input.from, expanded);
-	return [
-		settingsIn(input.home),
-		input.root === void 0 ? [] : settingsIn(hostPath.join(input.root, appConfigDir)),
-		...explicit === void 0 ? [] : [settingsIn(explicit)]
-	];
+	return [settingsIn(input.userConfigDir ?? input.home), input.root === void 0 ? [] : settingsIn(hostPath.join(input.root, appConfigDir))];
 }
 var SettingsError = class extends Schema.TaggedError()("SettingsError", {
 	path: Schema.String,
@@ -8238,8 +8256,7 @@ const load$1 = Effect.fn("Settings.load")(function* (options) {
 	const files = paths({
 		home: options.home,
 		root,
-		...options.hostDir === void 0 ? {} : { from: hostPath.resolve(options.hostDir) },
-		...options.userConfigDir === void 0 ? {} : { custom: options.userConfigDir }
+		...options.userConfigDir === void 0 ? {} : { userConfigDir: options.userConfigDir }
 	});
 	let settings = merge(schema_exports$3.defaults);
 	let declared = schema_exports$3.defaults.declared;
@@ -8265,6 +8282,20 @@ const load$1 = Effect.fn("Settings.load")(function* (options) {
 		declared
 	};
 });
+/**
+* Each module reference once, owned by the **last** file to declare it (D6).
+*
+* The owner is not bookkeeping: its `.npmrc` chain keys the store artifact. The CLI that installs
+* a reference and the runtime that loads it must pick the same owner, or `plugin update` refreshes
+* an artifact the runtime never reads. Only a string entry loads a module, so only a string entry
+* owns one -- a `{ package }` patch in another file configures it and must not move its registry.
+* A reference keeps the position of its first declaration.
+*/
+const modules = (declared) => {
+	const owners = /* @__PURE__ */ new Map();
+	for (const one of declared) if (typeof one.entry === "string") owners.set(one.entry, one);
+	return owners;
+};
 const layer$5 = (options = {}) => Layer.effect(Service$2, Effect.gen(function* () {
 	const global = yield* Service$17;
 	return Service$2.of({ load: (hostDir) => load$1({
@@ -8314,8 +8345,14 @@ const resolver = (input) => typeof input === "string" ? () => input : input;
 * `references` says which entries the config pass walks. It is a function of the settings that
 * exchange read, so a caller that pinned an explicit list keeps it and everyone else follows the
 * files.
+*
+* `pool` is the **process view**: what boot loaded from the user layers. A session in a project
+* runs from that project's own view, a pool created from the process view the first time the
+* project is seen and moved only by its own sessions. The same spec can be owned by different
+* files -- and so name different registries -- in two views; one shared pool could hold only one of
+* those builds, and sessions in different projects would keep evicting each other's.
 */
-const layer$4 = (options, pool, references, follow, rebuild) => {
+const layer$4 = (options, pool, references, follow, rebuild, viewOf = () => Effect.undefined) => {
 	return Layer.effect(Service$1, Effect.gen(function* () {
 		const runtime = yield* Service$3;
 		const sessions = yield* Service$14;
@@ -8330,10 +8367,31 @@ const layer$4 = (options, pool, references, follow, rebuild) => {
 			id,
 			...origin.file === void 0 ? {} : { file: origin.file }
 		});
-		const activate = Effect.fn("State.activatePlugins")(function* (next) {
-			const previous = yield* Ref.get(pool);
-			yield* eventRegistry.replace([...next.plugins.values()]);
-			yield* Ref.set(pool, next);
+		/** Project root to its view. The process view is `pool` itself. */
+		const views = /* @__PURE__ */ new Map();
+		/** Created from the process view on first use; called under `loading`, so never twice. */
+		const poolOf = Effect.fnUntraced(function* (root) {
+			if (root === void 0) return pool;
+			const existing = views.get(root);
+			if (existing !== void 0) return existing;
+			const created = yield* Ref.make(yield* Ref.get(pool));
+			views.set(root, created);
+			return created;
+		});
+		const everyView = () => [[void 0, pool], ...views];
+		/**
+		* Every plugin some view runs, one per ID. Event types are process-wide, and two views
+		* holding two builds of one plugin register its namespace once.
+		*/
+		const union = Effect.fnUntraced(function* (target, next) {
+			const plugins = /* @__PURE__ */ new Map();
+			for (const [, ref] of everyView()) for (const [id, plugin] of ref === target ? next.plugins : (yield* Ref.get(ref)).plugins) plugins.set(id, plugin);
+			return plugins;
+		});
+		const activate = Effect.fn("State.activatePlugins")(function* (target, next) {
+			const previous = yield* Ref.get(target);
+			yield* eventRegistry.replace([...(yield* union(target, next)).values()]);
+			yield* Ref.set(target, next);
 			for (const [id, origin] of next.origins) {
 				if (next.plugins.get(id) === previous.plugins.get(id)) continue;
 				yield* updated(origin, id, "loaded");
@@ -8353,16 +8411,21 @@ const layer$4 = (options, pool, references, follow, rebuild) => {
 		});
 		return Service$1.of({
 			reload: Effect.gen(function* () {
-				const rebuilt = yield* rebuild().pipe(Effect.flatMap(activate), loading.withPermits(1), Effect.result);
-				if (rebuilt._tag === "Failure") {
-					yield* Effect.logWarning(`plugin reload failed, keeping the previous set: ${rebuilt.failure.message}`);
-					yield* publishFailed(rebuilt.failure);
-					return {
-						plugins: (yield* Ref.get(pool)).plugins.size,
-						failure: rebuilt.failure.message
-					};
+				const failures = /* @__PURE__ */ new Map();
+				for (const [root, target] of everyView()) {
+					const rebuilt = yield* Ref.get(target).pipe(Effect.flatMap((current) => rebuild(root, current)), Effect.flatMap((next) => activate(target, next)), loading.withPermits(1), Effect.result);
+					if (rebuilt._tag === "Failure") failures.set(rebuilt.failure.message, rebuilt.failure);
+				}
+				for (const failure of failures.values()) {
+					yield* Effect.logWarning(`plugin reload failed, keeping the previous set: ${failure.message}`);
+					yield* publishFailed(failure);
 				}
-				return { plugins: rebuilt.success.plugins.size };
+				const plugins = (yield* union(pool, yield* Ref.get(pool))).size;
+				const [first] = failures.keys();
+				return first === void 0 ? { plugins } : {
+					plugins,
+					failure: first
+				};
 			}),
 			snapshot: Effect.fn("State.snapshot")(function* (sessionId) {
 				const sessionOptions = Option.getOrElse(yield* runtime.get(sessionId), () => ({}));
@@ -8387,10 +8450,12 @@ const layer$4 = (options, pool, references, follow, rebuild) => {
 					cause
 				});
 				const loaded = yield* Effect.gen(function* () {
-					const current = yield* Ref.get(pool);
-					const moved = yield* follow(refs, current, loadedSettings).pipe(Effect.tapError((cause) => publishFailed(cause, sessionId)));
+					const root = yield* viewOf(hostDir);
+					const target = yield* poolOf(root);
+					const current = yield* Ref.get(target);
+					const moved = yield* follow(refs, current, loadedSettings, root).pipe(Effect.tapError((cause) => publishFailed(cause, sessionId)));
 					if (Option.isNone(moved)) return current;
-					return yield* activate(moved.value);
+					return yield* activate(target, moved.value);
 				}).pipe(loading.withPermits(1), Effect.mapError(failed));
 				const chosen = yield* select(refs, loaded).pipe(Effect.mapError(failed));
 				for (const reference of chosen.missing) {
@@ -8883,23 +8948,28 @@ var harness_exports = /* @__PURE__ */ __exportAll({
 	layer: () => layer
 });
 const layer = (options = {}) => Layer.unwrap(Effect.gen(function* () {
-	const paths = yield* resolve$3(options.home === void 0 ? {} : { home: options.home });
 	const hostCwd = options.hostCwd ?? process.cwd();
+	const paths = yield* resolve$3(options.home === void 0 ? {} : { home: hostPath.resolve(hostCwd, expandTilde(options.home, hostPath)) });
 	const global = layerWith$1(paths);
-	const settingsOptions = options.userConfigDir === void 0 ? {} : { userConfigDir: hostPath.resolve(hostCwd, expandTilde(options.userConfigDir, hostPath)) };
+	const settingsOptions = options.userConfigDir === void 0 ? {} : { userConfigDir: userConfigDir(options.userConfigDir, hostCwd) };
 	const config = yield* load$1({
 		...settingsOptions,
 		home: paths.home
 	});
 	const references = (settings) => options.plugins ?? [...builtins, ...settings.plugins];
-	/** Reference to the file that declared it, for failures that should name one. */
-	const declaredIn = (settings) => new Map(settings.declared.flatMap((one) => typeof one.entry === "string" ? [[one.entry, one.file]] : "package" in one.entry ? [[one.entry.package, one.file]] : []));
+	/** Reference to the file that owns it: the `.npmrc` anchor, and what a failure names. */
+	const declaredIn = (settings) => new Map(Array.from(modules(settings.declared), ([reference, one]) => [reference, one.file]));
 	const catalogOptions = {
 		builtins,
 		cache: paths.cache,
 		hostDir: hostCwd
 	};
-	const filed = (reference, from) => parse$2(reference, hostCwd).pipe(Effect.flatMap((target) => target.kind === "local" ? fileSystem.exists(target.path).pipe(Effect.map((there) => there ? Option.some({}) : Option.none())) : resolve$2(target, paths.cache, from).pipe(Effect.map((entry) => Option.fromUndefinedOr(entry)))), Effect.orElseSucceed(() => Option.none()));
+	/**
+	* The host directory a view resolves against: a project view's is the root its sessions'
+	* `hostDir` led to; only the process view falls back to `hostCwd`.
+	*/
+	const hostDirOf = (root) => root ?? hostCwd;
+	const filed = (reference, from) => parse$2(reference, from).pipe(Effect.flatMap((target) => target.kind === "local" ? fileSystem.exists(target.path).pipe(Effect.map((there) => there ? Option.some({}) : Option.none())) : resolve$2(target, paths.cache, from).pipe(Effect.map((entry) => Option.fromUndefinedOr(entry)))), Effect.orElseSucceed(() => Option.none()));
 	const resolveOnly = {
 		...catalogOptions,
 		install: required
@@ -8908,22 +8978,25 @@ const layer = (options = {}) => Layer.unwrap(Effect.gen(function* () {
 		...resolveOnly,
 		declared: declaredIn(config)
 	}));
-	const followStore = (refs, current, settings) => follow(refs, current, {
+	const followStore = (refs, current, settings, root) => follow(refs, current, {
 		...resolveOnly,
+		hostDir: hostDirOf(root),
 		declared: declaredIn(settings)
 	}, filed);
+	/** A session's view is its project root; one with no project runs from the process view. */
+	const viewOf = (hostDir) => hostDir === void 0 ? Effect.undefined : projectRoot(hostDir, paths.home).pipe(Effect.orElseSucceed(() => void 0));
 	let reloads = 0;
-	const rebuild = () => Effect.gen(function* () {
+	const rebuild = (root, loaded) => Effect.gen(function* () {
 		reloads += 1;
 		const current = yield* load$1({
 			...settingsOptions,
-			home: paths.home
+			home: paths.home,
+			...root === void 0 ? {} : { hostDir: root }
 		});
-		const loaded = yield* Ref.get(pool);
 		const retained = [];
 		const configured = references(current);
 		for (const origin of loaded.origins.values()) {
-			if (configured.includes(origin.reference) || Option.isSome(yield* filed(origin.reference, anchor$1(origin.file, hostCwd)))) {
+			if (configured.includes(origin.reference) || Option.isSome(yield* filed(origin.reference, anchor$1(origin.file, hostDirOf(root))))) {
 				retained.push(origin);
 				continue;
 			}
@@ -8935,6 +9008,7 @@ const layer = (options = {}) => Layer.unwrap(Effect.gen(function* () {
 		for (const [reference, file] of declaredIn(current)) known.set(reference, file);
 		return yield* load$2(accumulated, {
 			...resolveOnly,
+			hostDir: hostDirOf(root),
 			declared: known,
 			reload: reloads
 		});
@@ -8947,7 +9021,7 @@ const layer = (options = {}) => Layer.unwrap(Effect.gen(function* () {
 	const authFile$1 = authFile(options.home === void 0 ? void 0 : paths.home);
 	const open = options.llm ?? openWith(authFile$1 === void 0 ? {} : { authFile: authFile$1 });
 	const loop = layer$3({ request: make$5(open) });
-	return layer$10.pipe(Layer.provideMerge(layer$7.pipe(Layer.provide(loop))), Layer.provideMerge(layer$4({}, pool, references, followStore, rebuild)), Layer.provideMerge(layer$5(settingsOptions)), Layer.provideMerge(layer$6), Layer.provideMerge(sandboxes), Layer.provideMerge(layer$22), Layer.provideMerge(layer$1), Layer.provideMerge(layer$25), Layer.provideMerge(layer$9(definitions)), Layer.provideMerge(database), Layer.provideMerge(global), Layer.provideMerge(layer$8({
+	return layer$10.pipe(Layer.provideMerge(layer$7.pipe(Layer.provide(loop))), Layer.provideMerge(layer$4({}, pool, references, followStore, rebuild, viewOf)), Layer.provideMerge(layer$5(settingsOptions)), Layer.provideMerge(layer$6), Layer.provideMerge(sandboxes), Layer.provideMerge(layer$22), Layer.provideMerge(layer$1), Layer.provideMerge(layer$25), Layer.provideMerge(layer$9(definitions)), Layer.provideMerge(database), Layer.provideMerge(global), Layer.provideMerge(layer$8({
 		home: paths.home,
 		watch: options.watchModels ?? false
 	})));
@@ -9245,7 +9319,9 @@ var plugin_exports = /* @__PURE__ */ __exportAll({
 	check: () => check,
 	define: () => plugin_exports$1.define,
 	definition: () => definition$1,
+	identity: () => digest,
 	inspect: () => inspect,
+	localName: () => localName,
 	parse: () => parse$2,
 	probe: () => probe,
 	resolve: () => resolve$2,