@moxxy/core 0.3.0

package/src/registries/transcribers.ts

@@ -0,0 +1,19 @@
+import type { Transcriber, TranscriberDef } from '@moxxy/sdk';
+import { ActiveBackendRegistry } from './active-backend-registry.js';
+
+/**
+ * Registry of speech-to-text backends:
+ *   - plugins call `register(def)` at load time
+ *   - the host/CLI calls `setActive(name, config)` once a backend is chosen
+ *   - channels with audio input read `getActive()` to transcribe bytes
+ *
+ * At most one transcriber is *active* at a time, selected explicitly (no
+ * auto-adopt). `getActive()` throws when none is active, so call sites can
+ * degrade gracefully (e.g. Telegram falls back to "you sent a voice note but no
+ * transcriber is configured").
+ */
+export class TranscriberRegistry extends ActiveBackendRegistry<TranscriberDef, Transcriber> {
+  constructor() {
+    super({ noun: 'Transcriber', build: (def, config) => def.createClient(config) });
+  }
+}

package/src/registries/tunnel-providers.test.ts

@@ -0,0 +1,30 @@
+import { describe, expect, it } from 'vitest';
+import type { TunnelProviderDef } from '@moxxy/sdk';
+import { TunnelProviderRegistry } from './tunnel-providers.js';
+
+const mk = (name: string): TunnelProviderDef => ({
+  name,
+  open: () => Promise.resolve({ url: `http://${name}`, close: () => Promise.resolve() }),
+});
+
+describe('TunnelProviderRegistry', () => {
+  it('auto-activates first; duplicate throws', () => {
+    const r = new TunnelProviderRegistry();
+    expect(r.getActive()).toBeNull();
+    r.register(mk('localhost'));
+    expect(r.getActive()?.name).toBe('localhost');
+    expect(() => r.register(mk('localhost'))).toThrow(/already registered/);
+  });
+
+  it('replace + setActive + unregister-clears-active behave like the other registries', () => {
+    const r = new TunnelProviderRegistry();
+    r.register(mk('localhost'));
+    r.replace(mk('cloudflared'));
+    r.setActive('cloudflared');
+    expect(r.getActive()?.name).toBe('cloudflared');
+    expect(() => r.setActive('ngrok')).toThrow(/not registered/);
+    r.unregister('cloudflared');
+    expect(r.getActive()).toBeNull();
+    expect(r.list().map((p) => p.name)).toEqual(['localhost']);
+  });
+});

package/src/registries/tunnel-providers.ts

@@ -0,0 +1,14 @@
+import type { TunnelProviderDef } from '@moxxy/sdk';
+import { ActiveDefRegistry } from './active-def-registry.js';
+
+/**
+ * One active tunnel provider per session. Register throws on duplicate,
+ * auto-activates the first, and `unregister` clears the active slot. Core
+ * seeds the `localhost` provider so `getActive()` is non-null even when no
+ * tunnel plugin is installed. See {@link ActiveDefRegistry}.
+ */
+export class TunnelProviderRegistry extends ActiveDefRegistry<TunnelProviderDef> {
+  constructor() {
+    super({ noun: 'Tunnel provider' });
+  }
+}

package/src/registries/view-renderers.test.ts

@@ -0,0 +1,68 @@
+import { describe, expect, it } from 'vitest';
+import type { ViewRendererDef } from '@moxxy/sdk';
+import { ViewRendererRegistry } from './view-renderers.js';
+
+const mk = (name: string): ViewRendererDef => ({
+  name,
+  allowList: [],
+  parse: () => ({ ok: false, errors: [{ message: name }] }),
+  validate: () => [],
+});
+
+describe('ViewRendererRegistry', () => {
+  it('auto-activates the first registered renderer', () => {
+    const r = new ViewRendererRegistry();
+    expect(r.getActive()).toBeNull();
+    r.register(mk('a'));
+    expect(r.getActive()?.name).toBe('a');
+    r.register(mk('b'));
+    expect(r.getActive()?.name).toBe('a'); // still the first
+  });
+
+  it('throws on duplicate register', () => {
+    const r = new ViewRendererRegistry();
+    r.register(mk('a'));
+    expect(() => r.register(mk('a'))).toThrow(/already registered/);
+  });
+
+  it('replace overwrites without throwing and keeps active', () => {
+    const r = new ViewRendererRegistry();
+    r.register(mk('a'));
+    const replacement = mk('a');
+    r.replace(replacement);
+    expect(r.getActive()).toBe(replacement);
+    expect(r.list()).toHaveLength(1);
+  });
+
+  it('replace on empty registry auto-activates', () => {
+    const r = new ViewRendererRegistry();
+    r.replace(mk('a'));
+    expect(r.getActive()?.name).toBe('a');
+  });
+
+  it('setActive switches; throws for unknown', () => {
+    const r = new ViewRendererRegistry();
+    r.register(mk('a'));
+    r.register(mk('b'));
+    r.setActive('b');
+    expect(r.getActive()?.name).toBe('b');
+    expect(() => r.setActive('nope')).toThrow(/not registered/);
+  });
+
+  it('unregister clears the active slot rather than picking a successor', () => {
+    const r = new ViewRendererRegistry();
+    r.register(mk('a'));
+    r.register(mk('b'));
+    r.unregister('a');
+    expect(r.getActive()).toBeNull();
+    expect(r.list().map((x) => x.name)).toEqual(['b']);
+  });
+
+  it('unregistering a non-active renderer leaves active intact', () => {
+    const r = new ViewRendererRegistry();
+    r.register(mk('a'));
+    r.register(mk('b'));
+    r.unregister('b');
+    expect(r.getActive()?.name).toBe('a');
+  });
+});

package/src/registries/view-renderers.ts

@@ -0,0 +1,15 @@
+import type { ViewRendererDef } from '@moxxy/sdk';
+import { ActiveDefRegistry } from './active-def-registry.js';
+
+/**
+ * One active view-spec renderer per session. Register throws on duplicate,
+ * auto-activates the first, and `unregister` clears the active slot rather
+ * than picking an arbitrary successor. Core seeds a default renderer so
+ * `getActive()` is non-null even with no plugins. See
+ * {@link ActiveDefRegistry}.
+ */
+export class ViewRendererRegistry extends ActiveDefRegistry<ViewRendererDef> {
+  constructor() {
+    super({ noun: 'View renderer' });
+  }
+}

package/src/registries/workflow-executors.test.ts

@@ -0,0 +1,53 @@
+import { describe, expect, it } from 'vitest';
+import type { WorkflowExecutorDef } from '@moxxy/sdk';
+import { WorkflowExecutorRegistry } from './workflow-executors.js';
+
+const mk = (name: string): WorkflowExecutorDef => ({
+  name,
+  run: async () => ({}) as never,
+});
+
+describe('WorkflowExecutorRegistry', () => {
+  it('auto-activates the first registered executor', () => {
+    const r = new WorkflowExecutorRegistry();
+    expect(r.getActive()).toBeNull();
+    r.register(mk('dag'));
+    expect(r.getActive()?.name).toBe('dag');
+    r.register(mk('linear'));
+    expect(r.getActive()?.name).toBe('dag'); // still the first
+  });
+
+  it('throws on duplicate register', () => {
+    const r = new WorkflowExecutorRegistry();
+    r.register(mk('dag'));
+    expect(() => r.register(mk('dag'))).toThrow(/already registered/);
+  });
+
+  it('replace overwrites without throwing and keeps active', () => {
+    const r = new WorkflowExecutorRegistry();
+    r.register(mk('dag'));
+    const replacement = mk('dag');
+    r.replace(replacement);
+    expect(r.getActive()).toBe(replacement);
+    expect(r.list()).toHaveLength(1);
+  });
+
+  it('setActive switches; throws for unknown', () => {
+    const r = new WorkflowExecutorRegistry();
+    r.register(mk('dag'));
+    r.register(mk('linear'));
+    r.setActive('linear');
+    expect(r.getActive()?.name).toBe('linear');
+    expect(() => r.setActive('nope')).toThrow(/not registered/);
+  });
+
+  it('unregister clears the active slot rather than picking a successor', () => {
+    const r = new WorkflowExecutorRegistry();
+    r.register(mk('dag'));
+    r.register(mk('linear'));
+    r.unregister('dag');
+    // getActive() returning null wrongly would silently disable workflows.
+    expect(r.getActive()).toBeNull();
+    expect(r.list().map((x) => x.name)).toEqual(['linear']);
+  });
+});

package/src/registries/workflow-executors.ts

@@ -0,0 +1,15 @@
+import type { WorkflowExecutorDef } from '@moxxy/sdk';
+import { ActiveDefRegistry } from './active-def-registry.js';
+
+/**
+ * Registry of swappable workflow-execution strategies. Register throws on
+ * duplicate, auto-activates the first registration (so a session always has
+ * an executor once `@moxxy/plugin-workflows` loads its default `dag`), and
+ * `unregister` clears the active slot rather than silently picking a
+ * successor. See {@link ActiveDefRegistry}.
+ */
+export class WorkflowExecutorRegistry extends ActiveDefRegistry<WorkflowExecutorDef> {
+  constructor() {
+    super({ noun: 'Workflow executor' });
+  }
+}

package/src/requirements.targetinfo.test.ts

@@ -0,0 +1,70 @@
+import { describe, expect, it } from 'vitest';
+import { requirementSchema, type RequirementKind } from '@moxxy/sdk';
+import { RequirementRegistry } from './requirements.js';
+import { ToolRegistryImpl } from './registries/tools.js';
+import { ProviderRegistry } from './registries/providers.js';
+import { ModeRegistry } from './registries/modes.js';
+import { CompactorRegistry } from './registries/compactors.js';
+import { ChannelRegistryImpl } from './registries/channels.js';
+import { AgentRegistry } from './registries/agents.js';
+import { CommandRegistry } from './registries/commands.js';
+import { TranscriberRegistry } from './registries/transcribers.js';
+import { SynthesizerRegistry } from './registries/synthesizers.js';
+import { silentLogger } from './logger.js';
+
+const makeRequirements = () =>
+  new RequirementRegistry({
+    tools: new ToolRegistryImpl({ logger: silentLogger, cwd: '/tmp' }),
+    providers: new ProviderRegistry(),
+    modes: new ModeRegistry(),
+    compactors: new CompactorRegistry(),
+    channels: new ChannelRegistryImpl(),
+    agents: new AgentRegistry(),
+    commands: new CommandRegistry(),
+    transcribers: new TranscriberRegistry(),
+    synthesizers: new SynthesizerRegistry(),
+  });
+
+// Drive the exhaustiveness sweep off the SDK's zod enum rather than a hand-kept
+// list, so a kind added to the union (and its schema) is automatically exercised
+// here. `targetInfo` is a table (TARGET_DESCRIPTORS) plus two special cases
+// (plugin/runtime); the `Record<Exclude<RequirementKind,'plugin'|'runtime'>,_>`
+// type already makes a missing table entry a compile error — this loop keeps the
+// runtime smoke honest alongside that guard.
+const ALL_KINDS: ReadonlyArray<RequirementKind> = requirementSchema.shape.kind.options;
+
+describe('RequirementRegistry.targetInfo exhaustiveness', () => {
+  it('exercises every RequirementKind in the zod enum', () => {
+    // Sanity: the enum still spells out the full known set (catches an enum that
+    // accidentally shrank). Order-independent.
+    expect([...ALL_KINDS].sort()).toEqual(
+      [
+        'agent',
+        'channel',
+        'command',
+        'compactor',
+        'mode',
+        'plugin',
+        'provider',
+        'runtime',
+        'synthesizer',
+        'tool',
+        'transcriber',
+      ].sort(),
+    );
+  });
+
+  it('resolves a check (never throws) for every RequirementKind', () => {
+    const requirements = makeRequirements();
+    for (const kind of ALL_KINDS) {
+      // Routed through the public `check` API since targetInfo is private.
+      // With nothing registered every kind reports a defined, blocking issue
+      // (missing / not_ready) rather than hitting the assertNever default — i.e.
+      // every kind has a table entry or special case backing it.
+      const check = requirements.check([{ kind, name: `nonexistent-${kind}` }]);
+      expect(check).toBeDefined();
+      expect(check.issues).toHaveLength(1);
+      expect(check.issues[0]?.requirement.kind).toBe(kind);
+    }
+  });
+});

package/src/requirements.test.ts

@@ -0,0 +1,111 @@
+import { describe, expect, it } from 'vitest';
+import { defineProvider, defineTranscriber } from '@moxxy/sdk';
+import { RequirementRegistry } from './requirements.js';
+import { ToolRegistryImpl } from './registries/tools.js';
+import { ProviderRegistry } from './registries/providers.js';
+import { ModeRegistry } from './registries/modes.js';
+import { CompactorRegistry } from './registries/compactors.js';
+import { ChannelRegistryImpl } from './registries/channels.js';
+import { AgentRegistry } from './registries/agents.js';
+import { CommandRegistry } from './registries/commands.js';
+import { TranscriberRegistry } from './registries/transcribers.js';
+import { silentLogger } from './logger.js';
+
+const makeRequirements = () => {
+  const tools = new ToolRegistryImpl({ logger: silentLogger, cwd: '/tmp' });
+  const providers = new ProviderRegistry();
+  const modes = new ModeRegistry();
+  const compactors = new CompactorRegistry();
+  const channels = new ChannelRegistryImpl();
+  const agents = new AgentRegistry();
+  const commands = new CommandRegistry();
+  const transcribers = new TranscriberRegistry();
+  const requirements = new RequirementRegistry({
+    tools,
+    providers,
+    modes,
+    compactors,
+    channels,
+    agents,
+    commands,
+    transcribers,
+  });
+  return { requirements, tools, providers, modes, compactors, transcribers };
+};
+
+describe('RequirementRegistry', () => {
+  it('reports missing registered requirements', () => {
+    const { requirements } = makeRequirements();
+
+    const check = requirements.check([{ kind: 'tool', name: 'web_fetch' }]);
+
+    expect(check).toMatchObject({
+      ready: false,
+      issues: [{ code: 'missing', message: 'Required tool is not registered: web_fetch' }],
+    });
+  });
+
+  it('reports inactive providers when active state is required', () => {
+    const { requirements, providers } = makeRequirements();
+    providers.register(
+      defineProvider({
+        name: 'openai-codex',
+        models: [],
+        createClient: () => ({ name: 'openai-codex', models: [], stream: async function* () {}, countTokens: async () => 0 }),
+      }),
+    );
+
+    const check = requirements.check([{ kind: 'provider', name: 'openai-codex', state: 'active' }]);
+
+    expect(check.ready).toBe(false);
+    expect(check.issues[0]).toMatchObject({
+      code: 'inactive',
+      message: 'Required provider is not active: openai-codex',
+    });
+  });
+
+  it('reports runtime requirements until they are marked ready', () => {
+    const { requirements } = makeRequirements();
+    const req = { kind: 'runtime' as const, name: 'auth:provider:openai-codex', state: 'ready' as const };
+
+    expect(requirements.check([req])).toMatchObject({
+      ready: false,
+      issues: [{ code: 'not_ready' }],
+    });
+
+    requirements.setRuntime('auth:provider:openai-codex', 'ready');
+
+    expect(requirements.check([req])).toEqual({ ready: true, issues: [] });
+  });
+
+  it('keeps optional requirements as diagnostics without blocking readiness', () => {
+    const { requirements } = makeRequirements();
+
+    const check = requirements.check([{ kind: 'runtime', name: 'browser:installed', state: 'ready', optional: true }]);
+
+    expect(check.ready).toBe(true);
+    expect(check.issues[0]).toMatchObject({ code: 'not_ready' });
+  });
+
+  it('isReady checks a single named target without composing per-def requirements', () => {
+    const { requirements, transcribers } = makeRequirements();
+    transcribers.register(
+      defineTranscriber({
+        name: 'openai-codex-transcribe',
+        createClient: () => ({ name: 'openai-codex-transcribe', transcribe: async () => ({ text: 'ok' }) }),
+      }),
+    );
+
+    expect(requirements.isReady('transcriber', 'openai-codex-transcribe')).toMatchObject({
+      ready: false,
+      issues: [{ code: 'inactive' }],
+    });
+
+    transcribers.setActive('openai-codex-transcribe');
+
+    expect(requirements.isReady('transcriber', 'openai-codex-transcribe')).toEqual({
+      ready: true,
+      issues: [],
+    });
+  });
+});

package/src/requirements.ts

@@ -0,0 +1,262 @@
+import type {
+  MoxxyRequirement,
+  RequirementCheck,
+  RequirementIssue,
+  RequirementKind,
+  RequirementState,
+  AgentDef,
+  ChannelDef,
+  CommandDef,
+  CompactorDef,
+  ModeDef,
+  ProviderDef,
+  ToolDef,
+  TranscriberDef,
+  SynthesizerDef,
+} from '@moxxy/sdk';
+
+export interface RequirementChecker {
+  check(requirements: ReadonlyArray<MoxxyRequirement> | undefined): RequirementCheck;
+}
+
+export interface RequirementRegistryOptions {
+  readonly tools: {
+    get(name: string): ToolDef | undefined;
+  };
+  readonly providers: {
+    list(): ReadonlyArray<ProviderDef>;
+    getActiveName(): string | null;
+  };
+  readonly modes: {
+    list(): ReadonlyArray<ModeDef>;
+    getActive(): ModeDef;
+  };
+  readonly compactors: {
+    list(): ReadonlyArray<CompactorDef>;
+    getActive(): CompactorDef | null;
+  };
+  readonly channels: {
+    get(name: string): ChannelDef | undefined;
+  };
+  readonly agents: {
+    get(name: string): AgentDef | undefined;
+  };
+  readonly commands: {
+    get(name: string): CommandDef | undefined;
+  };
+  readonly transcribers: {
+    list(): ReadonlyArray<TranscriberDef>;
+    getActiveName(): string | null;
+  };
+  readonly synthesizers: {
+    list(): ReadonlyArray<SynthesizerDef>;
+    getActiveName(): string | null;
+  };
+}
+
+interface RegisteredPlugin {
+  readonly name: string;
+  readonly version: string;
+}
+
+interface TargetInfo {
+  readonly kind: RequirementKind;
+  readonly name: string;
+  readonly version?: string;
+  readonly active: boolean;
+}
+
+/**
+ * Per-kind recipe for {@link RequirementRegistry.targetInfo}. Every kind that
+ * resolves against a registry on `opts` differs only in two orthogonal aspects,
+ * so we table them rather than repeat the same `lookup -> {kind,name,active}`
+ * shape once per case:
+ *   - `present`  — does a def by this name exist? (`registry.get` or
+ *                  `list().some`, depending on the registry base)
+ *   - `active`   — is this the currently-active one? (a `getActiveName() === name`
+ *                  / `getActive()?.name === name` check, or always-true for kinds
+ *                  with no active/inactive distinction like tool/channel/agent)
+ *
+ * None of these kinds track a version (only `plugin` does, and it is
+ * special-cased — see {@link RequirementRegistry.targetInfo}), so a `version`
+ * aspect is deliberately omitted here. `runtime` is handled by `checkRuntime`
+ * before `targetInfo` is reached and so also has no descriptor.
+ */
+interface TargetDescriptor {
+  /** Whether a def with `name` is registered for this kind. */
+  readonly present: (opts: RequirementRegistryOptions, name: string) => boolean;
+  /** Whether the registered def is the currently-active one. */
+  readonly active: (opts: RequirementRegistryOptions, name: string) => boolean;
+}
+
+/** Active for kinds with no active/inactive distinction (tool/channel/agent/command). */
+const ALWAYS_ACTIVE = (): true => true;
+
+export class RequirementRegistry {
+  private readonly runtime = new Map<string, RequirementState>();
+  private readonly plugins = new Map<string, RegisteredPlugin>();
+
+  constructor(private readonly opts: RequirementRegistryOptions) {}
+
+  registerPlugin(name: string, version: string): void {
+    this.plugins.set(name, { name, version });
+  }
+
+  unregisterPlugin(name: string): void {
+    this.plugins.delete(name);
+  }
+
+  setRuntime(name: string, state: RequirementState = 'ready'): void {
+    this.runtime.set(name, state);
+  }
+
+  clearRuntime(name: string): void {
+    this.runtime.delete(name);
+  }
+
+  check(requirements: ReadonlyArray<MoxxyRequirement> | undefined): RequirementCheck {
+    const issues: RequirementIssue[] = [];
+    for (const requirement of requirements ?? []) {
+      const issue = this.checkOne(requirement);
+      if (issue) issues.push(issue);
+    }
+    const blocking = issues.filter((issue) => !issue.requirement.optional);
+    return { ready: blocking.length === 0, issues };
+  }
+
+  /**
+   * Convenience: check whether a single named target is present and (if
+   * its kind has an active/inactive distinction) currently active.
+   * Equivalent to `check([{ kind, name, state: 'active' }])`.
+   */
+  isReady(kind: RequirementKind, name: string): RequirementCheck {
+    return this.check([{ kind, name, state: 'active' }]);
+  }
+
+  private checkOne(requirement: MoxxyRequirement): RequirementIssue | null {
+    if (requirement.kind === 'runtime') return this.checkRuntime(requirement);
+
+    const target = this.targetInfo(requirement.kind, requirement.name);
+    if (!target) {
+      return issue(requirement, 'missing', `Required ${label(requirement.kind)} is not registered: ${requirement.name}`);
+    }
+
+    if (requirement.version && target.version !== requirement.version) {
+      return issue(
+        requirement,
+        'version_mismatch',
+        `Required ${label(requirement.kind)} has version ${target.version ?? '(unknown)'}, expected ${requirement.version}: ${requirement.name}`,
+      );
+    }
+
+    const state = requirement.state ?? 'registered';
+    if ((state === 'active' || state === 'ready') && !target.active) {
+      return issue(requirement, 'inactive', `Required ${label(requirement.kind)} is not active: ${requirement.name}`);
+    }
+
+    return null;
+  }
+
+  private checkRuntime(requirement: MoxxyRequirement): RequirementIssue | null {
+    const state = requirement.state ?? 'ready';
+    const actual = this.runtime.get(requirement.name);
+    if (actual !== state) {
+      return issue(requirement, 'not_ready', `Required runtime is not ready: ${requirement.name}`);
+    }
+    return null;
+  }
+
+  private targetInfo(kind: RequirementKind, name: string): TargetInfo | null {
+    // `plugin` resolves against this instance's private registration map (not a
+    // registry on `opts`) and is the only kind carrying a version, so it stays a
+    // special case rather than being contorted into the shared table.
+    if (kind === 'plugin') {
+      const plugin = this.plugins.get(name);
+      return plugin ? { kind, name, version: plugin.version, active: true } : null;
+    }
+    // `runtime` never reaches here — `checkOne` routes it to `checkRuntime` first.
+    if (kind === 'runtime') return null;
+
+    // Every remaining kind has a table entry: `TARGET_DESCRIPTORS` is a total
+    // `Record` over `Exclude<RequirementKind, 'plugin' | 'runtime'>`, so a kind
+    // added to the union without an entry is a compile error (the table-driven
+    // replacement for the old switch's `assertNever` default).
+    const descriptor = TARGET_DESCRIPTORS[kind];
+    if (!descriptor.present(this.opts, name)) return null;
+    return { kind, name, active: descriptor.active(this.opts, name) };
+  }
+}
+
+/**
+ * Lookup table backing {@link RequirementRegistry.targetInfo} for every
+ * registry-backed {@link RequirementKind}. `plugin` (private map + version) and
+ * `runtime` (handled before `targetInfo`) are intentionally absent and dealt
+ * with as special cases; the `Partial`-free `Record` keyed on the remaining
+ * kinds keeps the set exhaustive (a new kind is a compile error until listed).
+ */
+const TARGET_DESCRIPTORS: Record<
+  Exclude<RequirementKind, 'plugin' | 'runtime'>,
+  TargetDescriptor
+> = {
+  provider: {
+    present: (opts, name) => opts.providers.list().some((p) => p.name === name),
+    active: (opts, name) => opts.providers.getActiveName() === name,
+  },
+  tool: {
+    present: (opts, name) => opts.tools.get(name) !== undefined,
+    active: ALWAYS_ACTIVE,
+  },
+  transcriber: {
+    present: (opts, name) => opts.transcribers.list().some((t) => t.name === name),
+    active: (opts, name) => opts.transcribers.getActiveName() === name,
+  },
+  synthesizer: {
+    present: (opts, name) => opts.synthesizers.list().some((s) => s.name === name),
+    active: (opts, name) => opts.synthesizers.getActiveName() === name,
+  },
+  mode: {
+    present: (opts, name) => opts.modes.list().some((m) => m.name === name),
+    active: (opts, name) => activeModeName(opts.modes) === name,
+  },
+  compactor: {
+    present: (opts, name) => opts.compactors.list().some((c) => c.name === name),
+    active: (opts, name) => opts.compactors.getActive()?.name === name,
+  },
+  channel: {
+    present: (opts, name) => opts.channels.get(name) !== undefined,
+    active: ALWAYS_ACTIVE,
+  },
+  agent: {
+    present: (opts, name) => opts.agents.get(name) !== undefined,
+    active: ALWAYS_ACTIVE,
+  },
+  command: {
+    present: (opts, name) => opts.commands.get(name) !== undefined,
+    active: ALWAYS_ACTIVE,
+  },
+};
+
+function issue(
+  requirement: MoxxyRequirement,
+  code: RequirementIssue['code'],
+  message: string,
+): RequirementIssue {
+  return {
+    requirement,
+    code,
+    message,
+    ...(requirement.hint ? { hint: requirement.hint } : {}),
+  };
+}
+
+function label(kind: RequirementKind): string {
+  return kind;
+}
+
+function activeModeName(modes: RequirementRegistryOptions['modes']): string | null {
+  try {
+    return modes.getActive().name;
+  } catch {
+    return null;
+  }
+}