@celilo/cli 0.3.0 → 0.3.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@celilo/cli",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "description": "Celilo — home lab orchestration CLI",
   "type": "module",
   "bin": {

package/src/cli/commands/events.test.ts

@@ -22,10 +22,10 @@ describe('celilo events command handlers', () => {
   beforeEach(() => {
     dir = mkdtempSync(join(tmpdir(), 'events-cmd-test-'));
     dbPath = join(dir, 'events.db');
-    process.env.CELILO_EVENT_BUS_PATH = dbPath;
+    process.env.EVENT_BUS_DB = dbPath;
   });
   afterEach(() => {
-    process.env.CELILO_EVENT_BUS_PATH = undefined;
+    process.env.EVENT_BUS_DB = undefined;
     try {
       rmSync(dir, { recursive: true, force: true });
     } catch {

package/src/config/paths.ts

@@ -96,7 +96,8 @@ export function getDbPath(): string {
  * Get the SQLite event-bus database file path.
  *
  * Priority:
- * 1. CELILO_EVENT_BUS_PATH environment variable (explicit override)
+ * 1. EVENT_BUS_DB environment variable (the bus library's native name —
+ *    used by the event-bus CLI, defineHandler, and any standalone tool)
  * 2. <data-dir>/events.db (platform-specific)
  *
  * Kept separate from the main celilo.db so the bus library remains
@@ -105,8 +106,8 @@ export function getDbPath(): string {
  * @returns Absolute path to event-bus database
  */
 export function getEventBusPath(): string {
-  if (process.env.CELILO_EVENT_BUS_PATH) {
-    return process.env.CELILO_EVENT_BUS_PATH;
+  if (process.env.EVENT_BUS_DB) {
+    return process.env.EVENT_BUS_DB;
   }
   return join(getDataDir(), 'events.db');
 }

package/src/module/import.ts

@@ -23,6 +23,25 @@ import {
 import { parseJsonWithValidation } from '../validation/schemas';
 import { cleanupTempDir, extractPackage, verifyPackageIntegrity } from './packaging/extract';
 
+/**
+ * Phase-timing helper for `celilo module import`. Set CELILO_IMPORT_DEBUG=1
+ * to get a phase-by-phase breakdown to stderr — useful when an import is
+ * inexplicably slow (e.g. a Docker bind-mount fsync amplification, a stale
+ * lockfile triggering a fresh bun install, etc.).
+ *
+ * Zero overhead when disabled: the wrapper just calls the inner fn.
+ */
+async function timedPhase<T>(label: string, fn: () => Promise<T> | T): Promise<T> {
+  if (!process.env.CELILO_IMPORT_DEBUG) return await fn();
+  const start = Date.now();
+  try {
+    return await fn();
+  } finally {
+    const ms = Date.now() - start;
+    process.stderr.write(`[import-timing] ${label.padEnd(36)} ${ms}ms\n`);
+  }
+}
+
 /**
  * Module import options
  */
@@ -547,7 +566,7 @@ export async function importModule(options: ModuleImportOptions): Promise<Module
 
     // Execution: Copy files
     try {
-      await copyModuleFiles(actualSourcePath, targetPath);
+      await timedPhase('copyModuleFiles', () => copyModuleFiles(actualSourcePath, targetPath));
     } catch (error) {
       if (tempDir) await cleanupTempDir(tempDir);
       return {
@@ -563,7 +582,9 @@ export async function importModule(options: ModuleImportOptions): Promise<Module
     // If no package.json exists but hook scripts do, auto-generate one with
     // just the framework dep — smooths migration for existing modules.
     try {
-      await installScriptDependencies(targetPath, manifest);
+      await timedPhase('installScriptDependencies', () =>
+        installScriptDependencies(targetPath, manifest),
+      );
     } catch (error) {
       // Non-fatal: the module is importable without deps, but hooks
       // will fail at runtime. Warn and continue.
@@ -574,7 +595,7 @@ export async function importModule(options: ModuleImportOptions): Promise<Module
 
     // Execution: Insert to database
     try {
-      await insertModuleToDb(manifest, targetPath, db);
+      await timedPhase('insertModuleToDb', () => insertModuleToDb(manifest, targetPath, db));
     } catch (error) {
       if (tempDir) await cleanupTempDir(tempDir);
       return {
@@ -586,8 +607,10 @@ export async function importModule(options: ModuleImportOptions): Promise<Module
 
     // Execution: Register capabilities if module provides them
     if (manifest.provides?.capabilities && manifest.provides.capabilities.length > 0) {
-      const { registerModuleCapabilities } = await import('../capabilities/registration');
-      const capResult = await registerModuleCapabilities(manifest.id, manifest, db.$client, flags);
+      const capResult = await timedPhase('registerModuleCapabilities', async () => {
+        const { registerModuleCapabilities } = await import('../capabilities/registration');
+        return registerModuleCapabilities(manifest.id, manifest, db.$client, flags);
+      });
 
       if (!capResult.success) {
         if (tempDir) await cleanupTempDir(tempDir);
@@ -604,8 +627,10 @@ export async function importModule(options: ModuleImportOptions): Promise<Module
     // can re-run the import after fixing the bus, and bus.subscribe is
     // idempotent.
     try {
-      const { registerModuleSubscriptions } = await import('../services/module-subscriptions');
-      registerModuleSubscriptions(manifest, targetPath);
+      await timedPhase('registerModuleSubscriptions', async () => {
+        const { registerModuleSubscriptions } = await import('../services/module-subscriptions');
+        registerModuleSubscriptions(manifest, targetPath);
+      });
     } catch (error) {
       const msg = error instanceof Error ? error.message : String(error);
       log.warn(`Failed to register event-bus subscriptions: ${msg}`);

package/src/services/bus-interview.test.ts

@@ -0,0 +1,134 @@
+import { afterEach, beforeEach, describe, expect, it } from 'bun:test';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { defineEvents, openBus } from '@celilo/event-bus';
+import {
+  type ConfigReply,
+  type ConfigRequiredPayload,
+  EVENT_TYPES,
+  busInterview,
+} from './bus-interview';
+
+const NO_SCHEMAS = defineEvents({});
+
+describe('busInterview', () => {
+  let dir: string;
+  let dbPath: string;
+  let origEnv: string | undefined;
+
+  beforeEach(() => {
+    dir = mkdtempSync(join(tmpdir(), 'bus-interview-test-'));
+    dbPath = join(dir, 'events.db');
+    origEnv = process.env.EVENT_BUS_DB;
+    process.env.EVENT_BUS_DB = dbPath;
+  });
+  afterEach(() => {
+    if (origEnv === undefined) process.env.EVENT_BUS_DB = undefined;
+    else process.env.EVENT_BUS_DB = origEnv;
+    try {
+      rmSync(dir, { recursive: true, force: true });
+    } catch {
+      /* ignore */
+    }
+  });
+
+  it('emits a query and returns the responder reply', async () => {
+    // Stand up a responder in a separate Bus instance against the same
+    // DB. The deploy's busInterview opens its own short-lived Bus and
+    // queries; the responder's Bus emits the reply. The cross-process
+    // poll inside bus.query is what makes this work.
+    const responderBus = openBus({ dbPath, events: NO_SCHEMAS });
+    const watch = responderBus.watch('config.required.lunacycle.domain', (event) => {
+      responderBus.emitRaw(
+        `${event.type}.reply`,
+        { value: 'lunacycle.net' },
+        { replyFor: event.id, emittedBy: 'test-responder' },
+      );
+    });
+
+    const payload: ConfigRequiredPayload = {
+      module: 'lunacycle',
+      key: 'domain',
+      type: 'string',
+      required: true,
+    };
+    const reply = await busInterview<ConfigReply>(
+      EVENT_TYPES.configRequired('lunacycle', 'domain'),
+      payload,
+    );
+
+    expect(reply.value).toBe('lunacycle.net');
+
+    watch.close();
+    responderBus.close();
+  });
+
+  it('honors first-reply-wins when multiple responders compete', async () => {
+    const fastResponder = openBus({ dbPath, events: NO_SCHEMAS });
+    const slowResponder = openBus({ dbPath, events: NO_SCHEMAS });
+
+    fastResponder.watch('config.required.foo.bar', (event) => {
+      fastResponder.emitRaw(
+        `${event.type}.reply`,
+        { value: 'fast' },
+        { replyFor: event.id, emittedBy: 'fast' },
+      );
+    });
+    slowResponder.watch('config.required.foo.bar', (event) => {
+      // Reply after a delay; the fast responder should win.
+      setTimeout(() => {
+        slowResponder.emitRaw(
+          `${event.type}.reply`,
+          { value: 'slow' },
+          { replyFor: event.id, emittedBy: 'slow' },
+        );
+      }, 200);
+    });
+
+    const reply = await busInterview<ConfigReply>(EVENT_TYPES.configRequired('foo', 'bar'), {
+      module: 'foo',
+      key: 'bar',
+      type: 'string',
+      required: true,
+    });
+    expect(reply.value).toBe('fast');
+
+    fastResponder.close();
+    slowResponder.close();
+  });
+
+  it('uses the existing Bus instance when one is passed in', async () => {
+    const sharedBus = openBus({ dbPath, events: NO_SCHEMAS });
+    sharedBus.watch('config.required.shared.x', (event) => {
+      sharedBus.emitRaw(
+        `${event.type}.reply`,
+        { value: 'shared' },
+        { replyFor: event.id, emittedBy: 'in-process' },
+      );
+    });
+
+    const reply = await busInterview<ConfigReply>(
+      EVENT_TYPES.configRequired('shared', 'x'),
+      { module: 'shared', key: 'x', type: 'string', required: true },
+      sharedBus,
+    );
+    expect(reply.value).toBe('shared');
+
+    sharedBus.close();
+  });
+});
+
+describe('EVENT_TYPES', () => {
+  it('builds dotted event names for each interview shape', () => {
+    expect(EVENT_TYPES.configRequired('lunacycle', 'domain')).toBe(
+      'config.required.lunacycle.domain',
+    );
+    expect(EVENT_TYPES.secretRequired('authentik', 'admin_password')).toBe(
+      'secret.required.authentik.admin_password',
+    );
+    expect(EVENT_TYPES.ensureRequired('namecheap', 'add_domain')).toBe(
+      'ensure.required.namecheap.add_domain',
+    );
+  });
+});

package/src/services/bus-interview.ts

@@ -0,0 +1,141 @@
+/**
+ * Bus-mediated deploy interview. Replaces the terminal-only prompt
+ * sites in `config-interview.ts` with `<bus-event-emit>` → wait for
+ * a responder's reply. Responders include the terminal (when stdin
+ * is a TTY), the `cele2e events respond` CLI, the Claude
+ * `celilo-config-responder` subagent, etc.
+ *
+ * No timeouts: the deploy waits indefinitely for a responder. If
+ * nothing answers, the operator sees the unanswered query via
+ * `celilo events list-pending` and fixes the responder setup.
+ *
+ * See `infra/design/INTERACTIVE_DEPLOYS_VIA_BUS.md`.
+ */
+
+import { type Bus, defineEvents, openBus } from '@celilo/event-bus';
+import { getEventBusPath } from '../config/paths';
+
+const NO_SCHEMAS = defineEvents({});
+
+export const EVENT_TYPES = {
+  configRequired: (module: string, key: string) => `config.required.${module}.${key}`,
+  secretRequired: (module: string, key: string) => `secret.required.${module}.${key}`,
+  ensureRequired: (provider: string, ensureId: string) => `ensure.required.${provider}.${ensureId}`,
+} as const;
+
+/**
+ * Payload for `config.required.<module>.<key>`. The deploy emits this
+ * when a non-secret variable is missing AND has no default to fall
+ * back on (defaults are applied at variable-resolution time before
+ * the missing-config check fires, so by the time we get here, no
+ * default exists).
+ */
+export interface ConfigRequiredPayload {
+  module: string;
+  key: string;
+  type: 'string' | 'integer' | 'number' | 'boolean' | 'array' | 'object';
+  required: boolean;
+  description?: string;
+  pattern?: string;
+  options?: Array<{ value: string; label: string; hint?: string }>;
+  /**
+   * Set on re-emits after a previous reply failed validation. The
+   * responder sees the prior error message and presumably does
+   * better the next round.
+   */
+  previousError?: string;
+  /** 1-indexed attempt counter. Bounds prevent infinite re-emit loops. */
+  attempt?: number;
+}
+
+export interface ConfigReply {
+  value: unknown;
+}
+
+/**
+ * Payload for `secret.required.<module>.<key>`. The reply NEVER
+ * carries the secret value — the responder calls
+ * `celilo module secret set <module> <key> <value>` out-of-band to
+ * write the value into the encrypted store, then replies with
+ * `{ acknowledged: true }`.
+ *
+ * Only fires for secrets WITHOUT a `generate:` block in the manifest
+ * (auto-generated secrets bypass the interview entirely).
+ */
+export interface SecretRequiredPayload {
+  module: string;
+  key: string;
+  type: 'string' | 'integer' | 'number';
+  required: boolean;
+  description?: string;
+}
+
+export interface SecretAck {
+  acknowledged: true;
+}
+
+/**
+ * Payload for `ensure.required.<provider>.<ensureId>`. One event per
+ * ensure (with all `inputs[]` in the payload), since the ensure is
+ * conceptually a single interview — the inputs relate to each other
+ * via the consumer's recipe.
+ */
+export interface EnsureRequiredPayload {
+  consumer: string;
+  provider: string;
+  ensureId: string;
+  triggerValue: string;
+  description?: string;
+  inputs: Array<{
+    target: string;
+    kind: 'append_to_array' | 'set_in_object';
+    prompt: string;
+    hint?: string;
+    type: string;
+  }>;
+}
+
+export interface EnsureReply {
+  values: Record<string, unknown>;
+  /**
+   * Set when one or more `inputs[]` had `target: 'secret.*'` and the
+   * responder set them out-of-band rather than including the value
+   * in the reply payload.
+   */
+  acknowledged?: true;
+}
+
+/**
+ * Emit a query event on the bus and wait for a responder to reply.
+ *
+ * No timeout — the deploy hangs until someone answers. The terminal-
+ * responder (when running on a TTY) is one of the responders; other
+ * responders include `celilo events respond` from another shell, the
+ * `celilo-config-responder` Claude subagent, and an autoresponder
+ * daemon (when one exists).
+ *
+ * `ownerBus` is the long-lived Bus instance the caller may already be
+ * holding (e.g. for a TerminalResponder). When passed, the function
+ * uses it; otherwise it opens + closes a short-lived bus per call.
+ */
+export async function busInterview<TReply>(
+  type: string,
+  payload: object,
+  ownerBus?: Bus,
+): Promise<TReply> {
+  const ownsBus = !ownerBus;
+  const bus: Bus = ownerBus ?? openBus({ dbPath: getEventBusPath(), events: NO_SCHEMAS });
+  try {
+    const replies = await bus.query(type as never, payload as never, {
+      timeoutMs: 0, // wait forever — race semantics, no timeout
+      pollIntervalMs: 250,
+      expect: 'first',
+    });
+    if (replies.length === 0) {
+      throw new Error(`bus-interview: ${type} returned no reply`);
+    }
+    return replies[0].payload as unknown as TReply;
+  } finally {
+    if (ownsBus) bus.close();
+  }
+}

package/src/services/celilo-events.test.ts

@@ -17,10 +17,10 @@ describe('celilo lifecycle events', () => {
   beforeEach(() => {
     dir = mkdtempSync(join(tmpdir(), 'celilo-events-test-'));
     dbPath = join(dir, 'events.db');
-    process.env.CELILO_EVENT_BUS_PATH = dbPath;
+    process.env.EVENT_BUS_DB = dbPath;
   });
   afterEach(() => {
-    process.env.CELILO_EVENT_BUS_PATH = undefined;
+    process.env.EVENT_BUS_DB = undefined;
     try {
       rmSync(dir, { recursive: true, force: true });
     } catch {
@@ -92,7 +92,7 @@ describe('celilo lifecycle events', () => {
   });
 
   it('does not throw when the bus path is unwritable', () => {
-    process.env.CELILO_EVENT_BUS_PATH = '/proc/no/such/place/events.db';
+    process.env.EVENT_BUS_DB = '/proc/no/such/place/events.db';
     expect(() => emitDeployStarted({ module: 'x', startedAt: 0 })).not.toThrow();
   });
 });

package/src/services/config-interview.ts

@@ -14,6 +14,12 @@ import { decryptSecret, encryptSecret } from '../secrets/encryption';
 import { deriveSecret, generateSecret } from '../secrets/generators';
 import { getOrCreateMasterKey } from '../secrets/master-key';
 import type { Machine } from '../types/infrastructure';
+import {
+  type ConfigReply,
+  type ConfigRequiredPayload,
+  EVENT_TYPES,
+  busInterview,
+} from './bus-interview';
 import { getSecretMetadata, loadSecretsSchema } from './secret-schema-loader';
 
 export interface MissingVariable {
@@ -417,21 +423,31 @@ export async function interviewForMissingConfig(
           }
         }
       } else {
-        // Prompt for regular config (visible input)
-        const message = variable.description
-          ? `${variable.name} - ${variable.description}:`
-          : `${variable.name}:`;
+        // Bus-mediated prompt: emit a query event, await the reply
+        // from any responder. The terminal-responder (started by
+        // module-deploy when stdin.isTTY) is one racer; the Claude
+        // subagent and `celilo events respond` from another shell are
+        // others. First reply wins. No timeout — the deploy hangs
+        // until someone answers; misconfigured environments are
+        // observable via `celilo events list-pending`.
+        const payload: ConfigRequiredPayload = {
+          module: moduleId,
+          key: variable.name,
+          type: (variable.type as ConfigRequiredPayload['type']) ?? 'string',
+          required: true,
+          description: variable.description,
+        };
+        const reply = await busInterview<ConfigReply>(
+          EVENT_TYPES.configRequired(moduleId, variable.name),
+          payload,
+        );
 
-        value = await promptText({
-          message,
-          validate: (val) => {
-            if (!val || val.trim() === '') {
-              return 'This field is required';
-            }
-          },
-        });
+        // The reply.value is typed per payload.type; the terminal-
+        // responder coerces strings to numbers/bools/json-as-array etc.
+        // For storage, we still need a string + an optional valueJson
+        // for non-scalar types. Match what `module config set` does.
+        value = typeof reply.value === 'string' ? reply.value : JSON.stringify(reply.value);
 
-        // Store config
         await db
           .insert(moduleConfigs)
           .values({

package/src/services/events-daemon.test.ts

@@ -23,7 +23,7 @@ describe('renderSystemdUnit', () => {
     expect(out).toContain(
       'ExecStart=/usr/local/bin/celilo events run --poll-ms 1000 --concurrency 4',
     );
-    expect(out).toContain('Environment=CELILO_EVENT_BUS_PATH=/var/lib/celilo/events.db');
+    expect(out).toContain('Environment=EVENT_BUS_DB=/var/lib/celilo/events.db');
     expect(out).toContain('Restart=on-failure');
     expect(out).toContain('WantedBy=default.target');
   });
@@ -141,9 +141,9 @@ describe('installDaemon / uninstallDaemon roundtrip', () => {
       pollMs: 500,
     });
     const written = readFileSync(second.unitPath, 'utf-8');
-    expect(written).toContain('CELILO_EVENT_BUS_PATH=/db2');
+    expect(written).toContain('EVENT_BUS_DB=/db2');
     expect(written).toContain('--poll-ms 500');
-    expect(written).not.toContain('CELILO_EVENT_BUS_PATH=/db1');
+    expect(written).not.toContain('EVENT_BUS_DB=/db1');
   });
 
   it('uninstall on a missing unit reports not-removed', () => {

package/src/services/events-daemon.ts

@@ -119,7 +119,7 @@ Type=simple
 ExecStart=${input.celiloPath} events run --poll-ms ${input.pollMs} --concurrency ${input.concurrency}
 Restart=on-failure
 RestartSec=10s
-Environment=CELILO_EVENT_BUS_PATH=${input.busDbPath}
+Environment=EVENT_BUS_DB=${input.busDbPath}
 # stdout/stderr are captured by journalctl --user -u celilo-events.service.
 StandardOutput=journal
 StandardError=journal
@@ -151,7 +151,7 @@ export function renderLaunchdPlist(input: UnitInputs): string {
   </array>
   <key>EnvironmentVariables</key>
   <dict>
-    <key>CELILO_EVENT_BUS_PATH</key>
+    <key>EVENT_BUS_DB</key>
     <string>${input.busDbPath}</string>
   </dict>
   <key>RunAtLoad</key>

package/src/services/module-deploy.ts

@@ -318,6 +318,17 @@ async function deployModuleImpl(
   });
   setActiveDisplay(display);
 
+  // Terminal-responder: when running on a TTY, this subscribes to
+  // `config.required.*` events and prompts via clack so the operator
+  // can answer the deploy's interview without `--no-interactive`'s
+  // brittle "everything must be pre-staged" flow. Other responders
+  // (Claude subagent, `celilo events respond`) compete; first reply
+  // wins. See infra/design/INTERACTIVE_DEPLOYS_VIA_BUS.md.
+  const terminalResponder =
+    !options.noInteractive && process.stdin.isTTY
+      ? (await import('./terminal-responder')).startTerminalResponder()
+      : null;
+
   try {
     // Check for e2e test containers — live and e2e environments are mutually exclusive.
     // Skip when using a test database (integration tests use os.tmpdir() paths).
@@ -1228,5 +1239,6 @@ async function deployModuleImpl(
   } finally {
     display.flush();
     setActiveDisplay(null);
+    terminalResponder?.close();
   }
 }

package/src/services/module-subscriptions.test.ts

@@ -78,10 +78,10 @@ describe('register / unregister roundtrip', () => {
   beforeEach(() => {
     dir = mkdtempSync(join(tmpdir(), 'modsubs-test-'));
     dbPath = join(dir, 'events.db');
-    process.env.CELILO_EVENT_BUS_PATH = dbPath;
+    process.env.EVENT_BUS_DB = dbPath;
   });
   afterEach(() => {
-    process.env.CELILO_EVENT_BUS_PATH = undefined;
+    process.env.EVENT_BUS_DB = undefined;
     try {
       rmSync(dir, { recursive: true, force: true });
     } catch {

package/src/services/terminal-responder.ts

@@ -0,0 +1,139 @@
+/**
+ * Terminal-responder: when a deploy runs on a TTY, this subscribes
+ * to `config.required.*` events and prompts the operator via clack
+ * for each one, replying on the bus with the user's input.
+ *
+ * Just one of several responder shapes — the bus query/reply path is
+ * a race, and the terminal is one racer. Other racers (Claude
+ * subagent, `celilo events respond` from another shell, autoresponder
+ * daemon) compete for the same events; first reply wins.
+ *
+ * The terminal-responder doesn't try to detect "another responder
+ * just won the race while my user was typing." For Stage 1, if the
+ * user types after losing, their reply is a stale-reply and the
+ * deploy already moved on. The user sees their prompt close and the
+ * deploy continues with the winning value (logged by the deploy in
+ * its normal output). Race-during-typing detection is a follow-up.
+ */
+
+import { hostname } from 'node:os';
+import { type Bus, openBus } from '@celilo/event-bus';
+import { defineEvents } from '@celilo/event-bus';
+import { log, promptText } from '../cli/prompts';
+import { getEventBusPath } from '../config/paths';
+import type { ConfigRequiredPayload } from './bus-interview';
+
+const NO_SCHEMAS = defineEvents({});
+
+/**
+ * Identifies this responder in the bus's `emittedBy` audit field.
+ * The deploy's audit log shows "config.required.lunacycle.domain →
+ * answered by terminal:hostname" so operators can correlate which
+ * shell answered which prompt.
+ */
+function responderId(): string {
+  return `terminal:${hostname()}:${process.pid}`;
+}
+
+export interface TerminalResponderHandle {
+  /** Stop watching for events. Doesn't cancel any in-flight prompt. */
+  close(): void;
+}
+
+/**
+ * Register a transient subscription on `config.required.*` events.
+ * For each event, prompt the operator via clack and reply on the bus.
+ *
+ * Returns a handle the caller can close() when the deploy completes.
+ */
+export function startTerminalResponder(): TerminalResponderHandle {
+  const bus: Bus = openBus({ dbPath: getEventBusPath(), events: NO_SCHEMAS });
+  const me = responderId();
+
+  // Track which queries we've already started a prompt for, so a
+  // re-fire (e.g. validation re-emit) doesn't double-prompt.
+  const handled = new Set<number>();
+
+  const watch = bus.watch('config.required.**', async (event) => {
+    if (handled.has(event.id)) return;
+    handled.add(event.id);
+
+    const payload = event.payload as ConfigRequiredPayload;
+    try {
+      const message = payload.description
+        ? `${payload.module}.${payload.key} — ${payload.description}:`
+        : `${payload.module}.${payload.key}:`;
+
+      const value = await promptText({
+        message,
+        validate: (val) => {
+          if (payload.required && (!val || val.trim() === '')) {
+            return 'This field is required';
+          }
+          if (payload.pattern && val) {
+            const re = new RegExp(payload.pattern);
+            if (!re.test(val)) return `Value must match: ${payload.pattern}`;
+          }
+        },
+      });
+
+      // Coerce to the declared type. clack returns string; the
+      // responder honors the type contract so the deploy doesn't
+      // have to second-guess the reply shape.
+      const coerced = coerceValue(value, payload.type);
+
+      bus.emitRaw(
+        `${event.type}.reply`,
+        { value: coerced },
+        {
+          replyFor: event.id,
+          emittedBy: me,
+        },
+      );
+    } catch (err) {
+      // Reply with an error-shaped payload so the deploy can surface
+      // it cleanly. The deploy can decide whether to re-emit (for
+      // recoverable errors) or fail.
+      const message = err instanceof Error ? err.message : String(err);
+      log.warn(`Terminal responder error for ${event.type}: ${message}`);
+      bus.emitRaw(`${event.type}.reply`, { error: message }, { replyFor: event.id, emittedBy: me });
+    }
+  });
+
+  return {
+    close() {
+      watch.close();
+      bus.close();
+    },
+  };
+}
+
+function coerceValue(raw: string, type: ConfigRequiredPayload['type']): unknown {
+  switch (type) {
+    case 'string':
+      return raw;
+    case 'integer':
+    case 'number': {
+      const n = Number(raw);
+      if (!Number.isFinite(n)) {
+        throw new Error(`Expected ${type}, got "${raw}"`);
+      }
+      return n;
+    }
+    case 'boolean':
+      if (/^(true|yes|y|1)$/i.test(raw.trim())) return true;
+      if (/^(false|no|n|0)$/i.test(raw.trim())) return false;
+      throw new Error(`Expected boolean, got "${raw}"`);
+    case 'array':
+    case 'object':
+      try {
+        return JSON.parse(raw);
+      } catch (err) {
+        throw new Error(
+          `Expected ${type} as JSON, got "${raw}": ${err instanceof Error ? err.message : err}`,
+        );
+      }
+    default:
+      return raw;
+  }
+}