@celilo/cli 0.5.0-alpha.1 → 0.5.0-alpha.11

package/src/cli/commands/module-status.ts

@@ -5,6 +5,8 @@
 import { eq } from 'drizzle-orm';
 import { getDb } from '../../db/client';
 import { capabilities, moduleConfigs, modules, secrets } from '../../db/schema';
+import { getModuleSystems } from '../../services/deployed-systems';
+import { formatPlacementLine, reconcilePlacement } from '../../services/placement-reconcile';
 import { getArg, validateRequiredArgs } from '../parser';
 import type { CommandResult } from '../types';
 
@@ -84,6 +86,19 @@ export async function handleModuleStatus(args: string[]): Promise<CommandResult>
   }
   sections.push(metadataLines.join('\n'));
 
+  // Section 1b: Placement (real node reconciled live from Proxmox — ISS-0060).
+  // Shows where each deployed system ACTUALLY lives, not the cached
+  // __infra_target_node config (which drifts). API-only modules (no deployed
+  // systems) skip this section; a Proxmox outage degrades to "node unknown".
+  const placements = await reconcilePlacement(getModuleSystems(moduleId, db));
+  if (placements.length > 0) {
+    const placementLines = ['Placement (live from Proxmox):'];
+    for (const p of placements) {
+      placementLines.push(`  ${formatPlacementLine(p.system, p.resolution)}`);
+    }
+    sections.push(placementLines.join('\n'));
+  }
+
   // Section 2: Configuration
   if (configs.length > 0) {
     const configLines = ['Configuration:'];

package/src/cli/commands/module-upgrade.test.ts

@@ -212,4 +212,41 @@ variables:
     expect(manifest.name).toBe('Test Module Renamed');
     expect(manifest.variables?.owns ?? []).toEqual([]);
   });
+
+  // Regression for ISS-0091: `module update` used to skip event-bus
+  // subscription registration (only `module import` did it), so a
+  // refreshed module silently lost its reconcile subscriptions — found
+  // live when caddy's reconcile_routes subscription vanished after a
+  // path-based update.
+  test('registers the new manifest subscriptions on the bus (ISS-0091)', async () => {
+    process.env.EVENT_BUS_DB = join(tempDir, 'events.db');
+    try {
+      writeFileSync(
+        join(srcDir, 'manifest.yml'),
+        `celilo_contract: "1.0"
+id: testmod
+name: Test Module
+version: 1.1.0
+description: fixture with subscriptions
+subscriptions:
+  - name: testmod-tick
+    pattern: timer.tick.15m
+    handler: "true"
+`,
+      );
+      const result = await upgradeOne(srcDir, db, {}, { quiet: true });
+      expect(result.status).toBe('success');
+
+      const { openBus, defineEvents } = await import('@celilo/event-bus');
+      const bus = openBus({ dbPath: join(tempDir, 'events.db'), events: defineEvents({}) });
+      try {
+        // Subscriber names are scoped `<module-id>.<sub-name>` on the bus.
+        expect(bus.getSubscriberByName('testmod.testmod-tick')).not.toBeNull();
+      } finally {
+        bus.close();
+      }
+    } finally {
+      process.env.EVENT_BUS_DB = undefined;
+    }
+  });
 });

package/src/cli/commands/module-upgrade.ts

@@ -13,7 +13,6 @@ import { cpSync, existsSync, readFileSync, readdirSync } from 'node:fs';
 import { unlink } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { join, resolve } from 'node:path';
-import * as p from '@clack/prompts';
 import { eq } from 'drizzle-orm';
 import { parse as parseYaml } from 'yaml';
 import { registerModuleCapabilities } from '../../capabilities/registration';
@@ -23,6 +22,7 @@ import { ModuleManifestSchema } from '../../manifest/schema';
 import type { ModuleManifest } from '../../manifest/schema';
 import { cleanupTempDir, extractPackage } from '../../module/packaging/extract';
 import { RegistryClient } from '../../registry/client';
+import { askConfirm, withInterviewSession } from '../../services/bus-interview';
 import { getFlag } from '../parser';
 import { log } from '../prompts';
 import type { CommandResult } from '../types';
@@ -293,6 +293,22 @@ export async function upgradeOne(
     }
   }
 
+  // (Re-)register event-bus subscriptions from the new manifest —
+  // mirrors import.ts (ISS-0091: update used to skip this, so a
+  // refreshed module silently lost its reconcile subscriptions).
+  // registerModuleSubscriptions is idempotent; best-effort like import:
+  // a bus problem shouldn't wedge the upgrade, but must be loud.
+  try {
+    const { registerModuleSubscriptions } = await import('../../services/module-subscriptions');
+    registerModuleSubscriptions(newManifest, installedPath);
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    log.warn(`  ${moduleId}: failed to register event-bus subscriptions: ${msg}`);
+    log.warn(
+      '  Module upgraded, but reactive flows on the event bus will not fire until this is fixed.',
+    );
+  }
+
   if (!opts.quiet) {
     log.success(`Upgraded ${moduleId} (${previousVersion} → ${newVersion})`);
   }
@@ -492,11 +508,15 @@ async function runRegistrySweep(
     log.message('Each breaking update will be applied only on explicit confirmation.\n');
 
     for (const plan of breaking) {
-      const proceed = await p.confirm({
-        message: `Apply breaking update for ${plan.moduleId} (${plan.installedVersion} → ${plan.targetVersion})?`,
-        initialValue: false,
-      });
-      if (p.isCancel(proceed) || !proceed) {
+      const proceed = await withInterviewSession(() =>
+        askConfirm({
+          scope: `module-upgrade:${plan.moduleId}`,
+          key: 'apply_breaking',
+          message: `Apply breaking update for ${plan.moduleId} (${plan.installedVersion} → ${plan.targetVersion})?`,
+          defaultValue: false,
+        }),
+      );
+      if (!proceed) {
         skippedBreaking++;
         continue;
       }

package/src/cli/commands/proxmox-node-list.ts

@@ -0,0 +1,101 @@
+/**
+ * `celilo proxmox node list` — live per-node capacity from the Proxmox cluster
+ * (ISS-0060, Phase 1 of v2/PROXMOX_CAPACITY_AND_LIFECYCLE.md).
+ *
+ * Reads reality from the Proxmox API via `ProxmoxClient`, never a cached DB
+ * value — the foundation for capacity-aware placement (ISS-0061) and
+ * reconcile-on-read (the rest of ISS-0060 / ISS-0090).
+ */
+
+import { ProxmoxClient, type ProxmoxCredentials } from '../../api-clients/proxmox';
+import { getServiceCredentials, listContainerServices } from '../../services/container-service';
+import { celiloIntro } from '../prompts';
+import type { CommandResult } from '../types';
+
+function formatUptime(sec: number): string {
+  if (sec <= 0) return '—';
+  const days = Math.floor(sec / 86400);
+  const hours = Math.floor((sec % 86400) / 3600);
+  return days > 0 ? `${days}d${hours}h` : `${hours}h`;
+}
+
+/**
+ * Resolve which Proxmox service to introspect: an explicit service-id arg, else
+ * the sole Proxmox service. Returns an error message when the choice is
+ * ambiguous or the named service doesn't exist.
+ */
+function resolveProxmoxService(
+  services: Awaited<ReturnType<typeof listContainerServices>>,
+  requested: string | undefined,
+): { service: (typeof services)[number] } | { error: string } {
+  const proxmox = services.filter((s) => s.providerName === 'proxmox');
+  if (proxmox.length === 0) {
+    return {
+      error: 'No Proxmox container service configured. Add one: celilo service add proxmox',
+    };
+  }
+  if (requested) {
+    const match = proxmox.find((s) => s.serviceId === requested);
+    if (!match) {
+      return {
+        error: `No Proxmox service '${requested}'. Known: ${proxmox.map((s) => s.serviceId).join(', ')}`,
+      };
+    }
+    return { service: match };
+  }
+  if (proxmox.length > 1) {
+    return {
+      error: `Multiple Proxmox services — specify one: celilo proxmox node list <service-id>\n  ${proxmox
+        .map((s) => s.serviceId)
+        .join('\n  ')}`,
+    };
+  }
+  return { service: proxmox[0] };
+}
+
+export async function handleProxmoxNodeList(
+  args: string[],
+  _flags: Record<string, boolean | string> = {},
+): Promise<CommandResult> {
+  celiloIntro('Proxmox nodes');
+
+  const resolved = resolveProxmoxService(await listContainerServices(), args[0]);
+  if ('error' in resolved) {
+    console.log(`✗ ${resolved.error}`);
+    return { success: false, error: resolved.error };
+  }
+  const { service } = resolved;
+
+  const creds = (await getServiceCredentials(service.id)) as ProxmoxCredentials;
+  const result = await new ProxmoxClient(creds).nodeCapacities();
+  if (!result.success) {
+    console.log(`✗ Could not reach Proxmox (${service.serviceId}): ${result.message}`);
+    return { success: false, error: result.message };
+  }
+
+  if (result.data.length === 0) {
+    console.log('No nodes reported by the cluster.');
+    return { success: true, message: 'No nodes' };
+  }
+
+  console.log(`Service: ${service.serviceId} (${service.name})\n`);
+  console.log(
+    'NODE        STATUS    RAM free/total      CPU             DISK free/total     UPTIME',
+  );
+  console.log(
+    '─────────────────────────────────────────────────────────────────────────────────────',
+  );
+  for (const n of result.data) {
+    const status = n.online ? 'online' : 'OFFLINE';
+    const ram = `${(n.memFreeMb / 1024).toFixed(1)}/${(n.memTotalMb / 1024).toFixed(1)} GB`;
+    const cpu = `${n.cpuCores} cores ${n.cpuUsedPct}%`;
+    const disk = `${n.diskFreeGb}/${n.diskTotalGb} GB`;
+    console.log(
+      `${n.node.padEnd(11)} ${status.padEnd(9)} ${ram.padEnd(19)} ${cpu.padEnd(15)} ${disk.padEnd(19)} ${formatUptime(
+        n.uptimeSec,
+      )}`,
+    );
+  }
+  console.log('');
+  return { success: true, message: `${result.data.length} node(s)` };
+}

package/src/cli/commands/proxmox-template-selection.ts

@@ -10,7 +10,6 @@
  * means the canonical filename always matches what `pveam download` accepts.
  */
 
-import * as p from '@clack/prompts';
 import {
   type ProxmoxAppliance,
   type ProxmoxCredentials,
@@ -18,9 +17,8 @@ import {
   downloadAppliance,
   listAvailableAppliances,
 } from '../../api-clients/proxmox';
+import { askSelect, askText } from '../../services/bus-interview';
 import { FuelGauge } from '../fuel-gauge';
-import { promptText } from '../prompts';
-import { validateRequired } from '../validators';
 
 export interface UbuntuTemplateChoice {
   /** Canonical filename, e.g. "ubuntu-24.04-standard_24.04-2_amd64.tar.zst" */
@@ -103,7 +101,7 @@ export function pickInitialTemplate(
 export async function selectUbuntuApplianceFromCatalog(
   credentials: ProxmoxCredentials,
   nodeName: string,
-  opts: { currentTemplate?: string } = {},
+  opts: { scope: string; currentTemplate?: string },
 ): Promise<TemplateSelectionResult> {
   console.log('\nFetching Proxmox template catalog...');
   const result = await listAvailableAppliances(credentials, nodeName);
@@ -115,13 +113,17 @@ export async function selectUbuntuApplianceFromCatalog(
       '  After saving, run `pveam download <storage> <template>` on the Proxmox host before deploying.',
     );
 
-    const manual = await promptText({
-      message: 'Template filename:',
+    // Manual fallback over the bus (ISS-0127) — drivable headlessly by
+    // answering `interview.required.<scope>.lxc_template_manual`.
+    const manual = await askText({
+      scope: opts.scope,
+      key: 'lxc_template_manual',
+      message: 'Template filename',
       placeholder: 'ubuntu-24.04-standard_24.04-2_amd64.tar.zst',
-      validate: validateRequired('Template filename'),
+      required: true,
     });
 
-    if (typeof manual !== 'string' || manual.trim() === '') {
+    if (manual.trim() === '') {
       return { kind: 'cancelled' };
     }
 
@@ -140,8 +142,11 @@ export async function selectUbuntuApplianceFromCatalog(
 
   const initialValue = pickInitialTemplate(options, opts.currentTemplate);
 
-  const selection = await p.select<string>({
-    message: 'Default Ubuntu template:',
+  // Template choice over the bus (ISS-0127), keyed `lxc_template` within scope.
+  const selection = await askSelect({
+    scope: opts.scope,
+    key: 'lxc_template',
+    message: 'Default Ubuntu template',
     options: options.map((e) => ({
       value: e.appliance.template,
       label: `Ubuntu ${e.major}.${String(e.minor).padStart(2, '0')}${e.isLts ? ' LTS' : ''}`,
@@ -149,13 +154,9 @@ export async function selectUbuntuApplianceFromCatalog(
         ? `revision ${e.appliance.version}`
         : `revision ${e.appliance.version} · non-LTS`,
     })),
-    initialValue,
+    defaultValue: initialValue,
   });
 
-  if (p.isCancel(selection)) {
-    return { kind: 'cancelled' };
-  }
-
   return { kind: 'selected', choice: { template: selection, source: 'catalog' } };
 }
 

package/src/cli/commands/proxmox-vm-template-build.ts

@@ -0,0 +1,171 @@
+/**
+ * Build a cloud-init Ubuntu VM template on Proxmox via the API (no SSH needed).
+ * Called from service-add-proxmox when the operator opts in.
+ *
+ * Steps:
+ *   1. Find ISO-capable storage on the target node.
+ *   2. Find a free template VMID (>= 9000, outside celilo's IPAM range).
+ *   3. Download Ubuntu 24.04 cloud image to ISO storage. (~2–5 min)
+ *   4. Create a VM with the cloud image imported as its boot disk + a cloud-init
+ *      CDROM drive. (~30s)
+ *   5. Convert the VM to a template. (~5s)
+ *
+ * The finished template is a blank cloud-init base — no credentials, IP, or SSH
+ * keys baked in. celilo's terraform sets those at clone time (ipconfig0, sshkeys,
+ * ciuser, nameserver). Requires PVE 8.0+ (the storage download-url endpoint is
+ * 7.2+, but importing the disk via `import-from` in the VM-create call is 8.0+,
+ * so the build as a whole needs 8.0+).
+ */
+
+import type { ProxmoxCredentials, ProxmoxVmTemplate } from '../../api-clients/proxmox';
+import {
+  buildCloudImageVolid,
+  convertVmToTemplate,
+  createVmFromCloudImage,
+  deleteVm,
+  downloadCloudImage,
+  findFreeTemplateVmid,
+  findImportStorage,
+  listVmTemplates,
+  pollTaskUntilDone,
+} from '../../api-clients/proxmox';
+import { FuelGauge } from '../fuel-gauge';
+
+const UBUNTU_2404_AMD64_URL =
+  'https://cloud-images.ubuntu.com/noble/current/noble-server-cloudimg-amd64.img';
+// Stored under the storage's import/ namespace, so the filename must end in an
+// extension PVE accepts for `import` content (UPLOAD_IMPORT_EXT_RE_1 =
+// ova|qcow2|raw|vmdk) — a `.img` is rejected with "invalid filename or wrong
+// extension". Ubuntu's cloud image is qcow2 format despite the upstream `.img`
+// URL, so we download it under a `.qcow2` name. The URL above is unchanged.
+const UBUNTU_2404_AMD64_FILENAME = 'noble-server-cloudimg-amd64.qcow2';
+const DEFAULT_TEMPLATE_NAME = 'ubuntu-2404-cloudinit';
+
+export interface VmTemplateBuildParams {
+  credentials: ProxmoxCredentials;
+  nodeName: string;
+  diskStorage: string;
+}
+
+/**
+ * List existing VM templates on the node. Returns an empty array (not an error)
+ * if the API call fails — the caller treats failure as "no templates found".
+ */
+export async function detectExistingVmTemplates(
+  credentials: ProxmoxCredentials,
+  nodeName: string,
+): Promise<ProxmoxVmTemplate[]> {
+  const result = await listVmTemplates(credentials, nodeName);
+  return result.success ? result.data : [];
+}
+
+/**
+ * Build a cloud-init Ubuntu 24.04 VM template on the Proxmox node.
+ * Shows a FuelGauge progress indicator — takes 2–10 min depending on the
+ * operator's internet connection (image download is ~600 MB).
+ * Returns the template name (e.g. "ubuntu-2404-cloudinit").
+ * Cleans up the VM on failure so the operator isn't left with a partial guest.
+ */
+export async function buildCloudInitTemplate(params: VmTemplateBuildParams): Promise<string> {
+  const { credentials, nodeName, diskStorage } = params;
+  const gauge = new FuelGauge('Building cloud-init VM template');
+  gauge.start();
+
+  let vmid: number | null = null;
+
+  try {
+    // Step 1: find import-capable storage. The cloud image is consumed via the
+    // VM-create `import-from=`, which requires an `import`/`images` source — a
+    // `.img` in the `iso/` namespace is rejected (`has wrong type 'iso'`).
+    gauge.addOutput('Finding import-capable storage on the node…');
+    const importStorageResult = await findImportStorage(credentials, nodeName);
+    if (!importStorageResult.success) {
+      throw new Error(`Could not list node storage: ${importStorageResult.message}`);
+    }
+    const importStorage = importStorageResult.data;
+    if (!importStorage) {
+      throw new Error(
+        'No import-capable storage found on the node. ' +
+          "Enable 'import' content on a storage (typically 'local') in the Proxmox UI: " +
+          'Datacenter → Storage → Edit → Content.',
+      );
+    }
+    gauge.addOutput(`Import storage: ${importStorage}`);
+
+    // Step 2: find a free template VMID
+    gauge.addOutput('Finding a free template VMID (>= 9000)…');
+    const vmidResult = await findFreeTemplateVmid(credentials, nodeName);
+    if (!vmidResult.success) throw new Error(`VMID lookup failed: ${vmidResult.message}`);
+    vmid = vmidResult.data;
+    gauge.addOutput(`Using VMID ${vmid}`);
+
+    // Step 3: download cloud image to import storage
+    gauge.addOutput(
+      `Downloading Ubuntu 24.04 cloud image to '${importStorage}' (~600 MB, may take several minutes)…`,
+    );
+    const downloadResult = await downloadCloudImage(
+      credentials,
+      nodeName,
+      importStorage,
+      UBUNTU_2404_AMD64_URL,
+      UBUNTU_2404_AMD64_FILENAME,
+    );
+    if (!downloadResult.success) {
+      if (downloadResult.message.includes('403') || downloadResult.message.includes('not found')) {
+        throw new Error(
+          `Proxmox storage download-url endpoint rejected the request. Downloading to 'import' content requires Proxmox VE 8.2+. Error: ${downloadResult.message}`,
+        );
+      }
+      throw new Error(`Cloud image download failed: ${downloadResult.message}`);
+    }
+    gauge.addOutput('Waiting for download to complete…');
+    await pollTaskUntilDone(credentials, nodeName, downloadResult.data, 600_000);
+    gauge.addOutput('Cloud image downloaded');
+
+    // Step 4: create VM from cloud image
+    const imageVolid = buildCloudImageVolid(importStorage, UBUNTU_2404_AMD64_FILENAME);
+    gauge.addOutput(`Creating VM ${vmid} '${DEFAULT_TEMPLATE_NAME}' (importing disk)…`);
+    const createResult = await createVmFromCloudImage({
+      credentials,
+      nodeName,
+      vmid,
+      name: DEFAULT_TEMPLATE_NAME,
+      imageVolid,
+      diskStorage,
+    });
+    if (!createResult.success) {
+      throw new Error(`VM creation failed: ${createResult.message}`);
+    }
+    gauge.addOutput('Waiting for disk import to complete…');
+    await pollTaskUntilDone(credentials, nodeName, createResult.data, 120_000);
+    gauge.addOutput('VM created');
+
+    // Step 5: convert to template
+    gauge.addOutput(`Converting VM ${vmid} to a template…`);
+    const templateResult = await convertVmToTemplate(credentials, nodeName, vmid);
+    if (!templateResult.success) {
+      throw new Error(`Convert-to-template failed: ${templateResult.message}`);
+    }
+    await pollTaskUntilDone(credentials, nodeName, templateResult.data, 60_000);
+
+    gauge.stop(true);
+    return DEFAULT_TEMPLATE_NAME;
+  } catch (error) {
+    gauge.stop(false);
+
+    // Best-effort cleanup — remove the partially-created VM so the operator
+    // isn't left with a stranded guest.
+    if (vmid !== null) {
+      try {
+        const del = await deleteVm(credentials, nodeName, vmid);
+        if (del.success) {
+          console.log(`✗ Cleaned up VM ${vmid} after build failure`);
+        }
+      } catch {
+        console.log(`⚠ Could not clean up VM ${vmid} — delete it manually in the Proxmox UI`);
+      }
+    }
+
+    throw error;
+  }
+}

package/src/cli/commands/publish/alpha.test.ts

@@ -14,6 +14,7 @@ import {
   isAlphaVersion,
   parsePackageSpec,
   pickNextAlphaN,
+  prereleaseDistTag,
   stripAlphaSuffix,
 } from './alpha';
 
@@ -80,6 +81,31 @@ describe('isAlphaVersion', () => {
   });
 });
 
+describe('prereleaseDistTag (ISS-0083)', () => {
+  test('stable versions get no override → @latest', () => {
+    expect(prereleaseDistTag('0.5.0')).toBeUndefined();
+    expect(prereleaseDistTag('1.0.0')).toBeUndefined();
+    expect(prereleaseDistTag('10.20.30')).toBeUndefined();
+  });
+
+  test('prerelease versions derive their dist-tag from the identifier', () => {
+    expect(prereleaseDistTag('0.5.0-alpha.0')).toBe('alpha');
+    expect(prereleaseDistTag('0.5.0-alpha.3')).toBe('alpha');
+    expect(prereleaseDistTag('1.0.0-beta.2')).toBe('beta');
+    expect(prereleaseDistTag('1.0.0-rc.1')).toBe('rc');
+  });
+
+  test('prerelease without a dotted counter still yields its identifier', () => {
+    expect(prereleaseDistTag('1.0.0-alpha')).toBe('alpha');
+    expect(prereleaseDistTag('1.0.0-next')).toBe('next');
+  });
+
+  test('a prerelease NEVER maps to latest', () => {
+    expect(prereleaseDistTag('0.5.0-alpha.0')).not.toBe('latest');
+    expect(prereleaseDistTag('0.5.0-alpha.0')).not.toBeUndefined();
+  });
+});
+
 describe('pickNextAlphaN', () => {
   test('returns 0 when no alphas exist for the target core', () => {
     expect(pickNextAlphaN([], '0.7.14')).toBe(0);

package/src/cli/commands/publish/alpha.ts

@@ -52,6 +52,29 @@ export function isAlphaVersion(version: string): boolean {
   return /-alpha\.\d+$/.test(version);
 }
 
+/**
+ * ISS-0083: the npm dist-tag a version must publish under, derived from
+ * its semver prerelease identifier. A prerelease (e.g. `0.5.0-alpha.0`,
+ * `1.0.0-beta.2`, `1.0.0-rc.1`) MUST be tagged with its prerelease name
+ * (`alpha`/`beta`/`rc`/…), NEVER `latest` — otherwise `npm install <pkg>`
+ * (no tag) pulls a prerelease, and the prerelease tag the .deb resolves
+ * (`@celilo/cli@alpha`) goes stale. A stable version returns undefined
+ * (publish defaults to `latest`, which is correct for stable).
+ *
+ * The tag is the FIRST dot-separated token of the prerelease component:
+ *   0.5.0-alpha.0   → "alpha"
+ *   1.0.0-beta.2    → "beta"
+ *   1.0.0-rc.1      → "rc"
+ *   1.0.0           → undefined (→ latest)
+ */
+export function prereleaseDistTag(version: string): string | undefined {
+  const dash = version.indexOf('-');
+  if (dash === -1) return undefined;
+  const prerelease = version.slice(dash + 1);
+  const identifier = prerelease.split('.')[0];
+  return identifier || undefined;
+}
+
 /**
  * Pure inner of `nextAlphaNumber`. Given the full list of versions
  * for a package (whatever `npm view <name> versions --json` returned)

package/src/cli/commands/publish/types.ts

@@ -166,8 +166,13 @@ export interface WorkspaceItem {
    * `X.Y.Z-alpha.N` for alpha mode, base-stripped for promote mode.
    */
   versionToPublish: string;
-  /** npm dist-tag override (only `'alpha'` for alpha mode; undefined → `@latest`). */
-  tag?: 'alpha';
+  /**
+   * npm dist-tag override. `'alpha'` for alpha mode; for normal mode a
+   * prerelease version (e.g. `0.5.0-alpha.0`) derives its tag from the
+   * prerelease identifier (ISS-0083) so it never lands on `@latest`.
+   * undefined → `@latest` (only for stable versions).
+   */
+  tag?: string;
   /**
    * Rewrite recipe applied to the package's package.json immediately
    * before `bun publish`. Restored from `originalPackageJson` after.

package/src/cli/commands/publish/workspace.ts

@@ -29,7 +29,13 @@ import {
   writeFileSync,
 } from 'node:fs';
 import { join, relative } from 'node:path';
-import { ALPHA_TAG, alphaSkipDecision, nextAlphaNumber, stripAlphaSuffix } from './alpha';
+import {
+  ALPHA_TAG,
+  alphaSkipDecision,
+  nextAlphaNumber,
+  prereleaseDistTag,
+  stripAlphaSuffix,
+} from './alpha';
 import { REPO_ROOT, isPublished, readPkg } from './helpers';
 import type {
   PackageJson,
@@ -140,6 +146,10 @@ export function planWorkspace(opts: PlanWorkspaceInput): PlanWorkspaceOutput {
       workspaceVersions.set(name, versionToPublish);
     } else {
       versionToPublish = version;
+      // ISS-0083: a prerelease version in package.json (e.g. 0.5.0-alpha.0)
+      // must publish under its prerelease dist-tag, never `latest`. Only
+      // stable versions get `latest` (tag stays undefined).
+      tag = prereleaseDistTag(versionToPublish);
       if (isPublished(name, versionToPublish)) {
         skipReason = 'already published';
       }

package/src/cli/commands/restore.ts

@@ -93,9 +93,38 @@ export async function handleRestore(
     );
   }
 
+  // Re-register event-bus subscriptions from the restored modules' manifests.
+  // The bus (events.db) is NOT in the backup envelope, so a restore/migration
+  // starts with an EMPTY subscribers table — every event-driven reconcile (caddy
+  // public_web, dns register, namecheap's 15m DDNS refresh, …) is dormant until
+  // subscriptions are re-registered (ISS-0088). Reconstruct them from durable
+  // celilo.db state rather than requiring a redeploy of every module. Best-effort:
+  // the DB was just swapped + reopened, so on an unhappy reopen, point the
+  // operator at the standalone command (which runs in a fresh process).
+  let subsResynced: { modules: number; registered: number } | undefined;
+  try {
+    const { resyncAllSubscriptions } = await import('../../services/module-subscriptions');
+    const r = resyncAllSubscriptions();
+    subsResynced = { modules: r.modules, registered: r.registered };
+    if (r.failures.length > 0) {
+      log.warn(
+        `Re-registered ${r.registered} subscription(s); ${r.failures.length} module(s) failed — run \`celilo events resync-subscriptions\` to retry.`,
+      );
+    }
+  } catch (err) {
+    log.warn(
+      `Restore landed but event-bus subscriptions were not re-registered: ${err instanceof Error ? err.message : String(err)}. Event-driven reconciles stay dormant until you run \`celilo events resync-subscriptions\`.`,
+    );
+  }
+
   // Build the success message.
   const lines: string[] = ['Restore complete.'];
   if (result.systemDbApplied) lines.push('  • celilo.db swapped into place');
+  if (subsResynced) {
+    lines.push(
+      `  • re-registered ${subsResynced.registered} event-bus subscription(s) from ${subsResynced.modules} deployed module(s)`,
+    );
+  }
   if (result.masterKeyApplied) lines.push('  • master.key swapped into place');
   if (result.sshKeyApplied) lines.push('  • fleet SSH key restored to <data-dir>/.ssh/');
   if (result.moduleSourcesApplied && result.moduleSourcesApplied > 0) {