unspaghettit 0.2.0 → 0.4.0

package/src/features/behavior-model/domain/value-objects/RuleCondition.ts

@@ -76,7 +76,33 @@ export type NotCondition = {
 
 export type CompositeRuleCondition = AllCondition | AnyCondition | NotCondition;
 
-export type RuleCondition = LeafRuleCondition | CompositeRuleCondition;
+/**
+ * Quantifier over the elements of an array-typed state path. `all_match` holds
+ * when EVERY element satisfies `where`; `any_match` holds when AT LEAST ONE
+ * does. This is the per-element guarantee that `count_where` (a count) and the
+ * boolean combinators (over sibling conditions, not elements) could never
+ * express — e.g. the invariant "every order line has qty > 0".
+ *
+ * Evaluation binds each element into the snapshot under the `as` name, then
+ * evaluates `where` as an ordinary condition. So with `as: "item"` over an
+ * array of objects, the body reads `item.qty`; over an array of scalars it
+ * reads `item` directly. The body may also reference outer state paths
+ * (e.g. compare `item.qty` to a threshold elsewhere in state).
+ *
+ * Vacuous truth: `all_match` over a missing/empty array is TRUE, `any_match`
+ * is FALSE — the standard ∀/∃ semantics.
+ */
+export type QuantifierCondition = {
+  readonly kind: 'all_match' | 'any_match';
+  readonly overPath: StatePath;
+  readonly as: string;
+  readonly where: RuleCondition;
+};
+
+export type RuleCondition =
+  | LeafRuleCondition
+  | CompositeRuleCondition
+  | QuantifierCondition;
 
 /**
  * Runtime guard: a composite condition carries a `kind` matching one of
@@ -91,6 +117,20 @@ export const isCompositeCondition = (
   return k === 'all' || k === 'any' || k === 'not';
 };
 
+/**
+ * Runtime guard: a quantifier condition (`all_match` / `any_match`). Kept
+ * separate from `isCompositeCondition` because quantifiers introduce a scoped
+ * element binding and so are evaluated/walked differently from the plain
+ * boolean combinators.
+ */
+export const isQuantifierCondition = (
+  c: unknown
+): c is QuantifierCondition => {
+  if (!c || typeof c !== 'object') return false;
+  const k = (c as { kind?: unknown }).kind;
+  return k === 'all_match' || k === 'any_match';
+};
+
 /**
  * Walks a condition tree and yields every leaf comparison it contains.
  * Use when a consumer (path collector, graph builder, indexer) needs to
@@ -111,6 +151,17 @@ export const flattenLeafConditions = (
       else for (const sub of node.conditions) walk(sub);
       return;
     }
+    if (isQuantifierCondition(node)) {
+      // Surface the array source as a synthetic `exists` leaf so every
+      // path-validator / collector that walks leaves sees the quantified
+      // array reference and keeps working unchanged. The body is NOT
+      // descended into: its leaves reference the scoped element binding
+      // (`as`), which isn't a declared outer state path and would be a false
+      // "unknown path" to those consumers. Body evaluation is handled
+      // directly by the condition evaluator, which understands the binding.
+      out.push({ left: node.overPath, operator: 'exists' });
+      return;
+    }
     out.push(node);
   };
   walk(c);

package/src/features/behavior-model/domain/value-objects/SimulationClock.ts

@@ -0,0 +1,35 @@
+import { asStatePath, readPath, writePath, type StateSnapshot, type StatePath } from './StatePath';
+
+/**
+ * Reserved state path holding the simulation clock — a NUMBER in logical time
+ * units chosen by the model (seconds, minutes, ticks; the engine doesn't care).
+ * It is the single source of "now" that conditions and invariants compare
+ * stored timestamps against ("session.expiresAt greater_than clock.now"), and
+ * the `advance_time` effect / scenario `timeAdvance` are the only sanctioned
+ * ways to move it forward.
+ *
+ * Time is EXPLICIT state, never wall-clock: a scenario that advances the clock
+ * by N and re-runs an action is fully deterministic and replayable, which is
+ * what makes "after 30 minutes the token is expired" verifiable instead of
+ * flaky. The path is implicitly available on every surface (the validator
+ * treats it as always-declared). The engine does NOT auto-seed it — the clock
+ * materializes the first time it is advanced — but it reads as 0 until then via
+ * `readNow`, so future-deadline comparisons behave as "time 0".
+ */
+export const CLOCK_NOW_PATH: StatePath = asStatePath('clock.now');
+
+/** Read the current clock value, defaulting to 0 when unset/non-numeric. */
+export const readNow = (snapshot: StateSnapshot): number => {
+  const v = readPath(snapshot, CLOCK_NOW_PATH);
+  return typeof v === 'number' && Number.isFinite(v) ? v : 0;
+};
+
+/**
+ * Advance the clock by `by` logical units. Time never runs backward: a negative
+ * or non-finite delta is clamped to 0 (a no-op), so a malformed duration can't
+ * un-expire something already expired.
+ */
+export const advanceClock = (snapshot: StateSnapshot, by: number): StateSnapshot => {
+  const delta = typeof by === 'number' && Number.isFinite(by) && by > 0 ? by : 0;
+  return writePath(snapshot, CLOCK_NOW_PATH, readNow(snapshot) + delta);
+};

package/src/features/behavior-model/domain/value-objects/ids.ts

@@ -16,6 +16,7 @@ export type EntityFieldId = Brand<string, 'EntityFieldId'>;
 export type ScenarioId = Brand<string, 'ScenarioId'>;
 export type EventDefinitionId = Brand<string, 'EventDefinitionId'>;
 export type ValueSetId = Brand<string, 'ValueSetId'>;
+export type ReachabilityGoalId = Brand<string, 'ReachabilityGoalId'>;
 
 export const asFeatureId = (v: string): FeatureId => v as FeatureId;
 export const asSurfaceId = (v: string): SurfaceId => v as SurfaceId;
@@ -33,3 +34,4 @@ export const asEntityFieldId = (v: string): EntityFieldId => v as EntityFieldId;
 export const asScenarioId = (v: string): ScenarioId => v as ScenarioId;
 export const asEventDefinitionId = (v: string): EventDefinitionId => v as EventDefinitionId;
 export const asValueSetId = (v: string): ValueSetId => v as ValueSetId;
+export const asReachabilityGoalId = (v: string): ReachabilityGoalId => v as ReachabilityGoalId;

package/src/features/behavior-model/infrastructure/io/FeatureJson.ts

@@ -1,96 +1,96 @@
-import type { Entity } from '$features/behavior-model/domain/entities/Entity';
-import type { Feature } from '$features/behavior-model/domain/entities/Feature';
-import type { Surface } from '$features/behavior-model/domain/entities/Surface';
-import { normalizeFeatureEmittedEvents } from '$features/behavior-model/domain/services/FeatureEmittedEventsNormalizer';
-import { normalizeFeatureExpressions } from '$features/behavior-model/domain/services/FeatureExpressionNormalizer';
+import type { Entity } from '$features/behavior-model/domain/entities/Entity';
+import type { Feature } from '$features/behavior-model/domain/entities/Feature';
+import type { Surface } from '$features/behavior-model/domain/entities/Surface';
+import { normalizeFeatureEmittedEvents } from '$features/behavior-model/domain/services/FeatureEmittedEventsNormalizer';
+import { normalizeFeatureExpressions } from '$features/behavior-model/domain/services/FeatureExpressionNormalizer';
 import { normalizeFeatureRuleCategories } from '$features/behavior-model/domain/services/FeatureRuleCategoryNormalizer';
 import { normalizeFeatureSharedState } from '$features/behavior-model/domain/services/FeatureSharedStateNormalizer';
 import { normalizeTags } from '$shared/domain/Tags';
-
-export type FeatureExportEnvelope = {
-  readonly format: 'unspaghettit';
-  readonly version: 1;
-  readonly feature: Feature;
-};
-
-export const exportFeatureToJson = (feature: Feature): string => {
-  const envelope: FeatureExportEnvelope = {
-    format: 'unspaghettit',
-    version: 1,
-    feature
-  };
-  return JSON.stringify(envelope, null, 2);
-};
-
-/**
- * Pre-rename JSON snapshots stored the Surface's user-action list under the
- * key `capabilities`. The TS field is now `actions`. Migrate on read so old
- * files keep loading without a separate batch migration step. New writes
- * always use the new key.
- */
-const migrateSurface = (raw: Record<string, unknown>): Surface => {
-  if ('actions' in raw) return raw as unknown as Surface;
-  if ('capabilities' in raw) {
-    const { capabilities, ...rest } = raw;
-    return { ...rest, actions: capabilities } as unknown as Surface;
-  }
-  return raw as unknown as Surface;
-};
-
-export const importFeatureFromJson = (raw: string): Feature => {
-  let parsed: unknown;
-  try {
-    parsed = JSON.parse(raw);
-  } catch (error) {
-    throw new Error(`Invalid JSON: ${(error as Error).message}`);
-  }
-  if (!parsed || typeof parsed !== 'object') {
-    throw new Error('Expected a feature export object');
-  }
-  // Accept both the new `feature` envelope key and the legacy `experience`
-  // key so older snapshots keep loading. New writes always use `feature`.
-  const envelope = parsed as {
-    format?: string;
-    version?: number;
-    feature?: Feature;
-    experience?: Feature;
-  };
-  if (envelope.format !== 'unspaghettit') {
-    throw new Error('Not an Unspaghettit export (missing format field)');
-  }
-  if (envelope.version !== 1) {
-    throw new Error(`Unsupported export version: ${envelope.version}`);
-  }
-  const feature = envelope.feature ?? envelope.experience;
-  if (!feature) {
-    throw new Error('Export envelope is missing a feature');
-  }
-  const rawSurfaces =
-    (feature as unknown as { surfaces?: readonly unknown[] }).surfaces ?? [];
-  const surfaces = rawSurfaces.map((s) => migrateSurface(s as Record<string, unknown>));
-  // Pre-rename JSON used `data[]` for first-class entity records; new files
-  // write `entities[]`. Accept either so legacy snapshots still load.
-  const expRaw = feature as unknown as {
-    entities?: readonly unknown[];
-    data?: readonly unknown[];
-  };
-  const entities = (expRaw.entities ?? expRaw.data ?? []) as readonly Entity[];
-  // Normalize Expression trees and emittedEvents on import so legacy
-  // snapshots load with healed-in-memory data. Expression normalization
-  // wraps raw scalars in `{kind:"literal",value}`; emittedEvents normalization
-  // merges every emit_event effect's name into the action's declared list.
-  return normalizeFeatureSharedState(
-    normalizeFeatureRuleCategories(
-      normalizeFeatureEmittedEvents(
+
+export type FeatureExportEnvelope = {
+  readonly format: 'unspaghettit';
+  readonly version: 1;
+  readonly feature: Feature;
+};
+
+export const exportFeatureToJson = (feature: Feature): string => {
+  const envelope: FeatureExportEnvelope = {
+    format: 'unspaghettit',
+    version: 1,
+    feature
+  };
+  return JSON.stringify(envelope, null, 2);
+};
+
+/**
+ * Pre-rename JSON snapshots stored the Surface's user-action list under the
+ * key `capabilities`. The TS field is now `actions`. Migrate on read so old
+ * files keep loading without a separate batch migration step. New writes
+ * always use the new key.
+ */
+const migrateSurface = (raw: Record<string, unknown>): Surface => {
+  if ('actions' in raw) return raw as unknown as Surface;
+  if ('capabilities' in raw) {
+    const { capabilities, ...rest } = raw;
+    return { ...rest, actions: capabilities } as unknown as Surface;
+  }
+  return raw as unknown as Surface;
+};
+
+export const importFeatureFromJson = (raw: string): Feature => {
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (error) {
+    throw new Error(`Invalid JSON: ${(error as Error).message}`);
+  }
+  if (!parsed || typeof parsed !== 'object') {
+    throw new Error('Expected a feature export object');
+  }
+  // Accept both the new `feature` envelope key and the legacy `experience`
+  // key so older snapshots keep loading. New writes always use `feature`.
+  const envelope = parsed as {
+    format?: string;
+    version?: number;
+    feature?: Feature;
+    experience?: Feature;
+  };
+  if (envelope.format !== 'unspaghettit') {
+    throw new Error('Not an Unspaghettit export (missing format field)');
+  }
+  if (envelope.version !== 1) {
+    throw new Error(`Unsupported export version: ${envelope.version}`);
+  }
+  const feature = envelope.feature ?? envelope.experience;
+  if (!feature) {
+    throw new Error('Export envelope is missing a feature');
+  }
+  const rawSurfaces =
+    (feature as unknown as { surfaces?: readonly unknown[] }).surfaces ?? [];
+  const surfaces = rawSurfaces.map((s) => migrateSurface(s as Record<string, unknown>));
+  // Pre-rename JSON used `data[]` for first-class entity records; new files
+  // write `entities[]`. Accept either so legacy snapshots still load.
+  const expRaw = feature as unknown as {
+    entities?: readonly unknown[];
+    data?: readonly unknown[];
+  };
+  const entities = (expRaw.entities ?? expRaw.data ?? []) as readonly Entity[];
+  // Normalize Expression trees and emittedEvents on import so legacy
+  // snapshots load with healed-in-memory data. Expression normalization
+  // wraps raw scalars in `{kind:"literal",value}`; emittedEvents normalization
+  // merges every emit_event effect's name into the action's declared list.
+  return normalizeFeatureSharedState(
+    normalizeFeatureRuleCategories(
+      normalizeFeatureEmittedEvents(
         normalizeFeatureExpressions({
           ...feature,
           tags: normalizeTags(feature.tags),
           surfaces,
-          personas: feature.personas ?? [],
-          resources: feature.resources ?? [],
-          entities
-        })
-      )
-    )
-  );
-};
+          personas: feature.personas ?? [],
+          resources: feature.resources ?? [],
+          entities
+        })
+      )
+    )
+  );
+};

package/src/features/behavior-model/infrastructure/persistence/HttpFeatureRepository.ts

@@ -1,43 +1,43 @@
-import type {
-  FeatureRepository,
-  FeatureSummary
-} from '$features/behavior-model/application/ports/FeatureRepository';
-import type { Feature } from '$features/behavior-model/domain/entities/Feature';
-import type { FeatureId } from '$features/behavior-model/domain/value-objects/ids';
-import { apiFetch } from '$shared/security/apiFetch';
-
-const BASE = '/api/snapshots';
-const itemUrl = (id: string) => `${BASE}/${encodeURIComponent(id)}`;
-
-export class HttpFeatureRepository implements FeatureRepository {
-  async list(): Promise<readonly FeatureSummary[]> {
-    const res = await apiFetch(BASE);
-    if (!res.ok) throw new Error(`Snapshot list failed (${res.status})`);
-    const body = (await res.json()) as { summaries: readonly FeatureSummary[] };
-    return body.summaries;
-  }
-
-  async get(id: FeatureId): Promise<Feature | null> {
-    const res = await apiFetch(itemUrl(id));
-    if (res.status === 404) return null;
-    if (!res.ok) throw new Error(`Snapshot get failed (${res.status})`);
-    return (await res.json()) as Feature;
-  }
-
-  async save(feature: Feature): Promise<void> {
-    const res = await apiFetch(itemUrl(feature.id), {
-      method: 'PUT',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify(feature)
-    });
-    if (!res.ok) {
-      const text = await res.text().catch(() => '');
-      throw new Error(`Snapshot save failed (${res.status})${text ? `: ${text}` : ''}`);
-    }
-  }
-
-  async delete(id: FeatureId): Promise<void> {
-    const res = await apiFetch(itemUrl(id), { method: 'DELETE' });
-    if (!res.ok && res.status !== 404) throw new Error(`Snapshot delete failed (${res.status})`);
-  }
-}
+import type {
+  FeatureRepository,
+  FeatureSummary
+} from '$features/behavior-model/application/ports/FeatureRepository';
+import type { Feature } from '$features/behavior-model/domain/entities/Feature';
+import type { FeatureId } from '$features/behavior-model/domain/value-objects/ids';
+import { apiFetch } from '$shared/security/apiFetch';
+
+const BASE = '/api/snapshots';
+const itemUrl = (id: string) => `${BASE}/${encodeURIComponent(id)}`;
+
+export class HttpFeatureRepository implements FeatureRepository {
+  async list(): Promise<readonly FeatureSummary[]> {
+    const res = await apiFetch(BASE);
+    if (!res.ok) throw new Error(`Snapshot list failed (${res.status})`);
+    const body = (await res.json()) as { summaries: readonly FeatureSummary[] };
+    return body.summaries;
+  }
+
+  async get(id: FeatureId): Promise<Feature | null> {
+    const res = await apiFetch(itemUrl(id));
+    if (res.status === 404) return null;
+    if (!res.ok) throw new Error(`Snapshot get failed (${res.status})`);
+    return (await res.json()) as Feature;
+  }
+
+  async save(feature: Feature): Promise<void> {
+    const res = await apiFetch(itemUrl(feature.id), {
+      method: 'PUT',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(feature)
+    });
+    if (!res.ok) {
+      const text = await res.text().catch(() => '');
+      throw new Error(`Snapshot save failed (${res.status})${text ? `: ${text}` : ''}`);
+    }
+  }
+
+  async delete(id: FeatureId): Promise<void> {
+    const res = await apiFetch(itemUrl(id), { method: 'DELETE' });
+    if (!res.ok && res.status !== 404) throw new Error(`Snapshot delete failed (${res.status})`);
+  }
+}

package/src/features/behavior-model/infrastructure/persistence/JsonFolderFeatureRepository.ts

@@ -65,6 +65,16 @@ export class JsonFolderFeatureRepository implements FeatureRepository {
     return found ? found.feature : null;
   }
 
+  /**
+   * Server-only bulk read: every full Feature in ONE directory pass. Not on the
+   * {@link FeatureRepository} port — it exists so derived artifacts (notably the
+   * global-search index) can build in O(N) instead of the O(N²) that
+   * `list()` + a `get()` per id incurs (each `get` re-walks the whole folder).
+   */
+  async listFull(): Promise<readonly Feature[]> {
+    return this.readAll().map((s) => s.feature);
+  }
+
   async save(feature: Feature): Promise<void> {
     // Re-resolve the owning project on every save: when a feature is reassigned
     // (add_feature_to_project / remove_feature_from_project), the very next

package/src/features/behavior-model/infrastructure/persistence/snapshot-discovery.ts

@@ -1,76 +1,76 @@
-import { existsSync, readdirSync, statSync } from 'node:fs';
-import { homedir } from 'node:os';
-import { isAbsolute, join, parse, resolve } from 'node:path';
-
-export type SnapshotDirectorySource = 'override' | 'walk' | 'hub-default';
-
-export type SnapshotDirectory = {
-  readonly directory: string;
-  readonly source: SnapshotDirectorySource;
-};
-
-export type DiscoverOptions = {
-  readonly override?: string;
-  readonly cwd?: string;
-  /** Home directory used to resolve the shared hub. Defaults to os.homedir(). */
-  readonly home?: string;
-};
-
-const SNAPSHOT_SUFFIXES = ['.feature.json', '.project.json'];
-const FOLDER_NAME = 'unspa';
-
-/**
- * Shared snapshot hub layout: `<home>/.unspa-hub/unspa`. The `.unspa-hub`
- * parent is the well-known launch point for `unspa dashboard`; the `unspa`
- * subfolder is the snapshot directory itself. This is the default home for
- * every project's behavior model — `unspa init` no longer scaffolds a per-repo
- * `unspa/` folder, so when neither an explicit override nor a walk-up hit is
- * found, both the dashboard and the MCP server land here on the first run. The
- * folder is created lazily on first write (`ensureProjectDir` does `mkdir -p`).
- *
- * `homedir()` + `path.join` keep this correct on Windows, macOS, and Linux.
- */
-export const HUB_ROOT_SEGMENT = '.unspa-hub';
-export const HUB_SNAPSHOTS_SEGMENT = FOLDER_NAME;
-
-export const defaultHubDirectory = (home: string = homedir()): string =>
-  join(home, HUB_ROOT_SEGMENT, HUB_SNAPSHOTS_SEGMENT);
-
-const containsSnapshot = (dir: string): boolean => {
-  if (!existsSync(dir)) return false;
-  if (!statSync(dir).isDirectory()) return false;
-  return readdirSync(dir).some((entry) =>
-    SNAPSHOT_SUFFIXES.some((suffix) => entry.endsWith(suffix))
-  );
-};
-
-export const discoverSnapshotDirectory = (
-  opts: DiscoverOptions = {}
-): SnapshotDirectory => {
-  const cwd = opts.cwd ?? process.cwd();
-
-  if (opts.override !== undefined) {
-    const directory = isAbsolute(opts.override) ? opts.override : resolve(cwd, opts.override);
-    return { directory, source: 'override' };
-  }
-
-  let current = resolve(cwd);
-  const { root } = parse(current);
-  while (true) {
-    const candidate = resolve(current, FOLDER_NAME);
-    if (containsSnapshot(candidate)) {
-      return { directory: candidate, source: 'walk' };
-    }
-    if (current === root) break;
-    const parent = resolve(current, '..');
-    if (parent === current) break;
-    current = parent;
-  }
-
-  // Nothing checked into this tree: fall back to the shared hub rather than an
-  // empty `<cwd>/unspa`. This is what makes hub mode the zero-config default —
-  // the MCP entry needs no UNSPA_SNAPSHOTS and `unspa dashboard` finds the same
-  // folder no matter where it's launched from. A per-repo `unspa/` (custom
-  // install) still wins above via the walk-up.
-  return { directory: defaultHubDirectory(opts.home), source: 'hub-default' };
-};
+import { existsSync, readdirSync, statSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { isAbsolute, join, parse, resolve } from 'node:path';
+
+export type SnapshotDirectorySource = 'override' | 'walk' | 'hub-default';
+
+export type SnapshotDirectory = {
+  readonly directory: string;
+  readonly source: SnapshotDirectorySource;
+};
+
+export type DiscoverOptions = {
+  readonly override?: string;
+  readonly cwd?: string;
+  /** Home directory used to resolve the shared hub. Defaults to os.homedir(). */
+  readonly home?: string;
+};
+
+const SNAPSHOT_SUFFIXES = ['.feature.json', '.project.json'];
+const FOLDER_NAME = 'unspa';
+
+/**
+ * Shared snapshot hub layout: `<home>/.unspa-hub/unspa`. The `.unspa-hub`
+ * parent is the well-known launch point for `unspa dashboard`; the `unspa`
+ * subfolder is the snapshot directory itself. This is the default home for
+ * every project's behavior model — `unspa init` no longer scaffolds a per-repo
+ * `unspa/` folder, so when neither an explicit override nor a walk-up hit is
+ * found, both the dashboard and the MCP server land here on the first run. The
+ * folder is created lazily on first write (`ensureProjectDir` does `mkdir -p`).
+ *
+ * `homedir()` + `path.join` keep this correct on Windows, macOS, and Linux.
+ */
+export const HUB_ROOT_SEGMENT = '.unspa-hub';
+export const HUB_SNAPSHOTS_SEGMENT = FOLDER_NAME;
+
+export const defaultHubDirectory = (home: string = homedir()): string =>
+  join(home, HUB_ROOT_SEGMENT, HUB_SNAPSHOTS_SEGMENT);
+
+const containsSnapshot = (dir: string): boolean => {
+  if (!existsSync(dir)) return false;
+  if (!statSync(dir).isDirectory()) return false;
+  return readdirSync(dir).some((entry) =>
+    SNAPSHOT_SUFFIXES.some((suffix) => entry.endsWith(suffix))
+  );
+};
+
+export const discoverSnapshotDirectory = (
+  opts: DiscoverOptions = {}
+): SnapshotDirectory => {
+  const cwd = opts.cwd ?? process.cwd();
+
+  if (opts.override !== undefined) {
+    const directory = isAbsolute(opts.override) ? opts.override : resolve(cwd, opts.override);
+    return { directory, source: 'override' };
+  }
+
+  let current = resolve(cwd);
+  const { root } = parse(current);
+  while (true) {
+    const candidate = resolve(current, FOLDER_NAME);
+    if (containsSnapshot(candidate)) {
+      return { directory: candidate, source: 'walk' };
+    }
+    if (current === root) break;
+    const parent = resolve(current, '..');
+    if (parent === current) break;
+    current = parent;
+  }
+
+  // Nothing checked into this tree: fall back to the shared hub rather than an
+  // empty `<cwd>/unspa`. This is what makes hub mode the zero-config default —
+  // the MCP entry needs no UNSPA_SNAPSHOTS and `unspa dashboard` finds the same
+  // folder no matter where it's launched from. A per-repo `unspa/` (custom
+  // install) still wins above via the walk-up.
+  return { directory: defaultHubDirectory(opts.home), source: 'hub-default' };
+};