@celilo/cli 0.7.1 → 0.8.0

package/drizzle/meta/_journal.json

@@ -85,13 +85,6 @@
       "when": 1781481660000,
       "tag": "0011_backups_name",
       "breakpoints": true
-    },
-    {
-      "idx": 12,
-      "version": "6",
-      "when": 1781481720000,
-      "tag": "0012_module_systems_sizing",
-      "breakpoints": true
     }
   ]
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@celilo/cli",
-  "version": "0.7.1",
+  "version": "0.8.0",
   "description": "Celilo — home lab orchestration CLI",
   "type": "module",
   "bin": {
@@ -52,9 +52,9 @@
   },
   "dependencies": {
     "@aws-sdk/client-s3": "^3.1024.0",
-    "@celilo/capabilities": "^0.5.0",
-    "@celilo/cli-display": "^0.1.9",
-    "@celilo/event-bus": "^0.1.7",
+    "@celilo/capabilities": "workspace:^",
+    "@celilo/cli-display": "workspace:^",
+    "@celilo/event-bus": "workspace:^",
     "@clack/prompts": "^1.1.0",
     "ajv": "^8.18.0",
     "drizzle-orm": "^0.36.4",

package/src/api-clients/proxmox.ts

@@ -636,23 +636,6 @@ export class ProxmoxClient {
     if (!result.success) return result;
     return { success: true, data: findNodeForVmid(result.data, vmid) };
   }
-
-  /**
-   * Power-cycle a guest so PENDING config changes take effect (ISS-0150). A
-   * cpu/memory change Terraform writes to the VM config is "pending" until the
-   * QEMU process is recreated; `qm reboot` does a shutdown+start that applies it.
-   * Returns the UPID and waits for the task to finish.
-   */
-  async rebootVm(node: string, vmid: number): Promise<ProxmoxResult<string>> {
-    const res = await makeProxmoxPost<string>(
-      this.credentials,
-      `/nodes/${node}/qemu/${vmid}/status/reboot`,
-      {},
-    );
-    if (!res.success) return res;
-    await pollTaskUntilDone(this.credentials, node, res.data, 300_000);
-    return res;
-  }
 }
 
 /**

package/src/cli/command-registry.ts

@@ -1090,7 +1090,7 @@ export const COMMANDS: CommandDef[] = [
   },
   {
     name: 'proxmox',
-    description: 'Proxmox cluster introspection (nodes, capacity, instance sizing)',
+    description: 'Proxmox cluster introspection (nodes, capacity)',
     subcommands: [
       {
         name: 'node',
@@ -1103,70 +1103,6 @@ export const COMMANDS: CommandDef[] = [
           },
         ],
       },
-      {
-        name: 'vm',
-        description: 'celilo-provisioned VM sizing',
-        subcommands: [
-          {
-            name: 'list',
-            description: 'List celilo VMs with desired vs actual size',
-            args: [{ name: 'service-id', description: 'Proxmox service (optional if only one)' }],
-          },
-          {
-            name: 'resize',
-            description: 'Resize a celilo VM (canonical size + reconcile)',
-            args: [{ name: 'name', description: 'Instance name (module/hostname)' }],
-            flags: [
-              { name: 'memory', description: 'New RAM in MB', takesValue: true },
-              { name: 'cpu', description: 'New vCPU count', takesValue: true },
-              { name: 'force', description: 'Override the node capacity check', takesValue: false },
-              {
-                name: 'allow-reboot',
-                description: 'Approve the stop/start a resize needs',
-                takesValue: false,
-              },
-              { name: 'skip-backup', description: 'Skip the pre-resize backup', takesValue: false },
-              {
-                name: 'yes',
-                description: 'Auto-approve reboot + backup (headless)',
-                takesValue: false,
-              },
-            ],
-          },
-        ],
-      },
-      {
-        name: 'ct',
-        description: 'celilo-provisioned container (LXC) sizing',
-        subcommands: [
-          {
-            name: 'list',
-            description: 'List celilo containers with desired vs actual size',
-            args: [{ name: 'service-id', description: 'Proxmox service (optional if only one)' }],
-          },
-          {
-            name: 'resize',
-            description: 'Resize a celilo container (canonical size + reconcile)',
-            args: [{ name: 'name', description: 'Instance name (module/hostname)' }],
-            flags: [
-              { name: 'memory', description: 'New RAM in MB', takesValue: true },
-              { name: 'cpu', description: 'New vCPU count', takesValue: true },
-              { name: 'force', description: 'Override the node capacity check', takesValue: false },
-              {
-                name: 'allow-reboot',
-                description: 'Approve the stop/start a resize needs',
-                takesValue: false,
-              },
-              { name: 'skip-backup', description: 'Skip the pre-resize backup', takesValue: false },
-              {
-                name: 'yes',
-                description: 'Auto-approve reboot + backup (headless)',
-                takesValue: false,
-              },
-            ],
-          },
-        ],
-      },
     ],
   },
   {

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

@@ -0,0 +1,52 @@
+import { afterEach, beforeEach, describe, expect, it } from 'bun:test';
+import { mkdtemp, readFile, readdir, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { parseChangeset } from '../../module/versioning/changeset-version';
+import { handleModuleChangeset } from './module-changeset';
+
+let dir: string;
+beforeEach(async () => {
+  dir = await mkdtemp(join(tmpdir(), 'celilo-cs-'));
+  await writeFile(
+    join(dir, 'manifest.yml'),
+    'celilo_contract: "1.0"\nid: lunacycle\nversion: 1.0.0\n',
+  );
+});
+afterEach(async () => {
+  await rm(dir, { recursive: true, force: true });
+});
+
+describe('handleModuleChangeset', () => {
+  it('writes a changeset keyed by the module id that the engine can parse', async () => {
+    const res = await handleModuleChangeset([dir], { bump: 'minor', message: 'Added a view.' });
+    expect(res.success).toBe(true);
+
+    const files = (await readdir(join(dir, '.changeset'))).filter((f) => f.endsWith('.md'));
+    expect(files.length).toBe(1);
+    const parsed = parseChangeset(await readFile(join(dir, '.changeset', files[0]), 'utf-8'));
+    expect(parsed.bumps).toEqual({ lunacycle: 'minor' });
+    expect(parsed.summary).toBe('Added a view.');
+  });
+
+  it('honors an explicit --name and defaults the body', async () => {
+    await handleModuleChangeset([dir], { bump: 'patch', name: 'fix-thing' });
+    const parsed = parseChangeset(await readFile(join(dir, '.changeset', 'fix-thing.md'), 'utf-8'));
+    expect(parsed.bumps).toEqual({ lunacycle: 'patch' });
+    expect(parsed.summary.length).toBeGreaterThan(0);
+  });
+
+  it('rejects a missing or invalid bump', async () => {
+    expect((await handleModuleChangeset([dir], {})).success).toBe(false);
+    expect((await handleModuleChangeset([dir], { bump: 'huge' })).success).toBe(false);
+  });
+
+  it('errors when the manifest is unreadable', async () => {
+    const empty = await mkdtemp(join(tmpdir(), 'celilo-cs-empty-'));
+    try {
+      expect((await handleModuleChangeset([empty], { bump: 'patch' })).success).toBe(false);
+    } finally {
+      await rm(empty, { recursive: true, force: true });
+    }
+  });
+});

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

@@ -0,0 +1,65 @@
+/**
+ * `celilo module changeset [<module-dir>] --bump <major|minor|patch> [-m <msg>]`
+ * — author a changeset for a module (ISS-0151 / v2/MODULE_VERSIONING.md).
+ *
+ * Writes `.changeset/<name>.md` keyed by the MODULE id (Option A), the same
+ * on-disk format `celilo module version` consumes. This is the thin authoring
+ * helper that stands in for `bunx changeset add` (which is npm-package-centric
+ * and can't target a celilo module id).
+ */
+
+import { mkdir, writeFile } from 'node:fs/promises';
+import { join, resolve } from 'node:path';
+import { parse as parseYaml } from 'yaml';
+import { isBumpType } from '../../module/versioning/changeset-version';
+import { getFlag } from '../parser';
+import type { CommandResult } from '../types';
+
+/** A short, collision-resistant, filename-safe slug for the changeset file. */
+function changesetName(bump: string): string {
+  const rand = crypto.randomUUID().replace(/-/g, '').slice(0, 10);
+  return `${bump}-${rand}`;
+}
+
+export async function handleModuleChangeset(
+  args: string[],
+  flags: Record<string, string | boolean>,
+): Promise<CommandResult> {
+  const moduleDir = args[0] ?? '.';
+  const dir = resolve(moduleDir);
+
+  const bump = getFlag(flags, 'bump', '');
+  if (!isBumpType(bump)) {
+    return {
+      success: false,
+      error: 'A bump is required: --bump <major|minor|patch>',
+    };
+  }
+  const message = getFlag(flags, 'message', '');
+
+  let id: string;
+  try {
+    const manifest = parseYaml(await Bun.file(join(dir, 'manifest.yml')).text()) as { id?: string };
+    if (!manifest.id) {
+      return { success: false, error: `${moduleDir}: manifest.yml missing id` };
+    }
+    id = manifest.id;
+  } catch {
+    return { success: false, error: `${moduleDir}: could not read manifest.yml in ${dir}` };
+  }
+
+  const name = getFlag(flags, 'name', '') || changesetName(bump);
+  const body = message.trim() || `${bump} change to ${id}.`;
+  const content = `---\n"${id}": ${bump}\n---\n\n${body}\n`;
+
+  const changesetDir = join(dir, '.changeset');
+  await mkdir(changesetDir, { recursive: true });
+  const file = join(changesetDir, `${name}.md`);
+  await writeFile(file, content);
+
+  return {
+    success: true,
+    message: `Wrote .changeset/${name}.md (${id}: ${bump}).`,
+    data: { id, bump, file },
+  };
+}

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

@@ -61,6 +61,7 @@ interface ManifestForPublish extends ManifestForCapabilityCheck {
   id: string;
   version: string;
   description?: string;
+  version_source?: { kind?: string };
 }
 
 /**
@@ -164,7 +165,15 @@ export async function publishOneModule(
 
   // Stale-check: src commits past the last manifest.yml commit. Only fires
   // when the dir is in git history; brand-new uncommitted modules pass.
-  if (!opts.allowStale) {
+  //
+  // Skipped for changeset/pin modules (ISS-0151 / v2/MODULE_VERSIONING.md): a
+  // changeset module's version is authored via .changeset/ + `celilo module
+  // version` and ordered by +N, so source-after-manifest is normal, not drift;
+  // a pin module's version is checked against its upstream resolver. The gate
+  // stays for hand-maintained (recipe/unset) modules — the default.
+  const versionKind = manifest.version_source?.kind;
+  const staleGateApplies = versionKind !== 'changeset' && versionKind !== 'pin';
+  if (!opts.allowStale && staleGateApplies) {
     const stale = checkModuleStale(resolvedDir);
     if (stale) {
       return {

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

@@ -0,0 +1,118 @@
+import { afterEach, beforeEach, describe, expect, it } from 'bun:test';
+import { mkdir, mkdtemp, readFile, readdir, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { handleModuleVersion } from './module-version';
+
+let dir: string;
+
+const MANIFEST = (kind: string | null) =>
+  [
+    'celilo_contract: "1.0"',
+    'id: lunacycle',
+    'name: LunaCycle',
+    'version: 1.0.1   # keep this comment',
+    ...(kind ? ['version_source:', `  kind: ${kind}`] : []),
+    'description: an app',
+  ].join('\n');
+
+async function seed(kind: string | null, changesets: Record<string, string> = {}) {
+  await writeFile(join(dir, 'manifest.yml'), MANIFEST(kind));
+  await mkdir(join(dir, '.changeset'), { recursive: true });
+  await writeFile(join(dir, '.changeset', 'README.md'), '# Changesets\n');
+  for (const [name, body] of Object.entries(changesets)) {
+    await writeFile(join(dir, '.changeset', name), body);
+  }
+}
+
+beforeEach(async () => {
+  dir = await mkdtemp(join(tmpdir(), 'celilo-modver-'));
+});
+afterEach(async () => {
+  await rm(dir, { recursive: true, force: true });
+});
+
+describe('handleModuleVersion (changeset kind)', () => {
+  it('bumps the manifest version, writes CHANGELOG, consumes changesets', async () => {
+    await seed('changeset', {
+      'a.md': '---\n"lunacycle": minor\n---\n\nAdded tasks view.\n',
+      'b.md': '---\n"lunacycle": patch\n---\n\nFixed a typo.\n',
+    });
+
+    const res = await handleModuleVersion([dir], {});
+    expect(res.success).toBe(true);
+
+    const manifest = await readFile(join(dir, 'manifest.yml'), 'utf-8');
+    expect(manifest).toContain('version: 1.1.0'); // max(minor,patch) = minor
+    expect(manifest).toContain('# keep this comment'); // comment preserved? (line replaced, but others intact)
+    expect(manifest).toContain('kind: changeset');
+
+    const changelog = await readFile(join(dir, 'CHANGELOG.md'), 'utf-8');
+    expect(changelog).toContain('# lunacycle');
+    expect(changelog).toContain('## 1.1.0');
+    expect(changelog).toContain('### Minor Changes');
+    expect(changelog).toContain('- Added tasks view.');
+
+    const remaining = (await readdir(join(dir, '.changeset'))).filter((f) => f !== 'README.md');
+    expect(remaining).toEqual([]); // both consumed
+  });
+
+  it('prepends newest-on-top to an existing CHANGELOG', async () => {
+    await seed('changeset', { 'a.md': '---\nlunacycle: patch\n---\nfix\n' });
+    await writeFile(
+      join(dir, 'CHANGELOG.md'),
+      '# lunacycle\n\n## 1.0.1\n\n### Patch Changes\n\n- old\n',
+    );
+
+    await handleModuleVersion([dir], {});
+    const changelog = await readFile(join(dir, 'CHANGELOG.md'), 'utf-8');
+    expect(changelog.indexOf('## 1.0.2')).toBeLessThan(changelog.indexOf('## 1.0.1'));
+    expect(changelog.split('# lunacycle').length).toBe(2); // header not duplicated
+  });
+
+  it('is a clean no-op when no changeset targets the module', async () => {
+    await seed('changeset', { 'a.md': '---\nnigredo: minor\n---\nother app\n' });
+    const res = await handleModuleVersion([dir], {});
+    expect(res.success).toBe(true);
+    const manifest = await readFile(join(dir, 'manifest.yml'), 'utf-8');
+    expect(manifest).toContain('version: 1.0.1'); // unchanged
+    // the non-targeting changeset is left in place
+    expect((await readdir(join(dir, '.changeset'))).includes('a.md')).toBe(true);
+  });
+
+  it('is a clean no-op with no changesets at all', async () => {
+    await seed('changeset', {});
+    const res = await handleModuleVersion([dir], {});
+    expect(res.success).toBe(true);
+    expect(await readFile(join(dir, 'manifest.yml'), 'utf-8')).toContain('version: 1.0.1');
+  });
+
+  it('fails loudly on a malformed changeset', async () => {
+    await seed('changeset', { 'bad.md': 'no frontmatter here' });
+    const res = await handleModuleVersion([dir], {});
+    expect(res.success).toBe(false);
+  });
+});
+
+describe('handleModuleVersion (other kinds)', () => {
+  it('recipe kind is a no-op', async () => {
+    await seed('recipe', { 'a.md': '---\nlunacycle: minor\n---\nx\n' });
+    const res = await handleModuleVersion([dir], {});
+    expect(res.success).toBe(true);
+    expect(await readFile(join(dir, 'manifest.yml'), 'utf-8')).toContain('version: 1.0.1');
+  });
+
+  it('absent version_source defaults to recipe (no-op)', async () => {
+    await seed(null, { 'a.md': '---\nlunacycle: minor\n---\nx\n' });
+    const res = await handleModuleVersion([dir], {});
+    expect(res.success).toBe(true);
+    expect(await readFile(join(dir, 'manifest.yml'), 'utf-8')).toContain('version: 1.0.1');
+  });
+
+  it('pin kind is a not-yet-implemented notice (no change)', async () => {
+    await seed('pin', {});
+    const res = await handleModuleVersion([dir], {});
+    expect(res.success).toBe(true);
+    expect(res.success && res.message).toContain('pin');
+  });
+});

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

@@ -0,0 +1,155 @@
+/**
+ * `celilo module version [<module-dir>]` — stamp a changeset-kind module's
+ * payload version into manifest.yml (ISS-0151 / v2/MODULE_VERSIONING.md).
+ *
+ * Reads `.changeset/*.md` (keyed by the MODULE id — Option A), computes the next
+ * `manifest.yml#version`, prepends a CHANGELOG entry, and deletes the consumed
+ * changesets. It only edits the working tree — the caller (release.yml's version
+ * phase) commits the result and opens the "Version Packages" PR.
+ *
+ * Only `version_source.kind: changeset` is handled here. `pin` (wrapper modules)
+ * is a no-op-with-notice for now; `recipe` (and an absent block) has no
+ * changeset-driven version and is a clean no-op.
+ */
+
+import { readFile, readdir, unlink, writeFile } from 'node:fs/promises';
+import { join, resolve } from 'node:path';
+import { parse as parseYaml } from 'yaml';
+import {
+  parseChangeset,
+  planModuleVersion,
+  renderChangelogSection,
+} from '../../module/versioning/changeset-version';
+import type { CommandResult } from '../types';
+
+/** Replace the top-level `version:` line (column 0 — not nested capability versions). */
+function rewriteManifestVersion(raw: string, next: string): string {
+  if (!/^version:[ \t]*\S.*$/m.test(raw)) {
+    throw new Error('manifest.yml has no top-level `version:` line to rewrite');
+  }
+  // Replace only the value; keep the `version:` key prefix and any trailing
+  // comment so a targeted edit preserves the rest of the line.
+  return raw.replace(/^(version:[ \t]*)\S+(.*)$/m, `$1${next}$2`);
+}
+
+/** Prepend a new section below the `# <id>` header (creating the file if needed). */
+function updateChangelog(existing: string | null, moduleId: string, section: string): string {
+  const headerLine = `# ${moduleId}`;
+  if (existing?.startsWith(headerLine)) {
+    const rest = existing.slice(headerLine.length).replace(/^\n+/, '');
+    return `${headerLine}\n\n${section}\n${rest}`;
+  }
+  const tail = existing ? `\n${existing.trimStart()}` : '';
+  return `${headerLine}\n\n${section}${tail}`;
+}
+
+export async function handleModuleVersion(
+  args: string[],
+  _flags: Record<string, string | boolean>,
+): Promise<CommandResult> {
+  const moduleDir = args[0] ?? '.';
+  const dir = resolve(moduleDir);
+
+  let manifestRaw: string;
+  let id: string;
+  let version: string;
+  let kind: string;
+  try {
+    manifestRaw = await readFile(join(dir, 'manifest.yml'), 'utf-8');
+    const manifest = parseYaml(manifestRaw) as {
+      id?: string;
+      version?: string;
+      version_source?: { kind?: string };
+    };
+    if (!manifest.id || !manifest.version) {
+      return { success: false, error: `${moduleDir}: manifest.yml missing id or version` };
+    }
+    id = manifest.id;
+    version = manifest.version;
+    kind = manifest.version_source?.kind ?? 'recipe';
+  } catch {
+    return { success: false, error: `${moduleDir}: could not read manifest.yml in ${dir}` };
+  }
+
+  if (kind === 'pin') {
+    return {
+      success: true,
+      message: `${id}: version_source.kind=pin — resolver-based stamping not yet implemented (ISS-0151); leaving version ${version} unchanged.`,
+    };
+  }
+  if (kind !== 'changeset') {
+    return {
+      success: true,
+      message: `${id}: version_source.kind=${kind} — no changeset-driven version; ordered by the +N revision. Nothing to do.`,
+    };
+  }
+
+  // changeset kind: read .changeset/*.md (excluding README.md).
+  const changesetDir = join(dir, '.changeset');
+  let files: string[];
+  try {
+    files = (await readdir(changesetDir)).filter((f) => f.endsWith('.md') && f !== 'README.md');
+  } catch {
+    files = [];
+  }
+  if (files.length === 0) {
+    return { success: true, message: `${id}: no changesets — nothing to version (${version}).` };
+  }
+
+  // Parse, remembering which file each came from so we only delete consumed ones.
+  const parsed: { file: string; targetsModule: boolean; cs: ReturnType<typeof parseChangeset> }[] =
+    [];
+  for (const file of files) {
+    const content = await readFile(join(changesetDir, file), 'utf-8');
+    let cs: ReturnType<typeof parseChangeset>;
+    try {
+      cs = parseChangeset(content);
+    } catch (e) {
+      return {
+        success: false,
+        error: `${id}: malformed changeset ${file}: ${e instanceof Error ? e.message : String(e)}`,
+      };
+    }
+    parsed.push({ file, cs, targetsModule: id in cs.bumps });
+  }
+
+  const plan = planModuleVersion(
+    version,
+    id,
+    parsed.map((p) => p.cs),
+  );
+  if (!plan) {
+    return {
+      success: true,
+      message: `${id}: ${files.length} changeset(s) present but none target "${id}" — nothing to version (${version}).`,
+    };
+  }
+
+  // 1. Stamp the new version into manifest.yml (targeted line edit — comments preserved).
+  await writeFile(join(dir, 'manifest.yml'), rewriteManifestVersion(manifestRaw, plan.next));
+
+  // 2. Prepend the CHANGELOG section.
+  const changelogPath = join(dir, 'CHANGELOG.md');
+  let existingChangelog: string | null = null;
+  try {
+    existingChangelog = await readFile(changelogPath, 'utf-8');
+  } catch {
+    existingChangelog = null;
+  }
+  await writeFile(
+    changelogPath,
+    updateChangelog(existingChangelog, id, renderChangelogSection(plan)),
+  );
+
+  // 3. Consume the changesets that targeted this module.
+  const consumed = parsed.filter((p) => p.targetsModule);
+  for (const p of consumed) {
+    await unlink(join(changesetDir, p.file));
+  }
+
+  return {
+    success: true,
+    message: `${id}: ${plan.current} → ${plan.next} (${plan.bump}); consumed ${consumed.length} changeset(s), wrote CHANGELOG.md.`,
+    data: { id, from: plan.current, to: plan.next, bump: plan.bump },
+  };
+}

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

@@ -11,7 +11,6 @@ import { ProxmoxClient, type ProxmoxCredentials } from '../../api-clients/proxmo
 import { getServiceCredentials, listContainerServices } from '../../services/container-service';
 import { celiloIntro } from '../prompts';
 import type { CommandResult } from '../types';
-import { resolveProxmoxService } from './proxmox-service';
 
 function formatUptime(sec: number): string {
   if (sec <= 0) return '—';
@@ -20,6 +19,40 @@ function formatUptime(sec: number): string {
   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> = {},

package/src/cli/completion.ts

@@ -248,21 +248,13 @@ export async function getCompletions(words: string[], current: number): Promise<
   // Service subcommands
   // Proxmox subcommands
   if (command === 'proxmox' && currentIndex === 1) {
-    return filterSuggestions(['node', 'vm', 'ct'], args[1] || '');
+    return filterSuggestions(['node'], args[1] || '');
   }
   if (command === 'proxmox' && args[1] === 'node' && currentIndex === 2) {
     return filterSuggestions(['list'], args[2] || '');
   }
-  if (command === 'proxmox' && (args[1] === 'vm' || args[1] === 'ct') && currentIndex === 2) {
-    return filterSuggestions(['list', 'resize'], args[2] || '');
-  }
-  // proxmox <node|vm|ct> list <service-id> — proxmox services only
-  if (
-    command === 'proxmox' &&
-    (args[1] === 'node' || args[1] === 'vm' || args[1] === 'ct') &&
-    args[2] === 'list' &&
-    currentIndex === 3
-  ) {
+  // proxmox node list <service-id> — proxmox services only
+  if (command === 'proxmox' && args[1] === 'node' && args[2] === 'list' && currentIndex === 3) {
     const services = await listContainerServices();
     const serviceIds = services.filter((s) => s.providerName === 'proxmox').map((s) => s.serviceId);
     return filterSuggestions(serviceIds, args[3] || '');