@celilo/cli 0.5.0-alpha.8 → 0.5.0

package/package.json

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

package/src/api-clients/proxmox.test.ts

@@ -1,11 +1,13 @@
 import { describe, expect, test } from 'bun:test';
 import {
+  type ProxmoxClusterResource,
   buildCloudImageVolid,
   filterVmTemplates,
   findNodeForVmid,
   pollTaskUntilDone,
   selectFreeVmid,
-  selectIsoStorage,
+  selectImportStorage,
+  summarizeNodeCapacities,
 } from './proxmox';
 
 describe('findNodeForVmid (ISS-0090 — Proxmox is source of truth for current location)', () => {
@@ -36,6 +38,82 @@ describe('findNodeForVmid (ISS-0090 — Proxmox is source of truth for current l
   });
 });
 
+describe('summarizeNodeCapacities (ISS-0060 — per-node capacity reconciled from Proxmox)', () => {
+  const GB = 1024 * 1024 * 1024;
+  const resources: ProxmoxClusterResource[] = [
+    {
+      type: 'node',
+      node: 'node3',
+      status: 'online',
+      maxmem: 16 * GB,
+      mem: 4 * GB,
+      maxcpu: 8,
+      cpu: 0.25,
+      maxdisk: 200 * GB,
+      disk: 50 * GB,
+      uptime: 3600,
+    },
+    {
+      type: 'node',
+      node: 'node2',
+      status: 'offline',
+      maxmem: 8 * GB,
+      mem: 7 * GB,
+      maxcpu: 4,
+      cpu: 0.9,
+      maxdisk: 100 * GB,
+      disk: 90 * GB,
+      uptime: 0,
+    },
+    // Guest + storage rows must be ignored.
+    { type: 'lxc', vmid: 200, node: 'node2', status: 'running' },
+    { type: 'storage', node: 'node3', status: 'available' },
+  ];
+
+  test('derives free RAM/CPU/disk and online state from node rows only', () => {
+    const caps = summarizeNodeCapacities(resources);
+    expect(caps).toHaveLength(2); // guest + storage rows dropped
+    // Sorted by node name → node2 first.
+    expect(caps[0]).toEqual({
+      node: 'node2',
+      online: false,
+      memTotalMb: 8192,
+      memFreeMb: 1024,
+      cpuCores: 4,
+      cpuUsedPct: 90,
+      diskTotalGb: 100,
+      diskFreeGb: 10,
+      uptimeSec: 0,
+    });
+    expect(caps[1]).toMatchObject({
+      node: 'node3',
+      online: true,
+      memFreeMb: 12288,
+      cpuUsedPct: 25,
+      diskFreeGb: 150,
+    });
+  });
+
+  test('tolerates missing fields (treats absent capacity as 0, offline unless status==online)', () => {
+    const caps = summarizeNodeCapacities([{ type: 'node', node: 'bare' }]);
+    expect(caps[0]).toEqual({
+      node: 'bare',
+      online: false,
+      memTotalMb: 0,
+      memFreeMb: 0,
+      cpuCores: 0,
+      cpuUsedPct: 0,
+      diskTotalGb: 0,
+      diskFreeGb: 0,
+      uptimeSec: 0,
+    });
+  });
+
+  test('empty inventory → no nodes', () => {
+    expect(summarizeNodeCapacities([])).toEqual([]);
+  });
+});
+
 describe('filterVmTemplates — extract VM templates from a /nodes/{node}/qemu listing', () => {
   test('keeps only guests flagged template===1 and projects to {vmid, name}', () => {
     const guests = [
@@ -59,38 +137,48 @@ describe('filterVmTemplates — extract VM templates from a /nodes/{node}/qemu l
   });
 });
 
-describe('selectIsoStorage — pick a storage that accepts iso content', () => {
-  test('returns the first active, enabled storage whose content includes iso', () => {
+describe('selectImportStorage — pick a storage that accepts import content', () => {
+  test('returns the first active, enabled storage whose content includes import', () => {
     const storages = [
       { storage: 'local-lvm', content: 'images,rootdir', active: 1, enabled: 1 },
-      { storage: 'local', content: 'iso,vztmpl,backup', active: 1, enabled: 1 },
+      { storage: 'local', content: 'import,vztmpl,backup', active: 1, enabled: 1 },
+    ];
+    expect(selectImportStorage(storages)).toBe('local');
+  });
+
+  test('does NOT pick an iso-only storage (import-from rejects iso content)', () => {
+    // Regression guard: the cloud image must land in the import namespace, not
+    // iso/, or the VM-create `import-from=` fails with `has wrong type 'iso'`.
+    const storages = [
+      { storage: 'iso-only', content: 'iso,vztmpl,backup', active: 1, enabled: 1 },
+      { storage: 'data', content: 'import,images', active: 1, enabled: 1 },
     ];
-    expect(selectIsoStorage(storages)).toBe('local');
+    expect(selectImportStorage(storages)).toBe('data');
   });
 
-  test('skips an iso-capable storage that is inactive', () => {
+  test('skips an import-capable storage that is inactive', () => {
     const storages = [
-      { storage: 'cold', content: 'iso', active: 0, enabled: 1 },
-      { storage: 'local', content: 'iso', active: 1, enabled: 1 },
+      { storage: 'cold', content: 'import', active: 0, enabled: 1 },
+      { storage: 'local', content: 'import', active: 1, enabled: 1 },
     ];
-    expect(selectIsoStorage(storages)).toBe('local');
+    expect(selectImportStorage(storages)).toBe('local');
   });
 
-  test('skips an iso-capable storage that is disabled', () => {
+  test('skips an import-capable storage that is disabled', () => {
     const storages = [
-      { storage: 'off', content: 'iso', active: 1, enabled: 0 },
-      { storage: 'local', content: 'iso', active: 1, enabled: 1 },
+      { storage: 'off', content: 'import', active: 1, enabled: 0 },
+      { storage: 'local', content: 'import', active: 1, enabled: 1 },
     ];
-    expect(selectIsoStorage(storages)).toBe('local');
+    expect(selectImportStorage(storages)).toBe('local');
   });
 
-  test('returns null when no storage accepts iso content', () => {
+  test('returns null when no storage accepts import content', () => {
     const storages = [{ storage: 'local-lvm', content: 'images,rootdir', active: 1, enabled: 1 }];
-    expect(selectIsoStorage(storages)).toBeNull();
+    expect(selectImportStorage(storages)).toBeNull();
   });
 
   test('returns null for an empty storage list', () => {
-    expect(selectIsoStorage([])).toBeNull();
+    expect(selectImportStorage([])).toBeNull();
   });
 });
 
@@ -122,15 +210,15 @@ describe('selectFreeVmid — first free VMID >= minVmid (template hygiene)', ()
   });
 });
 
-describe('buildCloudImageVolid — volid for a cloud image on iso storage', () => {
-  test('places the filename under the storage iso/ namespace', () => {
+describe('buildCloudImageVolid — volid for a cloud image on import storage', () => {
+  test('places the filename under the storage import/ namespace', () => {
     expect(buildCloudImageVolid('local', 'noble-server-cloudimg-amd64.img')).toBe(
-      'local:iso/noble-server-cloudimg-amd64.img',
+      'local:import/noble-server-cloudimg-amd64.img',
     );
   });
 
   test('works with an arbitrary storage name', () => {
-    expect(buildCloudImageVolid('nas-iso', 'jammy.img')).toBe('nas-iso:iso/jammy.img');
+    expect(buildCloudImageVolid('nas', 'jammy.img')).toBe('nas:import/jammy.img');
   });
 });
 

package/src/api-clients/proxmox.ts

@@ -28,7 +28,7 @@ interface ProxmoxError {
   details?: Record<string, unknown>;
 }
 
-type ProxmoxResult<T> = { success: true; data: T } | ProxmoxError;
+export type ProxmoxResult<T> = { success: true; data: T } | ProxmoxError;
 
 /**
  * Make an authenticated API request to Proxmox
@@ -543,6 +543,101 @@ export function findNodeForVmid(
   return match?.node ?? null;
 }
 
+/**
+ * One row from `GET /cluster/resources`. The list is heterogeneous — `type`
+ * discriminates node / storage / guest rows. For `type: 'node'`, `status` is
+ * 'online'/'offline' and the mem/cpu/disk fields describe the node's capacity;
+ * for guests it's 'running'/'stopped' and `vmid` is set.
+ */
+export interface ProxmoxClusterResource {
+  type: string;
+  node?: string;
+  status?: string;
+  vmid?: number;
+  maxmem?: number; // bytes (node total RAM)
+  mem?: number; // bytes (node RAM in use)
+  maxcpu?: number; // cores
+  cpu?: number; // load fraction 0..1
+  maxdisk?: number; // bytes (node total disk on the relevant storage)
+  disk?: number; // bytes (disk in use)
+  uptime?: number; // seconds
+}
+
+/** Per-node capacity reconciled from Proxmox (reality, never a cached DB value). */
+export interface ProxmoxNodeCapacity {
+  node: string;
+  online: boolean;
+  memTotalMb: number;
+  memFreeMb: number;
+  cpuCores: number;
+  cpuUsedPct: number; // 0..100
+  diskTotalGb: number;
+  diskFreeGb: number;
+  uptimeSec: number;
+}
+
+const BYTES_PER_MB = 1024 * 1024;
+const BYTES_PER_GB = 1024 * 1024 * 1024;
+
+/**
+ * Summarize per-node capacity from a `/cluster/resources` list. Pure (Rule 10) —
+ * split from the network call for unit testing. Only `type: 'node'` rows count;
+ * guest and storage rows are ignored. Sorted by node name for stable output.
+ */
+export function summarizeNodeCapacities(
+  resources: ProxmoxClusterResource[],
+): ProxmoxNodeCapacity[] {
+  return resources
+    .filter((r): r is ProxmoxClusterResource & { node: string } => r.type === 'node' && !!r.node)
+    .map((r) => {
+      const maxmem = r.maxmem ?? 0;
+      const mem = r.mem ?? 0;
+      const maxdisk = r.maxdisk ?? 0;
+      const disk = r.disk ?? 0;
+      return {
+        node: r.node,
+        online: r.status === 'online',
+        memTotalMb: Math.round(maxmem / BYTES_PER_MB),
+        memFreeMb: Math.round((maxmem - mem) / BYTES_PER_MB),
+        cpuCores: r.maxcpu ?? 0,
+        cpuUsedPct: Math.round((r.cpu ?? 0) * 100),
+        diskTotalGb: Math.round(maxdisk / BYTES_PER_GB),
+        diskFreeGb: Math.round((maxdisk - disk) / BYTES_PER_GB),
+        uptimeSec: r.uptime ?? 0,
+      };
+    })
+    .sort((a, b) => a.node.localeCompare(b.node));
+}
+
+/**
+ * Cohesive Proxmox introspection client (ISS-0060). Wraps the credentials so
+ * callers don't thread them through every call, and centralizes the live reads
+ * that let celilo treat Proxmox — not a cached DB row — as the source of truth
+ * for where containers live and how much room each node has.
+ */
+export class ProxmoxClient {
+  constructor(private readonly credentials: ProxmoxCredentials) {}
+
+  /** Raw cluster resource inventory (node + guest + storage rows). */
+  async clusterResources(): Promise<ProxmoxResult<ProxmoxClusterResource[]>> {
+    return makeProxmoxRequest<ProxmoxClusterResource[]>(this.credentials, '/cluster/resources');
+  }
+
+  /** Live per-node capacity (RAM/CPU/disk/online), reconciled from Proxmox. */
+  async nodeCapacities(): Promise<ProxmoxResult<ProxmoxNodeCapacity[]>> {
+    const result = await this.clusterResources();
+    if (!result.success) return result;
+    return { success: true, data: summarizeNodeCapacities(result.data) };
+  }
+
+  /** The node a VMID currently lives on, or null if it isn't created yet. */
+  async nodeForVmid(vmid: number): Promise<ProxmoxResult<string | null>> {
+    const result = await this.clusterResources();
+    if (!result.success) return result;
+    return { success: true, data: findNodeForVmid(result.data, vmid) };
+  }
+}
+
 /**
  * List available LXC templates in storage
  */
@@ -795,30 +890,38 @@ export async function listVmTemplates(
   return { success: true, data: filterVmTemplates(result.data) };
 }
 
-/** Storage row shape (subset) used when picking ISO-capable storage. */
+/** Storage row shape (subset) used when picking import-capable storage. */
 type ProxmoxStorageRow = { storage: string; content: string; active: number; enabled: number };
 
 /**
- * Pick the first active, enabled storage that accepts `iso` content. Pure
+ * Pick the first active, enabled storage that accepts `import` content. Pure
  * selection logic, split from the network call for testability (Rule 10).
  * Returns the storage name, or null when none qualifies.
+ *
+ * Must be `import`, NOT `iso`: the cloud image is consumed via the VM-create
+ * `import-from=` parameter, which Proxmox only accepts from a source on a
+ * storage whose content type is `images` or `import`. A `.img` downloaded to
+ * the `iso/` namespace is rejected with `has wrong type 'iso'`. The
+ * `download-url` endpoint accepts `content=import` on PVE 8.2+, so we download
+ * straight into the import namespace. (PVE 8.2+; node fleet is 9.x.)
  */
-export function selectIsoStorage(storages: ProxmoxStorageRow[]): string | null {
-  const iso = storages.find((s) => s.active && s.enabled && s.content.includes('iso'));
-  return iso?.storage ?? null;
+export function selectImportStorage(storages: ProxmoxStorageRow[]): string | null {
+  const match = storages.find((s) => s.active && s.enabled && s.content.includes('import'));
+  return match?.storage ?? null;
 }
 
 /**
- * Find a storage on the node that accepts `iso` content (for downloading cloud
- * images). Returns the storage name, or null if none found.
+ * Find a storage on the node that accepts `import` content (for downloading
+ * cloud images that will be imported as a VM disk). Returns the storage name,
+ * or null if none found.
  */
-export async function findIsoStorage(
+export async function findImportStorage(
   credentials: ProxmoxCredentials,
   nodeName: string,
 ): Promise<ProxmoxResult<string | null>> {
   const result = await listNodeStorage(credentials, nodeName);
   if (!result.success) return result;
-  return { success: true, data: selectIsoStorage(result.data) };
+  return { success: true, data: selectImportStorage(result.data) };
 }
 
 /**
@@ -858,20 +961,22 @@ export async function findFreeTemplateVmid(
 }
 
 /**
- * Download a cloud image URL to ISO storage on the node. Returns a UPID for
- * status polling. Requires PVE 7.2+ (`download-url` endpoint).
+ * Download a cloud image URL to `import` storage on the node. Returns a UPID
+ * for status polling. Requires PVE 8.2+ (`download-url` with `content=import`).
+ * The image MUST land in the import namespace (not iso) so the VM-create
+ * `import-from=` accepts it — see selectImportStorage.
  */
 export async function downloadCloudImage(
   credentials: ProxmoxCredentials,
   nodeName: string,
-  isoStorage: string,
+  importStorage: string,
   url: string,
   filename: string,
 ): Promise<ProxmoxResult<string>> {
   return makeProxmoxPost<string>(
     credentials,
-    `/nodes/${nodeName}/storage/${isoStorage}/download-url`,
-    { url, filename, content: 'iso' },
+    `/nodes/${nodeName}/storage/${importStorage}/download-url`,
+    { url, filename, content: 'import' },
   );
 }
 
@@ -908,13 +1013,14 @@ export async function pollTaskUntilDone(
 }
 
 /**
- * Build the volid for a cloud image downloaded to ISO storage. Pure path
+ * Build the volid for a cloud image downloaded to `import` storage. Pure path
  * construction, split out for testability (Rule 10) — mirrors buildTemplatePath.
- * Proxmox's `download-url` with `content=iso` stores the `.img` under the
- * storage's `iso/` namespace, so the volid is `<storage>:iso/<filename>`.
+ * Proxmox's `download-url` with `content=import` stores the `.img` under the
+ * storage's `import/` namespace, so the volid is `<storage>:import/<filename>`.
+ * This is the namespace the VM-create `import-from=` accepts (iso/ is rejected).
  */
-export function buildCloudImageVolid(isoStorage: string, filename: string): string {
-  return `${isoStorage}:iso/${filename}`;
+export function buildCloudImageVolid(importStorage: string, filename: string): string {
+  return `${importStorage}:import/${filename}`;
 }
 
 export interface CreateVmFromCloudImageParams {
@@ -922,8 +1028,8 @@ export interface CreateVmFromCloudImageParams {
   nodeName: string;
   vmid: number;
   name: string;
-  /** Volume ID of the downloaded cloud image, e.g. `local:iso/noble-server-cloudimg-amd64.img` */
-  isoVolid: string;
+  /** Volume ID of the downloaded cloud image, e.g. `local:import/noble-server-cloudimg-amd64.img` */
+  imageVolid: string;
   /** Storage for the imported VM disk and the cloud-init drive */
   diskStorage: string;
 }
@@ -943,7 +1049,7 @@ export interface CreateVmFromCloudImageParams {
 export async function createVmFromCloudImage(
   params: CreateVmFromCloudImageParams,
 ): Promise<ProxmoxResult<string>> {
-  const { credentials, nodeName, vmid, name, isoVolid, diskStorage } = params;
+  const { credentials, nodeName, vmid, name, imageVolid, diskStorage } = params;
   return makeProxmoxPost<string>(credentials, `/nodes/${nodeName}/qemu`, {
     vmid: String(vmid),
     name,
@@ -955,7 +1061,7 @@ export async function createVmFromCloudImage(
     serial0: 'socket',
     vga: 'serial0',
     boot: 'order=scsi0',
-    scsi0: `${diskStorage}:0,import-from=${isoVolid}`,
+    scsi0: `${diskStorage}:0,import-from=${imageVolid}`,
     ide2: `${diskStorage}:cloudinit`,
   });
 }

package/src/cli/command-registry.ts

@@ -666,8 +666,16 @@ export const COMMANDS: CommandDef[] = [
             description: 'Add Proxmox container service',
             flags: [
               { name: 'api-url', description: 'Proxmox API URL', takesValue: true },
-              { name: 'token-id', description: 'API token ID', takesValue: true },
-              { name: 'token-secret', description: 'API token secret', takesValue: true },
+              {
+                name: 'api-token-id',
+                description: 'API token ID (or $PROXMOX_API_TOKEN_ID)',
+                takesValue: true,
+              },
+              {
+                name: 'api-token-secret',
+                description: 'API token secret (or $PROXMOX_API_TOKEN_SECRET)',
+                takesValue: true,
+              },
               { name: 'node', description: 'Target node', takesValue: true },
               {
                 name: 'zone',
@@ -682,7 +690,11 @@ export const COMMANDS: CommandDef[] = [
             name: 'digitalocean',
             description: 'Add DigitalOcean container service',
             flags: [
-              { name: 'api-token', description: 'DigitalOcean API token', takesValue: true },
+              {
+                name: 'api-token',
+                description: 'DigitalOcean API token (or $DIGITALOCEAN_API_TOKEN)',
+                takesValue: true,
+              },
               { name: 'region', description: 'Region', takesValue: true },
               {
                 name: 'zone',
@@ -1057,6 +1069,23 @@ export const COMMANDS: CommandDef[] = [
       },
     ],
   },
+  {
+    name: 'proxmox',
+    description: 'Proxmox cluster introspection (nodes, capacity)',
+    subcommands: [
+      {
+        name: 'node',
+        description: 'Proxmox node operations',
+        subcommands: [
+          {
+            name: 'list',
+            description: 'List cluster nodes with live capacity (RAM/CPU/disk)',
+            args: [{ name: 'service-id', description: 'Proxmox service (optional if only one)' }],
+          },
+        ],
+      },
+    ],
+  },
   {
     name: 'subscribers',
     description: 'Manage build-bus subscribers (cross-machine publish-event delivery)',

package/src/cli/commands/backup-delete.ts

@@ -3,9 +3,9 @@
  * Delete a specific backup entry and its storage file.
  */
 
-import * as p from '@clack/prompts';
 import { deleteBackupRecord, formatSize, getBackup } from '../../services/backup-metadata';
 import { createStorageProvider, getBackupStorage } from '../../services/backup-storage';
+import { askConfirm, withInterviewSession } from '../../services/bus-interview';
 import { celiloIntro, celiloOutro } from '../prompts';
 import type { CommandResult } from '../types';
 
@@ -40,13 +40,16 @@ export async function handleBackupDelete(
     console.log(`  → ${storage?.storageId ?? '?'}: ${backup.storagePath}\n`);
 
     if (!flags.force) {
-      const confirmed = await p.confirm({
-        message: 'Delete this backup?',
-        initialValue: false,
-      });
+      const confirmed = await withInterviewSession(() =>
+        askConfirm({
+          scope: `backup:${backupId}`,
+          key: 'delete',
+          message: 'Delete this backup?',
+          defaultValue: false,
+        }),
+      );
 
-      if (p.isCancel(confirmed) || !confirmed) {
-        p.cancel('Operation cancelled');
+      if (!confirmed) {
         return { success: false, error: 'Cancelled by user' };
       }
     }

package/src/cli/commands/backup-import.ts

@@ -5,8 +5,8 @@
 
 import { existsSync, statSync } from 'node:fs';
 import { resolve } from 'node:path';
-import * as p from '@clack/prompts';
 import { formatSize } from '../../services/backup-metadata';
+import { askConfirm, withInterviewSession } from '../../services/bus-interview';
 import { celiloIntro, celiloOutro } from '../prompts';
 import type { CommandResult } from '../types';
 
@@ -54,13 +54,16 @@ export async function handleBackupImport(
 
     // Confirm unless --yes
     if (!flags.yes) {
-      const confirmed = await p.confirm({
-        message: `Import this file as a backup for ${moduleId}?`,
-        initialValue: true,
-      });
-
-      if (p.isCancel(confirmed) || !confirmed) {
-        p.cancel('Import cancelled');
+      const confirmed = await withInterviewSession(() =>
+        askConfirm({
+          scope: `backup-import:${moduleId}`,
+          key: 'import',
+          message: `Import this file as a backup for ${moduleId}?`,
+          defaultValue: true,
+        }),
+      );
+
+      if (!confirmed) {
         return { success: false, error: 'Cancelled by user' };
       }
     }

package/src/cli/commands/backup-restore.ts

@@ -3,10 +3,10 @@
  * Restores from a backup archive, executing the module's on_restore hook.
  */
 
-import * as p from '@clack/prompts';
 import { formatSize, getBackup } from '../../services/backup-metadata';
 import { restoreModuleBackup, restoreSystemStateBackup } from '../../services/backup-restore';
 import { getBackupStorage } from '../../services/backup-storage';
+import { askConfirm, withInterviewSession } from '../../services/bus-interview';
 import { celiloIntro, celiloOutro } from '../prompts';
 import type { CommandResult } from '../types';
 
@@ -66,13 +66,16 @@ export async function handleBackupRestore(
 
     // Confirm unless --yes
     if (!flags.yes) {
-      const confirmed = await p.confirm({
-        message: 'Proceed with restore?',
-        initialValue: false,
-      });
-
-      if (p.isCancel(confirmed) || !confirmed) {
-        p.cancel('Restore cancelled');
+      const confirmed = await withInterviewSession(() =>
+        askConfirm({
+          scope: `backup-restore:${backupId}`,
+          key: 'proceed',
+          message: 'Proceed with restore?',
+          defaultValue: false,
+        }),
+      );
+
+      if (!confirmed) {
         return { success: false, error: 'Cancelled by user' };
       }
     }

package/src/cli/commands/events.ts

@@ -389,7 +389,7 @@ export async function handleEventsRepair(): Promise<CommandResult> {
   }
 }
 
-const INTERVIEW_FAMILIES = ['config', 'secret', 'ensure', 'aspect'] as const;
+const INTERVIEW_FAMILIES = ['config', 'secret', 'ensure', 'aspect', 'interview'] as const;
 type InterviewFamily = (typeof INTERVIEW_FAMILIES)[number];
 
 /** Classify a query event type into its interview family, or null if it isn't one. */
@@ -398,6 +398,7 @@ function interviewFamily(type: string): InterviewFamily | null {
   if (type.startsWith('secret.required.')) return 'secret';
   if (type.startsWith('ensure.required.')) return 'ensure';
   if (type.startsWith('aspect.required.')) return 'aspect';
+  if (type.startsWith('interview.required.')) return 'interview';
   return null;
 }
 
@@ -428,6 +429,10 @@ function interviewFamily(type: string): InterviewFamily | null {
  *                                base-module aspect, 'false' refuses it (ISS-0027).
  *                                Replies { consented }; the deploy records the
  *                                approval/denial.
+ *   - interview.required.<scope>.<key> → value is the answer itself, shaped per
+ *                                the question's kind ('"node3"', 'true',
+ *                                '["a","b"]'); replies { value }. The generic
+ *                                operator-command interview family (ISS-0127).
  */
 export async function handleEventsReply(
   args: string[],
@@ -476,7 +481,7 @@ export async function handleEventsReply(
       return {
         success: false,
         error: `Event ${queryId} is type '${query.type}', not an interview query.
-  Expected one of: config.required.* / secret.required.* / ensure.required.* / aspect.required.*`,
+  Expected one of: config.required.* / secret.required.* / ensure.required.* / aspect.required.* / interview.required.*`,
       };
     }
 
@@ -496,7 +501,7 @@ export async function handleEventsReply(
       });
     }
 
-    if (family === 'config') {
+    if (family === 'config' || family === 'interview') {
       bus.emitRaw(`${query.type}.reply`, { value }, { replyFor: queryId, emittedBy });
       return jsonResult({ ok: true, status: 'replied', queryId, type: query.type, family, value });
     }