@moxxy/core 0.6.3 → 0.21.0

package/src/registries/event-stores.test.ts

@@ -0,0 +1,77 @@
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { promises as fs } from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import type { EventStoreDef } from '@moxxy/sdk';
+import { Session, autoAllowResolver, silentLogger } from '../index.js';
+import { jsonlEventStore } from '../sessions/jsonl-event-store.js';
+
+function makeSession(): Session {
+  return new Session({ cwd: '/tmp', logger: silentLogger, permissionResolver: autoAllowResolver });
+}
+
+describe('EventStore registry + floor', () => {
+  it('seeds the JSONL store as the active, protected floor', () => {
+    const session = makeSession();
+    expect(session.eventStores.getActiveName()).toBe('jsonl');
+    expect(session.eventStores.getFloorName()).toBe('jsonl');
+    expect(session.eventStores.list().map((s) => s.name)).toEqual(['jsonl']);
+  });
+
+  it('a registered second store does NOT auto-activate (trust boundary)', () => {
+    const session = makeSession();
+    const fake: EventStoreDef = {
+      name: 'fake',
+      open: jsonlEventStore.open,
+      restore: jsonlEventStore.restore,
+      readPage: jsonlEventStore.readPage,
+    };
+    session.eventStores.register(fake);
+    // Still on the floor — a discovered store is inert until explicit setActive.
+    expect(session.eventStores.getActiveName()).toBe('jsonl');
+    session.eventStores.setActive('fake');
+    expect(session.eventStores.getActiveName()).toBe('fake');
+    // Removing the swap target reverts to the floor, never null.
+    session.eventStores.unregister('fake');
+    expect(session.eventStores.getActiveName()).toBe('jsonl');
+  });
+
+  it('refuses to unregister the protected jsonl floor', () => {
+    const session = makeSession();
+    expect(() => session.eventStores.unregister('jsonl')).toThrow(/protected default/);
+    expect(session.eventStores.getActiveName()).toBe('jsonl');
+  });
+});
+
+describe('jsonlEventStore round-trip (behaviour-identical to SessionPersistence)', () => {
+  let dir: string;
+  beforeEach(async () => {
+    dir = await fs.mkdtemp(path.join(os.tmpdir(), 'mox-evstore-'));
+  });
+  afterEach(async () => {
+    await fs.rm(dir, { recursive: true, force: true });
+  });
+
+  it('open().attach() persists log events that restore() reads back', async () => {
+    const session = makeSession();
+    const store = session.eventStores.getActive()!;
+    const handle = store.open({ sessionId: session.id, cwd: '/tmp', dir });
+    const detach = handle.attach(session.log);
+
+    await session.log.append({
+      type: 'user_prompt',
+      text: 'hello store',
+      sessionId: session.id,
+      source: 'user',
+    });
+    await handle.settleWrites();
+    await handle.flush();
+
+    const restored = await store.restore(String(session.id), dir);
+    expect(restored.some((e) => e.type === 'user_prompt')).toBe(true);
+
+    const page = await store.readPage(String(session.id), { before: null, limit: 10 }, dir);
+    expect(page.events.length).toBeGreaterThanOrEqual(1);
+    detach();
+  });
+});

package/src/registries/event-stores.ts

@@ -0,0 +1,15 @@
+import type { EventStoreDef } from '@moxxy/sdk';
+import { ActiveDefRegistry } from './active-def-registry.js';
+
+/**
+ * The single-active EventStore registry (storage backend behind the event log).
+ * Core seeds the JSONL default as a protected floor; uses throw-on-duplicate
+ * `register` (NOT override) so a discovered plugin's store is added but never
+ * shadows the floor — the user must `setActive` it explicitly. A removed
+ * non-floor store reverts to the JSONL floor (never null).
+ */
+export class EventStoreRegistry extends ActiveDefRegistry<EventStoreDef> {
+  constructor() {
+    super({ noun: 'EventStore' });
+  }
+}

package/src/registries/modes.ts

@@ -55,6 +55,18 @@ export class ModeRegistry {
     return [...this.modes.values()];
   }
 
+  has(name: string): boolean {
+    return this.modes.has(name) || this.modes.has(migrateModeName(name));
+  }
+
+  /** Active mode name, or null when none is active. Mirrors ActiveDefRegistry
+   *  so the manifest apply loop + `categories()` surface can treat modes
+   *  uniformly. (`mode` has no protected-floor concept here — `mode-default`
+   *  is a critical package, so the default is protected at the package level.) */
+  getActiveName(): string | null {
+    return this.active;
+  }
+
   setActive(name: string): void {
     // Prefer the literal name; only when it isn't registered fall back to the
     // legacy-name map (e.g. a persisted "tool-use" → "default"). This never

package/src/registries/services.test.ts

@@ -0,0 +1,29 @@
+import { describe, expect, it } from 'vitest';
+import { ServiceRegistryImpl } from './services.js';
+
+describe('ServiceRegistryImpl', () => {
+  it('register / get / has round-trip', () => {
+    const r = new ServiceRegistryImpl();
+    expect(r.has('vault')).toBe(false);
+    expect(r.get('vault')).toBeUndefined();
+    const store = { secret: 1 };
+    r.register('vault', store);
+    expect(r.has('vault')).toBe(true);
+    expect(r.get('vault')).toBe(store);
+  });
+
+  it('require returns the service or throws with a helpful message', () => {
+    const r = new ServiceRegistryImpl();
+    expect(() => r.require('vault')).toThrow(/Required service not registered: vault/);
+    const store = { secret: 2 };
+    r.register('vault', store);
+    expect(r.require<typeof store>('vault')).toBe(store);
+  });
+
+  it('last write wins (a later plugin may replace a service)', () => {
+    const r = new ServiceRegistryImpl();
+    r.register('x', 1);
+    r.register('x', 2);
+    expect(r.get('x')).toBe(2);
+  });
+});

package/src/registries/services.ts

@@ -0,0 +1,33 @@
+import type { ServiceRegistry } from '@moxxy/sdk';
+
+/**
+ * In-process inter-plugin service registry (one per Session). A plugin publishes
+ * a named service in `onInit`; a sibling plugin resolves it in its own `onInit`.
+ * Last-write-wins on a duplicate name (a later plugin may intentionally replace
+ * a service); `require` throws when the name was never published.
+ */
+export class ServiceRegistryImpl implements ServiceRegistry {
+  private readonly services = new Map<string, unknown>();
+
+  register<T>(name: string, impl: T): void {
+    this.services.set(name, impl);
+  }
+
+  get<T>(name: string): T | undefined {
+    return this.services.get(name) as T | undefined;
+  }
+
+  require<T>(name: string): T {
+    if (!this.services.has(name)) {
+      throw new Error(
+        `Required service not registered: ${name}. The providing plugin's onInit ` +
+          'must run first — declare a moxxy.requirements entry on the consumer.',
+      );
+    }
+    return this.services.get(name) as T;
+  }
+
+  has(name: string): boolean {
+    return this.services.has(name);
+  }
+}

package/src/run-turn.ts

@@ -110,6 +110,7 @@ export async function* runTurn(
       turnId,
       cwd: appCtx.cwd,
       env: appCtx.env,
+      services: appCtx.services,
       model,
       systemPrompt: opts.systemPrompt,
       provider,
@@ -123,6 +124,7 @@ export async function* runTurn(
       // Reasoning preference (effort) — honored only by providers/models that
       // advertise `supportsReasoning` (gated in collectProviderStream).
       ...(session.reasoning ? { reasoning: session.reasoning } : {}),
+      ...(session.loopGuard ? { loopGuard: session.loopGuard } : {}),
       permissions: session.resolver,
       ...(session.approvalResolver ? { approval: session.approvalResolver } : {}),
       hooks: session.dispatcher,

package/src/session-runtime.ts

@@ -6,6 +6,7 @@ import type {
   ElisionSettings,
   HookDispatcher,
   LLMProvider,
+  LoopGuardSettings,
   ModeDef,
   PermissionResolver,
   PluginHostHandle,
@@ -59,6 +60,8 @@ export interface SessionRuntime {
   readonly lazyTools: boolean;
   /** Reasoning/thinking preference (effort), forwarded to each turn's ModeContext. */
   readonly reasoning?: { readonly effort?: 'low' | 'medium' | 'high' } | boolean | undefined;
+  /** Stuck-loop guard tuning, forwarded to each turn's ModeContext. */
+  readonly loopGuard?: LoopGuardSettings;
   readonly dispatcher: HookDispatcher;
   readonly pluginHost: PluginHostHandle;
   /**

package/src/session.ts

@@ -1,6 +1,8 @@
 import type {
   AppContext,
   ClientSession,
+  EmittedEvent,
+  LoopGuardSettings,
   MoxxyEvent,
   RunTurnOptions,
   SessionId,
@@ -32,10 +34,13 @@ import { SynthesizerRegistry } from './registries/synthesizers.js';
 import { EmbedderRegistry } from './registries/embedders.js';
 import { IsolatorRegistry } from './registries/isolators.js';
 import { WorkflowExecutorRegistry } from './registries/workflow-executors.js';
+import { EventStoreRegistry } from './registries/event-stores.js';
+import { ServiceRegistryImpl } from './registries/services.js';
+import { jsonlEventStore } from './sessions/jsonl-event-store.js';
 import { RequirementRegistry } from './requirements.js';
 import { PermissionEngine } from './permissions/engine.js';
 import { autoAllowResolver } from './permissions/resolvers.js';
-import { evaluateToolRule } from '@moxxy/sdk';
+import { evaluateToolRule, isSelectableMode } from '@moxxy/sdk';
 import type {
   ApprovalResolver,
   CredentialResolver,
@@ -129,6 +134,9 @@ export class Session implements ClientSession, SessionRuntime {
   readonly embedders: EmbedderRegistry;
   readonly isolators: IsolatorRegistry;
   readonly workflowExecutors: WorkflowExecutorRegistry;
+  readonly eventStores: EventStoreRegistry;
+  /** Inter-plugin service registry — plugins publish/consume services in onInit. */
+  readonly services: ServiceRegistryImpl;
   readonly requirements: RequirementRegistry;
   readonly permissions: PermissionEngine;
   /** Current PermissionResolver. Update via `setPermissionResolver(r)`. */
@@ -155,6 +163,12 @@ export class Session implements ClientSession, SessionRuntime {
    * when the active model advertises `supportsReasoning`. Undefined → off.
    */
   reasoning: { readonly effort?: 'low' | 'medium' | 'high' } | boolean | undefined = undefined;
+  /**
+   * Stuck-loop guard tuning, from `config.context.loopGuard`. Forwarded to each
+   * turn's ModeContext and on to the mode's stuck-loop detector. Undefined →
+   * the detector's defaults.
+   */
+  loopGuard: LoopGuardSettings | undefined = undefined;
   /**
    * Model id resolved by the most recent `runTurn()` (see SessionRuntime).
    * Last-writer-wins for concurrent turns; null until the first turn runs.
@@ -168,8 +182,6 @@ export class Session implements ClientSession, SessionRuntime {
    */
   readyProviders?: Set<string>;
   credentialResolver?: CredentialResolver;
-  mcpAdmin?: McpAdminView;
-  providerAdmin?: ProviderAdminView;
   workflows?: WorkflowsView;
   pluginsAdmin?: PluginsAdminView;
   readonly dispatcher: HookDispatcherImpl;
@@ -191,13 +203,15 @@ export class Session implements ClientSession, SessionRuntime {
     this.compactors = new CompactorRegistry();
     this.cacheStrategies = new CacheStrategyRegistry();
     this.viewRenderers = new ViewRendererRegistry();
-    // Seed the built-in renderer so `present_view` always has one to parse
-    // with; plugins can register/replace and `setActive` an alternative.
-    this.viewRenderers.register(defaultViewRenderer);
+    // Seed the built-in renderer as the protected floor so `present_view`
+    // always has one to parse with; plugins can register/replace and
+    // `setActive` an alternative, but it can never be removed (reverts here).
+    this.viewRenderers.register(defaultViewRenderer, { protected: true });
     this.tunnelProviders = new TunnelProviderRegistry();
-    // Seed the no-op localhost provider so the web surface always resolves a
-    // URL; plugins (the proxy relay) register/setActive a real tunnel.
-    this.tunnelProviders.register(localhostTunnel);
+    // Seed the no-op localhost provider as the protected floor so the web
+    // surface always resolves a URL; plugins (the proxy relay) register/
+    // setActive a real tunnel, reverting here if it's removed.
+    this.tunnelProviders.register(localhostTunnel, { protected: true });
     this.channels = new ChannelRegistryImpl();
     this.surfaceRegistry = new SurfaceRegistryImpl();
     this.surfaces = new SurfaceHostImpl(this.surfaceRegistry, { cwd: this.cwd, logger: this.logger }, this.logger);
@@ -211,6 +225,49 @@ export class Session implements ClientSession, SessionRuntime {
     this.embedders = new EmbedderRegistry();
     this.isolators = new IsolatorRegistry();
     this.workflowExecutors = new WorkflowExecutorRegistry();
+    this.services = new ServiceRegistryImpl();
+    // Publish the core registries on the inter-plugin service registry under
+    // well-known names, so a discovery-loaded plugin can resolve one in its
+    // onInit (typed as the SDK's minimal NamedRegistry) instead of being
+    // hand-built with a `() => session.<registry>` closure. The registry
+    // objects are stable; their contents grow as plugins register — consumers
+    // read them lazily at tool-call time, after all registration has run.
+    this.services.register('agents', this.agents);
+    this.services.register('tools', this.tools);
+    this.services.register('providers', this.providers);
+    this.services.register('viewRenderers', this.viewRenderers);
+    this.services.register('synthesizers', this.synthesizers);
+    this.services.register('skills', this.skills);
+    this.services.register('tunnelProviders', this.tunnelProviders);
+    // A stable accessor for the active provider's stored credentials. The
+    // resolver itself is installed late (by activateProvider, after plugins are
+    // built), so close over `this` and read it lazily at call time — lets
+    // provider-admin rebuild a reconfigured provider's instance without a
+    // host-injected `resolveActiveConfig` closure.
+    this.services.register(
+      'resolveCredentials',
+      (name: string): Promise<Record<string, unknown>> | Record<string, unknown> =>
+        this.credentialResolver ? this.credentialResolver(name) : {},
+    );
+    // A live registry-name snapshot (per kind) + a writable event-append fn, for
+    // plugins (self-update) that need them in onInit without a host closure.
+    // appendEvent is the writable counterpart to the read-only `ctx.log`.
+    this.services.register('registrySnapshot', () => ({
+      tools: this.tools.list().map((t) => t.name),
+      agents: this.agents.list().map((a) => a.name),
+      providers: this.providers.list().map((p) => p.name),
+      modes: this.modes.list().filter(isSelectableMode).map((m) => m.name),
+      compactors: this.compactors.list().map((c) => c.name),
+      channels: this.channels.list().map((c) => c.name),
+    }));
+    this.services.register(
+      'appendEvent',
+      (event: EmittedEvent): Promise<void> => this.log.append(event).then(() => undefined),
+    );
+    this.eventStores = new EventStoreRegistry();
+    // Seed the built-in JSONL store as the protected floor — the storage backend
+    // behind the event log always exists and can be swapped but never removed.
+    this.eventStores.register(jsonlEventStore, { protected: true });
     this.requirements = new RequirementRegistry({
       tools: this.tools,
       providers: this.providers,
@@ -257,12 +314,16 @@ export class Session implements ClientSession, SessionRuntime {
       embedders: this.embedders,
       isolators: this.isolators,
       workflowExecutors: this.workflowExecutors,
+      eventStores: this.eventStores,
       requirements: this.requirements,
       dispatcher: this.dispatcher,
       loader: opts.pluginLoader,
       ...(opts.pluginDiscoveryPaths ? { userPaths: opts.pluginDiscoveryPaths } : {}),
       ...(opts.isPluginDisabled ? { isDisabled: opts.isPluginDisabled } : {}),
     });
+    // Published after construction (the host is built late) so a discovery-loaded
+    // plugin (self-update) can reach reload/unload/listSkipped in its onInit.
+    this.services.register('pluginHost', this.pluginHost);
 
     // Fan every appended event out to plugin `onEvent` hooks. Without this
     // wiring the hook is dead code — declared on the SDK, dispatched by
@@ -367,6 +428,25 @@ export class Session implements ClientSession, SessionRuntime {
    */
   private envSnapshot: Readonly<NodeJS.ProcessEnv> | null = null;
 
+  /**
+   * The provider-admin capability (configure/refresh stored providers), read by
+   * the runner's provider handlers + the desktop. The @moxxy/plugin-provider-admin
+   * plugin publishes it on the service registry in its onInit, so discovery-loading
+   * it needs no host stash. (RemoteSession sets its own field for thin clients.)
+   */
+  get providerAdmin(): ProviderAdminView | undefined {
+    return this.services.get<ProviderAdminView>('providerAdmin');
+  }
+
+  /**
+   * The MCP-admin capability (enable/detach/list MCP servers), read by the
+   * runner's mcp handlers + the desktop. @moxxy/plugin-mcp publishes it on the
+   * service registry in its onInit. (RemoteSession sets its own field.)
+   */
+  get mcpAdmin(): McpAdminView | undefined {
+    return this.services.get<McpAdminView>('mcpAdmin');
+  }
+
   appContext(): AppContext {
     if (!this.envSnapshot) {
       this.envSnapshot = Object.freeze({ ...process.env });
@@ -376,6 +456,7 @@ export class Session implements ClientSession, SessionRuntime {
       cwd: this.cwd,
       log: this.log.asReader(),
       env: this.envSnapshot,
+      services: this.services,
     };
   }
 
@@ -435,7 +516,7 @@ export class Session implements ClientSession, SessionRuntime {
       })),
       activeMode,
       activeModeBadge,
-      modes: this.modes.list().map((m) => m.name),
+      modes: this.modes.list().filter(isSelectableMode).map((m) => m.name),
       tools: this.tools.list().map((t) => ({
         name: t.name,
         description: t.description,

package/src/sessions/jsonl-event-store.ts

@@ -0,0 +1,31 @@
+import type { EventStoreDef, EventStoreScope, EventStoreSession } from '@moxxy/sdk';
+import { SessionPersistence, readEventPage, restoreEvents } from './persistence.js';
+
+/**
+ * The built-in EventStore: per-session JSONL (`~/.moxxy/sessions/<id>.jsonl`) +
+ * a `.json` meta sidecar. A thin adapter over the battle-tested
+ * {@link SessionPersistence} (write) and `restoreEvents`/`readEventPage` (read)
+ * — zero behaviour change, just expressed behind the {@link EventStoreDef}
+ * contract. Core seeds this as the protected floor: a plugin can register an
+ * alternative store, but it never auto-activates (the user opts in by name via
+ * `plugins.eventStore.default`).
+ *
+ * `SessionPersistence` already exposes the full {@link EventStoreSession}
+ * surface (attach/flush/settleWrites/updateHeader/degraded), so `open` returns
+ * one directly.
+ */
+export const jsonlEventStore: EventStoreDef = {
+  name: 'jsonl',
+  open(scope: EventStoreScope): EventStoreSession {
+    return new SessionPersistence({
+      sessionId: scope.sessionId,
+      cwd: scope.cwd,
+      ...(scope.dir ? { dir: scope.dir } : {}),
+      ...(scope.providerName ? { providerName: scope.providerName } : {}),
+      ...(scope.modelId ? { modelId: scope.modelId } : {}),
+      ...(scope.source ? { source: scope.source } : {}),
+    });
+  },
+  restore: (sessionId, dir) => restoreEvents(sessionId, dir),
+  readPage: (sessionId, opts, dir) => readEventPage(sessionId, opts, dir),
+};

package/src/sessions/persistence.ts

@@ -19,59 +19,22 @@
 import { constants as fsConstants, promises as fs } from 'node:fs';
 import * as path from 'node:path';
 import { createMutex, type Mutex, type MoxxyEvent, type SessionId } from '@moxxy/sdk';
+import type { EventLogLike, EventPage, SessionMeta, SessionSource } from '@moxxy/sdk';
 import { moxxyPath, writeFileAtomic } from '@moxxy/sdk/server';
-import type { EventLog } from '../events/log.js';
 import { createLogger, type Logger } from '../logger.js';
 
-/**
- * The channel that originated a session. Persisted into the sidecar by the
- * runner so every surface (desktop/TUI/mobile) derives the session list from a
- * single source instead of each keeping its own copy. `desktop`/`mobile`
- * sessions are kept in the derived workspace list even before they have a first
- * prompt (a brand-new chat the user just opened); empty `cli`/`tui` sidecars are
- * dropped as noise.
- */
-export type SessionSource = 'cli' | 'tui' | 'desktop' | 'mobile';
+// `SessionSource`, `SessionMeta` and `EventPage` are the EventStore contract's
+// data shapes — defined in @moxxy/sdk so `EventStoreDef` can reference them.
+// Re-exported here (and onward from @moxxy/core) so existing importers are
+// unaffected by the move.
+export type { EventLogLike, EventPage, SessionMeta, SessionSource } from '@moxxy/sdk';
 
 /** Schema version of the per-session metadata file (`<id>.json`). Bump when the
  *  shape changes incompatibly; readers tolerate a missing/older version. */
 export const SESSION_META_VERSION = 1;
 
-/**
- * The single per-session metadata file: `~/.moxxy/sessions/<id>.json`.
- *
- * ONE file per session, the unit every surface (TUI/desktop/mobile) lists,
- * searches and caches. The conversation itself lives in the append-only
- * `<id>.jsonl`. Fields split by owner:
- *  - the RUNNER owns the content fields (`firstPrompt`, `eventCount`,
- *    `lastActivity`, `provider`, `model`, `startedAt`, `source`) and rewrites
- *    them on a debounce;
- *  - the UI owns `title` (a rename) and `groupId` (which desk it belongs to).
- * Because both write the same file, the runner ADOPTS the UI fields on attach
- * and re-merges them just before each write, so a live session never clobbers a
- * rename or a move.
- */
-export interface SessionMeta {
-  /** Schema version; absent on older files (treated as v0). */
-  readonly version?: number;
-  readonly id: string;
-  readonly cwd: string;
-  readonly startedAt: string;
-  readonly lastActivity: string;
-  readonly eventCount: number;
-  /** First 80 chars of the first user_prompt. The list/search label. */
-  readonly firstPrompt: string | null;
-  readonly provider: string | null;
-  readonly model: string | null;
-  /** Originating channel, when known. Written by the runner via `opts.source`. */
-  readonly source?: SessionSource;
-  /** Explicit workspace/desk membership (UI-owned). `null`/absent → grouped by
-   *  cwd containment (CLI/TUI sessions that don't know about desks). */
-  readonly groupId?: string | null;
-  /** User-set display name, the rename (UI-owned). `null`/absent → the name is
-   *  derived from `firstPrompt`. */
-  readonly title?: string | null;
-}
+// `SessionMeta` is defined in @moxxy/sdk (the EventStore contract's listing
+// shape) and re-exported above. The JSONL impl below reads/writes it.
 
 export interface SessionPersistenceOpts {
   readonly sessionId: SessionId;
@@ -216,7 +179,7 @@ export class SessionPersistence {
    * in the same (now empty) JSONL, matching how the in-memory log
    * reuses the same Session object.
    */
-  attach(log: EventLog): () => void {
+  attach(log: EventLogLike): () => void {
     void this.ensureReady()
       .then(() => this.scheduleIndexWrite())
       .catch(() => undefined);
@@ -679,18 +642,8 @@ export async function restoreEvents(
   return events;
 }
 
-/** One page of persisted events, newest-page-first paging (see
- *  {@link readEventPage}). */
-export interface EventPage {
-  /** The events in this page, in ascending `seq` order. */
-  readonly events: MoxxyEvent[];
-  /**
-   * Cursor to pass as `before` for the NEXT (older) page — the `seq` of the
-   * OLDEST event in this page. `null` once the start of history (the first
-   * persisted event) is included, signalling there is no older page.
-   */
-  readonly prevCursor: number | null;
-}
+// `EventPage` is defined in @moxxy/sdk (the EventStore read contract) and
+// re-exported above; `readEventPage`/`pageEvents` below produce it.
 
 /**
  * Read ONE page of a persisted session's events without re-materializing the

package/src/subagents/run-child.ts

@@ -447,6 +447,7 @@ function buildChildContext(
     turnId: childTurnId,
     cwd: parentAppCtx.cwd,
     env: parentAppCtx.env,
+    services: parentAppCtx.services,
     model,
     ...(spec.systemPrompt !== undefined ? { systemPrompt: spec.systemPrompt } : {}),
     provider: parentSession.providers.getActive(),
@@ -457,6 +458,7 @@ function buildChildContext(
     cacheStrategy: parentSession.cacheStrategies.getActive(),
     ...(parentSession.elisionSettings ? { elision: parentSession.elisionSettings } : {}),
     ...(parentSession.lazyTools ? { lazyTools: true } : {}),
+    ...(parentSession.loopGuard ? { loopGuard: parentSession.loopGuard } : {}),
     permissions: parentSession.resolver,
     // Intentionally no `approval` — fanning approval gates out to N
     // children in parallel would prompt the user N times. Strategies

package/dist/preferences.d.ts

@@ -1,40 +0,0 @@
-/**
- * User-level runtime preferences persisted at ~/.moxxy/preferences.json.
- * Distinct from `~/.moxxy/config.yaml` (user-edited, source of truth for
- * provider/plugin wiring) — this file is mutated by the TUI as the user
- * picks a model / loop strategy via slash commands, so it survives across
- * CLI invocations. A missing file or unreadable contents is a no-op:
- * preferences are best-effort, never load-blocking.
- */
-export interface MoxxyPreferences {
-    /** Active provider name (e.g. "openai", "anthropic"). */
-    readonly providerName?: string;
-    /** Active model id under that provider (e.g. "gpt-5.4-mini"). */
-    readonly model?: string;
-    /** Active loop strategy name (e.g. "default", "research", "goal"). */
-    readonly mode?: string;
-    /**
-     * Providers the user disabled (desktop Settings → Providers toggle).
-     * Seeded into the ProviderRegistry at boot; a listed provider stays
-     * registered but can't be activated until re-enabled.
-     */
-    readonly disabledProviders?: ReadonlyArray<string>;
-}
-export declare function preferencesPath(): string;
-/**
- * Read preferences from disk. Returns an empty object when the file
- * doesn't exist or fails to parse — preferences are an optional layer,
- * never a hard dependency of session bootstrap.
- */
-export declare function loadPreferences(): Promise<MoxxyPreferences>;
-/**
- * Merge-and-write preferences. Reads the current file (if any), merges
- * the patch on top so we don't blow away unrelated fields, and writes
- * the result back atomically. The whole read-merge-write runs inside a
- * module-level mutex so overlapping saves serialize (invariant #5) and
- * never lose an update. Best-effort: a write failure logs to stderr but
- * does not throw — the user's pick still takes effect in this session,
- * just won't persist across invocations.
- */
-export declare function savePreferences(patch: Partial<MoxxyPreferences>): Promise<void>;
-//# sourceMappingURL=preferences.d.ts.map

package/dist/preferences.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"preferences.d.ts","sourceRoot":"","sources":["../src/preferences.ts"],"names":[],"mappings":"AAIA;;;;;;;GAOG;AACH,MAAM,WAAW,gBAAgB;IAC/B,yDAAyD;IACzD,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAC/B,iEAAiE;IACjE,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,sEAAsE;IACtE,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB;;;;OAIG;IACH,QAAQ,CAAC,iBAAiB,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;CACpD;AAED,wBAAgB,eAAe,IAAI,MAAM,CAKxC;AAED;;;;GAIG;AACH,wBAAsB,eAAe,IAAI,OAAO,CAAC,gBAAgB,CAAC,CAYjE;AAUD;;;;;;;;GAQG;AACH,wBAAsB,eAAe,CAAC,KAAK,EAAE,OAAO,CAAC,gBAAgB,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAcrF"}

package/dist/preferences.js

@@ -1,59 +0,0 @@
-import { promises as fs } from 'node:fs';
-import { createMutex, migrateModeName } from '@moxxy/sdk';
-import { moxxyPath, writeFileAtomic } from '@moxxy/sdk/server';
-export function preferencesPath() {
-    // Route through `moxxyPath` so a `$MOXXY_HOME` override relocates preferences
-    // alongside the rest of the data dir (config.yaml, vault, providers.json, …).
-    // Identical to `~/.moxxy/preferences.json` when MOXXY_HOME is unset.
-    return moxxyPath('preferences.json');
-}
-/**
- * Read preferences from disk. Returns an empty object when the file
- * doesn't exist or fails to parse — preferences are an optional layer,
- * never a hard dependency of session bootstrap.
- */
-export async function loadPreferences() {
-    try {
-        const raw = await fs.readFile(preferencesPath(), 'utf8');
-        const parsed = JSON.parse(raw);
-        if (parsed && typeof parsed === 'object') {
-            const prefs = parsed;
-            return prefs.mode ? { ...prefs, mode: migrateModeName(prefs.mode) } : prefs;
-        }
-        return {};
-    }
-    catch {
-        return {};
-    }
-}
-// Serializes the read-modify-write in `savePreferences` so two concurrent
-// saves (e.g. a /model pick and a provider-disable toggle firing close
-// together) can't both read the same snapshot and have the second write
-// clobber the first's field. This is the single write path for the file —
-// other packages (CLI, runner, channels) route their fire-and-forget saves
-// through it, and any load-modify-save must go through it too.
-const writeMutex = createMutex();
-/**
- * Merge-and-write preferences. Reads the current file (if any), merges
- * the patch on top so we don't blow away unrelated fields, and writes
- * the result back atomically. The whole read-merge-write runs inside a
- * module-level mutex so overlapping saves serialize (invariant #5) and
- * never lose an update. Best-effort: a write failure logs to stderr but
- * does not throw — the user's pick still takes effect in this session,
- * just won't persist across invocations.
- */
-export async function savePreferences(patch) {
-    return writeMutex.run(async () => {
-        const current = await loadPreferences();
-        const next = { ...current, ...patch };
-        const target = preferencesPath();
-        try {
-            await writeFileAtomic(target, JSON.stringify(next, null, 2) + '\n');
-        }
-        catch (err) {
-            process.stderr.write(`moxxy: failed to persist preferences to ${target}: ` +
-                `${err instanceof Error ? err.message : String(err)}\n`);
-        }
-    });
-}
-//# sourceMappingURL=preferences.js.map

package/dist/preferences.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"preferences.js","sourceRoot":"","sources":["../src/preferences.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,IAAI,EAAE,EAAE,MAAM,SAAS,CAAC;AACzC,OAAO,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAC1D,OAAO,EAAE,SAAS,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAyB/D,MAAM,UAAU,eAAe;IAC7B,8EAA8E;IAC9E,8EAA8E;IAC9E,qEAAqE;IACrE,OAAO,SAAS,CAAC,kBAAkB,CAAC,CAAC;AACvC,CAAC;AAED;;;;GAIG;AACH,MAAM,CAAC,KAAK,UAAU,eAAe;IACnC,IAAI,CAAC;QACH,MAAM,GAAG,GAAG,MAAM,EAAE,CAAC,QAAQ,CAAC,eAAe,EAAE,EAAE,MAAM,CAAC,CAAC;QACzD,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAY,CAAC;QAC1C,IAAI,MAAM,IAAI,OAAO,MAAM,KAAK,QAAQ,EAAE,CAAC;YACzC,MAAM,KAAK,GAAG,MAA0B,CAAC;YACzC,OAAO,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,GAAG,KAAK,EAAE,IAAI,EAAE,eAAe,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC;QAC9E,CAAC;QACD,OAAO,EAAE,CAAC;IACZ,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,EAAE,CAAC;IACZ,CAAC;AACH,CAAC;AAED,0EAA0E;AAC1E,uEAAuE;AACvE,wEAAwE;AACxE,0EAA0E;AAC1E,2EAA2E;AAC3E,+DAA+D;AAC/D,MAAM,UAAU,GAAG,WAAW,EAAE,CAAC;AAEjC;;;;;;;;GAQG;AACH,MAAM,CAAC,KAAK,UAAU,eAAe,CAAC,KAAgC;IACpE,OAAO,UAAU,CAAC,GAAG,CAAC,KAAK,IAAI,EAAE;QAC/B,MAAM,OAAO,GAAG,MAAM,eAAe,EAAE,CAAC;QACxC,MAAM,IAAI,GAAqB,EAAE,GAAG,OAAO,EAAE,GAAG,KAAK,EAAE,CAAC;QACxD,MAAM,MAAM,GAAG,eAAe,EAAE,CAAC;QACjC,IAAI,CAAC;YACH,MAAM,eAAe,CAAC,MAAM,EAAE,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC;QACtE,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,OAAO,CAAC,MAAM,CAAC,KAAK,CAClB,2CAA2C,MAAM,IAAI;gBACnD,GAAG,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,CAC1D,CAAC;QACJ,CAAC;IACH,CAAC,CAAC,CAAC;AACL,CAAC"}