@getmonoceros/workbench 1.8.0 → 1.9.1

package/dist/bin.js

@@ -251,25 +251,25 @@ function detectHelpRequest(argv, main2) {
   const separatorIdx = argv.indexOf("--");
   if (helpIdx === -1) return null;
   if (separatorIdx !== -1 && separatorIdx < helpIdx) return null;
-  const path16 = [];
+  const path17 = [];
   const tokens = argv.slice(
     0,
     separatorIdx === -1 ? argv.length : separatorIdx
   );
   let cursor = main2;
   const mainName = (main2.meta ?? {}).name ?? "monoceros";
-  path16.push(mainName);
+  path17.push(mainName);
   for (const tok of tokens) {
     if (tok.startsWith("-")) continue;
     const subs = cursor.subCommands ?? {};
     if (tok in subs) {
       cursor = subs[tok];
-      path16.push(tok);
+      path17.push(tok);
       continue;
     }
     break;
   }
-  return { path: path16, cmd: cursor };
+  return { path: path17, cmd: cursor };
 }
 async function maybeRenderHelp(argv, main2) {
   const hit = detectHelpRequest(argv, main2);
@@ -301,17 +301,17 @@ function getInnerArgs() {
 }
 
 // src/main.ts
-import { defineCommand as defineCommand28 } from "citty";
+import { defineCommand as defineCommand29 } from "citty";
 
 // src/commands/add-apt-packages.ts
 import { defineCommand } from "citty";
 import { consola as consola2 } from "consola";
 
 // src/modify/index.ts
-import { promises as fs7 } from "fs";
+import { promises as fs8 } from "fs";
 import { consola } from "consola";
 import { createPatch } from "diff";
-import path6 from "path";
+import path7 from "path";
 
 // src/config/io.ts
 import { promises as fs } from "fs";
@@ -1161,10 +1161,175 @@ ${existing}` : leakedComment;
   }
 }
 
+// src/init/components.ts
+import { existsSync as existsSync2, promises as fs4 } from "fs";
+import path3 from "path";
+import { z as z3 } from "zod";
+import { parse as parseYaml } from "yaml";
+var CategorySchema = z3.enum(["language", "service", "feature"]);
+var FeatureContributionSchema = z3.object({
+  ref: z3.string().regex(REGEX.featureRef),
+  options: z3.record(z3.string(), FeatureOptionValueSchema).optional()
+});
+var ComponentFileSchema = z3.object({
+  displayName: z3.string().min(1),
+  description: z3.string().min(1),
+  category: CategorySchema,
+  contributes: z3.object({
+    languages: z3.array(z3.string().min(1)).optional(),
+    services: z3.array(z3.string().min(1)).optional(),
+    features: z3.array(FeatureContributionSchema).optional()
+  })
+}).superRefine((data, ctx) => {
+  const c = data.contributes;
+  const filled = [
+    c.languages && c.languages.length > 0 ? "languages" : null,
+    c.services && c.services.length > 0 ? "services" : null,
+    c.features && c.features.length > 0 ? "features" : null
+  ].filter((x) => x !== null);
+  if (filled.length === 0) {
+    ctx.addIssue({
+      code: z3.ZodIssueCode.custom,
+      message: "contributes must set at least one of languages/services/features"
+    });
+    return;
+  }
+  if (filled.length > 1) {
+    ctx.addIssue({
+      code: z3.ZodIssueCode.custom,
+      message: `contributes must set exactly one of languages/services/features, got: ${filled.join(", ")}`
+    });
+    return;
+  }
+  const expected = data.category === "language" ? "languages" : data.category === "service" ? "services" : "features";
+  if (filled[0] !== expected) {
+    ctx.addIssue({
+      code: z3.ZodIssueCode.custom,
+      message: `category '${data.category}' requires contributes.${expected}, got contributes.${filled[0]}`
+    });
+  }
+});
+async function loadComponentCatalog(rootDir = componentsDir()) {
+  if (!existsSync2(rootDir)) {
+    return /* @__PURE__ */ new Map();
+  }
+  const out = /* @__PURE__ */ new Map();
+  await walk(rootDir, rootDir, out);
+  return out;
+}
+async function walk(baseDir, currentDir, out) {
+  const entries = await fs4.readdir(currentDir, { withFileTypes: true });
+  for (const entry2 of entries) {
+    const full = path3.join(currentDir, entry2.name);
+    if (entry2.isDirectory()) {
+      await walk(baseDir, full, out);
+      continue;
+    }
+    if (!entry2.isFile() || !entry2.name.endsWith(".yml")) continue;
+    const relative = path3.relative(baseDir, full);
+    const name = relative.replace(/\.yml$/, "").split(path3.sep).join("/");
+    const text = await fs4.readFile(full, "utf8");
+    let raw;
+    try {
+      raw = parseYaml(text);
+    } catch (err) {
+      throw new Error(
+        `Failed to parse component ${name} (${full}): ${err.message}`
+      );
+    }
+    const parsed = ComponentFileSchema.safeParse(raw);
+    if (!parsed.success) {
+      const issues = parsed.error.issues.map((issue) => {
+        const where = issue.path.length > 0 ? issue.path.join(".") : "(root)";
+        return `  - ${where}: ${issue.message}`;
+      }).join("\n");
+      throw new Error(`Invalid component ${name} (${full}):
+${issues}`);
+    }
+    out.set(name, { name, sourcePath: full, file: parsed.data });
+  }
+}
+function mergeComponents(resolved) {
+  const languages = [];
+  const services = [];
+  const featureByRef = /* @__PURE__ */ new Map();
+  for (const entry2 of resolved) {
+    const c = isResolvedComponent(entry2) ? entry2.component : entry2;
+    const version = isResolvedComponent(entry2) ? entry2.version : void 0;
+    const ct = c.file.contributes;
+    for (const lang of ct.languages ?? []) {
+      const value = version !== void 0 ? `${lang}:${version}` : lang;
+      if (!languages.includes(value)) languages.push(value);
+    }
+    for (const svc of ct.services ?? []) {
+      if (!services.includes(svc)) services.push(svc);
+    }
+    for (const f of ct.features ?? []) {
+      const existing = featureByRef.get(f.ref);
+      if (!existing) {
+        featureByRef.set(f.ref, {
+          ref: f.ref,
+          options: { ...f.options ?? {} }
+        });
+        continue;
+      }
+      existing.options = mergeFeatureOptions(existing.options, f.options ?? {});
+    }
+  }
+  return {
+    languages,
+    services,
+    features: [...featureByRef.values()]
+  };
+}
+function isResolvedComponent(x) {
+  return "component" in x;
+}
+function mergeFeatureOptions(a, b) {
+  const result = { ...a };
+  for (const [key, valueB] of Object.entries(b)) {
+    const valueA = result[key];
+    if (typeof valueA === "boolean" && typeof valueB === "boolean") {
+      result[key] = valueA || valueB;
+      continue;
+    }
+    result[key] = valueB;
+  }
+  return result;
+}
+function resolveComponents(catalog, names) {
+  const unknown = [];
+  const out = [];
+  for (const raw of names) {
+    const colon = raw.indexOf(":");
+    const name = colon === -1 ? raw : raw.slice(0, colon);
+    const version = colon === -1 ? void 0 : raw.slice(colon + 1);
+    const c = catalog.get(name);
+    if (!c) {
+      unknown.push(raw);
+      continue;
+    }
+    if (version !== void 0 && c.file.category !== "language") {
+      throw new Error(
+        `Component '${name}' is a ${c.file.category}, not a language \u2014 a ':${version}' suffix has no meaning here.`
+      );
+    }
+    out.push({ component: c, ...version !== void 0 ? { version } : {} });
+  }
+  if (unknown.length > 0) {
+    const available = [...catalog.keys()].sort();
+    throw new Error(
+      `Unknown component${unknown.length > 1 ? "s" : ""}: ${unknown.join(", ")}.
+Available: ${available.join(", ")}.`
+    );
+  }
+  return out;
+}
+
 // src/proxy/index.ts
 import { spawn as spawn3 } from "child_process";
-import { promises as fs4 } from "fs";
-import path3 from "path";
+import { promises as fs5 } from "fs";
+import path4 from "path";
 var PROXY_CONTAINER_NAME = "monoceros-proxy";
 var PROXY_NETWORK_NAME = "monoceros-proxy";
 var TRAEFIK_IMAGE = "traefik:v3.3";
@@ -1190,12 +1355,12 @@ var defaultDockerExec = (args) => {
 };
 var realDocker = defaultDockerExec;
 function proxyDynamicDir(home) {
-  return path3.join(home ?? monocerosHome(), "traefik", "dynamic");
+  return path4.join(home ?? monocerosHome(), "traefik", "dynamic");
 }
 async function ensureProxy(opts = {}) {
   const docker = opts.docker ?? realDocker;
   const dyn = proxyDynamicDir(opts.monocerosHome);
-  await fs4.mkdir(dyn, { recursive: true });
+  await fs5.mkdir(dyn, { recursive: true });
   const netInspect = await docker(["network", "inspect", PROXY_NETWORK_NAME]);
   if (netInspect.exitCode !== 0) {
     const create = await docker(["network", "create", PROXY_NETWORK_NAME]);
@@ -1281,8 +1446,8 @@ async function maybeStopProxy(opts = {}) {
 }
 
 // src/proxy/dynamic.ts
-import { promises as fs5 } from "fs";
-import path4 from "path";
+import { promises as fs6 } from "fs";
+import path5 from "path";
 async function writeDynamicConfig(name, ports, opts = {}) {
   if (ports.length === 0) {
     throw new Error(
@@ -1290,14 +1455,14 @@ async function writeDynamicConfig(name, ports, opts = {}) {
     );
   }
   const dir = proxyDynamicDir(opts.monocerosHome);
-  await fs5.mkdir(dir, { recursive: true });
-  const file = path4.join(dir, `${name}.yml`);
-  await fs5.writeFile(file, renderDynamicConfig(name, ports), "utf8");
+  await fs6.mkdir(dir, { recursive: true });
+  const file = path5.join(dir, `${name}.yml`);
+  await fs6.writeFile(file, renderDynamicConfig(name, ports), "utf8");
   return file;
 }
 async function removeDynamicConfig(name, opts = {}) {
-  const file = path4.join(proxyDynamicDir(opts.monocerosHome), `${name}.yml`);
-  await fs5.rm(file, { force: true });
+  const file = path5.join(proxyDynamicDir(opts.monocerosHome), `${name}.yml`);
+  await fs6.rm(file, { force: true });
 }
 function renderDynamicConfig(name, ports) {
   const lines = [];
@@ -1498,8 +1663,8 @@ function knownServices() {
 }
 
 // src/create/scaffold.ts
-import { existsSync as existsSync2, readFileSync, promises as fs6 } from "fs";
-import path5 from "path";
+import { existsSync as existsSync3, readFileSync, promises as fs7 } from "fs";
+import path6 from "path";
 
 // src/util/ref.ts
 var FEATURE_NAME_CHARSET = "[a-z0-9._-]+";
@@ -1670,8 +1835,8 @@ function resolveFeatures(opts) {
       if (match) {
         const name = match.name;
         const checkout = workbenchCheckoutRoot();
-        const localSourceDir = checkout ? path5.join(checkout, "images", "features", name) : null;
-        if (localSourceDir && existsSync2(localSourceDir)) {
+        const localSourceDir = checkout ? path6.join(checkout, "images", "features", name) : null;
+        if (localSourceDir && existsSync3(localSourceDir)) {
           const { paths, files } = readPersistentHomeEntries(localSourceDir);
           resolved.push({
             devcontainerKey: `./features/${name}`,
@@ -1695,7 +1860,7 @@ function resolveFeatures(opts) {
   return resolved;
 }
 function readPersistentHomeEntries(localSourceDir) {
-  const manifestPath = path5.join(localSourceDir, "devcontainer-feature.json");
+  const manifestPath = path6.join(localSourceDir, "devcontainer-feature.json");
   try {
     const text = readFileSync(manifestPath, "utf8");
     const parsed = JSON.parse(text);
@@ -1980,86 +2145,86 @@ function buildPostCreateScript(opts) {
   return lines.join("\n") + "\n";
 }
 async function writePostCreateScript(devcontainerDir, opts) {
-  const dest = path5.join(devcontainerDir, "post-create.sh");
-  await fs6.writeFile(dest, buildPostCreateScript(opts));
-  await fs6.chmod(dest, 493);
+  const dest = path6.join(devcontainerDir, "post-create.sh");
+  await fs7.writeFile(dest, buildPostCreateScript(opts));
+  await fs7.chmod(dest, 493);
 }
 async function writeScaffold(opts, targetDir, scaffoldOpts = {}) {
   const dockerMode = scaffoldOpts.dockerMode ?? "rootful";
-  const devcontainerDir = path5.join(targetDir, ".devcontainer");
-  const monocerosDir = path5.join(targetDir, ".monoceros");
-  const projectsDir = path5.join(targetDir, "projects");
-  const homeDir = path5.join(targetDir, "home");
-  const dataDir = path5.join(targetDir, "data");
-  await fs6.mkdir(devcontainerDir, { recursive: true });
-  await fs6.mkdir(monocerosDir, { recursive: true });
-  await fs6.mkdir(projectsDir, { recursive: true });
-  await fs6.mkdir(homeDir, { recursive: true });
+  const devcontainerDir = path6.join(targetDir, ".devcontainer");
+  const monocerosDir = path6.join(targetDir, ".monoceros");
+  const projectsDir = path6.join(targetDir, "projects");
+  const homeDir = path6.join(targetDir, "home");
+  const dataDir = path6.join(targetDir, "data");
+  await fs7.mkdir(devcontainerDir, { recursive: true });
+  await fs7.mkdir(monocerosDir, { recursive: true });
+  await fs7.mkdir(projectsDir, { recursive: true });
+  await fs7.mkdir(homeDir, { recursive: true });
   if (needsCompose(opts)) {
-    await fs6.mkdir(dataDir, { recursive: true });
+    await fs7.mkdir(dataDir, { recursive: true });
     for (const svcId of opts.services) {
       const def = SERVICE_CATALOG[svcId];
       if (def?.dataMount) {
-        await fs6.mkdir(path5.join(dataDir, def.id), { recursive: true });
+        await fs7.mkdir(path6.join(dataDir, def.id), { recursive: true });
       }
     }
   }
-  const containerGitignore = path5.join(targetDir, ".gitignore");
-  await fs6.writeFile(containerGitignore, "/home/\n/.monoceros/\n/data/\n");
-  const gitkeep = path5.join(projectsDir, ".gitkeep");
-  if (!existsSync2(gitkeep)) {
-    await fs6.writeFile(gitkeep, "");
+  const containerGitignore = path6.join(targetDir, ".gitignore");
+  await fs7.writeFile(containerGitignore, "/home/\n/.monoceros/\n/data/\n");
+  const gitkeep = path6.join(projectsDir, ".gitkeep");
+  if (!existsSync3(gitkeep)) {
+    await fs7.writeFile(gitkeep, "");
   }
-  await fs6.writeFile(
-    path5.join(monocerosDir, ".gitignore"),
+  await fs7.writeFile(
+    path6.join(monocerosDir, ".gitignore"),
     "git-credentials*\ngitconfig\n"
   );
   const devcontainerJson = buildDevcontainerJson(opts, dockerMode);
-  await fs6.writeFile(
-    path5.join(devcontainerDir, "devcontainer.json"),
+  await fs7.writeFile(
+    path6.join(devcontainerDir, "devcontainer.json"),
     JSON.stringify(devcontainerJson, null, 2) + "\n"
   );
-  const featuresDir = path5.join(devcontainerDir, "features");
-  if (existsSync2(featuresDir)) {
-    await fs6.rm(featuresDir, { recursive: true, force: true });
+  const featuresDir = path6.join(devcontainerDir, "features");
+  if (existsSync3(featuresDir)) {
+    await fs7.rm(featuresDir, { recursive: true, force: true });
   }
   const resolvedFeatures = resolveFeatures(opts);
   for (const f of resolvedFeatures) {
     if (!f.localSourceDir || !f.localName) continue;
-    const dest = path5.join(featuresDir, f.localName);
-    await fs6.mkdir(dest, { recursive: true });
-    await fs6.cp(f.localSourceDir, dest, { recursive: true });
+    const dest = path6.join(featuresDir, f.localName);
+    await fs7.mkdir(dest, { recursive: true });
+    await fs7.cp(f.localSourceDir, dest, { recursive: true });
   }
   for (const f of resolvedFeatures) {
     for (const sub of f.persistentHomePaths) {
-      await fs6.mkdir(path5.join(homeDir, sub), { recursive: true });
+      await fs7.mkdir(path6.join(homeDir, sub), { recursive: true });
     }
     for (const entry2 of f.persistentHomeFiles) {
-      const filePath = path5.join(homeDir, entry2.path);
-      await fs6.mkdir(path5.dirname(filePath), { recursive: true });
-      if (!existsSync2(filePath)) {
-        await fs6.writeFile(filePath, entry2.initialContent);
+      const filePath = path6.join(homeDir, entry2.path);
+      await fs7.mkdir(path6.dirname(filePath), { recursive: true });
+      if (!existsSync3(filePath)) {
+        await fs7.writeFile(filePath, entry2.initialContent);
       }
     }
   }
   await writePostCreateScript(devcontainerDir, opts);
-  const composePath = path5.join(devcontainerDir, "compose.yaml");
+  const composePath = path6.join(devcontainerDir, "compose.yaml");
   if (needsCompose(opts)) {
-    await fs6.writeFile(composePath, buildComposeYaml(opts, dockerMode));
-  } else if (existsSync2(composePath)) {
-    await fs6.rm(composePath);
+    await fs7.writeFile(composePath, buildComposeYaml(opts, dockerMode));
+  } else if (existsSync3(composePath)) {
+    await fs7.rm(composePath);
   }
-  const workspacePath = path5.join(targetDir, `${opts.name}.code-workspace`);
+  const workspacePath = path6.join(targetDir, `${opts.name}.code-workspace`);
   let existingWorkspace;
   try {
-    const raw = await fs6.readFile(workspacePath, "utf8");
+    const raw = await fs7.readFile(workspacePath, "utf8");
     existingWorkspace = JSON.parse(raw);
   } catch {
     existingWorkspace = void 0;
   }
   const generated = buildCodeWorkspaceJson(opts);
   const merged = mergeCodeWorkspace(existingWorkspace, generated);
-  await fs6.writeFile(workspacePath, JSON.stringify(merged, null, 2) + "\n");
+  await fs7.writeFile(workspacePath, JSON.stringify(merged, null, 2) + "\n");
 }
 
 // src/modify/yml.ts
@@ -2417,8 +2582,8 @@ function removeRepoFromDoc(doc, urlOrPath) {
     if (!isMap2(item)) return false;
     const url = item.get("url");
     if (url === urlOrPath) return true;
-    const path16 = item.get("path");
-    const effectivePath = typeof path16 === "string" ? path16 : typeof url === "string" ? deriveRepoName(url) : void 0;
+    const path17 = item.get("path");
+    const effectivePath = typeof path17 === "string" ? path17 : typeof url === "string" ? deriveRepoName(url) : void 0;
     return effectivePath === urlOrPath;
   });
   if (idx < 0) return false;
@@ -2468,7 +2633,7 @@ async function runAddRepo(input) {
       "Missing repo URL. Usage: monoceros add-repo <containername> <url>."
     );
   }
-  const path16 = (input.path ?? deriveRepoName(url)).trim();
+  const path17 = (input.path ?? deriveRepoName(url)).trim();
   const hasName = typeof input.gitName === "string" && input.gitName.trim().length > 0;
   const hasEmail = typeof input.gitEmail === "string" && input.gitEmail.trim().length > 0;
   if (hasName !== hasEmail) {
@@ -2497,7 +2662,7 @@ async function runAddRepo(input) {
   const providerToWrite = !canonical && explicitProvider ? explicitProvider : void 0;
   const entry2 = {
     url,
-    path: path16,
+    path: path17,
     ...hasName && hasEmail ? {
       gitUser: {
         name: input.gitName.trim(),
@@ -2573,14 +2738,14 @@ async function tryCloneInRunningContainer(input, entry2) {
     );
     return;
   }
-  const containerName = input.name;
+  const containerName2 = input.name;
   const targetRel = `projects/${entry2.path}`;
   const parentRel = entry2.path.includes("/") ? `projects/${entry2.path.split("/").slice(0, -1).join("/")}` : "projects";
-  const credentialsFile = `/workspaces/${containerName}/.monoceros/git-credentials`;
+  const credentialsFile = `/workspaces/${containerName2}/.monoceros/git-credentials`;
   const credentialHelper = `store --file=${credentialsFile}`;
   const script = [
     `set -eu`,
-    `cd /workspaces/${containerName}`,
+    `cd /workspaces/${containerName2}`,
     `if [ -d ${shquote(targetRel)} ]; then`,
     `  echo "[add-repo] ${targetRel} already exists \u2014 skipping clone."`,
     `  exit 0`,
@@ -2611,9 +2776,9 @@ async function tryCloneInRunningContainer(input, entry2) {
     return;
   }
   logger.info(
-    `Cloned ${entry2.url} into /workspaces/${containerName}/${targetRel} inside the running container.`
+    `Cloned ${entry2.url} into /workspaces/${containerName2}/${targetRel} inside the running container.`
   );
-  void path6;
+  void path7;
 }
 function shquote(value) {
   return `'${value.replace(/'/g, `'\\''`)}'`;
@@ -2678,14 +2843,56 @@ function normalizePorts(raw) {
   }
   return result;
 }
-function runAddFeature(input) {
-  const ref = input.ref.trim();
-  if (ref.length === 0) {
+async function runAddFeature(input) {
+  const raw = input.ref.trim();
+  if (raw.length === 0) {
+    throw new Error(
+      "Missing feature ref. Usage: monoceros add-feature <containername> <feature>."
+    );
+  }
+  const resolved = await resolveFeatureRefOrShortname(raw);
+  const merged = {
+    ...resolved.defaultOptions,
+    ...input.options ?? {}
+  };
+  return mutate(input, (doc) => addFeatureToDoc(doc, resolved.ref, merged));
+}
+async function resolveFeatureRefOrShortname(input) {
+  if (REGEX.featureRef.test(input)) {
+    return { ref: input, defaultOptions: {} };
+  }
+  const catalog = await loadComponentCatalog();
+  const component = catalog.get(input);
+  if (!component) {
+    const featureShorts = [...catalog.values()].filter((c) => c.file.category === "feature").map((c) => c.name).sort();
+    const knownList = featureShorts.length > 0 ? featureShorts.join(", ") : "(none)";
+    throw new Error(
+      `Unknown feature: ${JSON.stringify(input)}. Pass either a catalog short-name (one of: ${knownList}) or a full OCI ref like 'ghcr.io/getmonoceros/monoceros-features/<name>:<tag>'.`
+    );
+  }
+  if (component.file.category !== "feature") {
+    throw new Error(
+      `'${input}' is a ${component.file.category}, not a feature. Use 'monoceros add-${component.file.category} <name> ${input}' instead.`
+    );
+  }
+  const features = component.file.contributes.features ?? [];
+  if (features.length === 0) {
     throw new Error(
-      "Missing feature ref. Usage: monoceros add-feature <containername> <ref>."
+      `Catalog entry '${input}' contributes no feature ref \u2014 bug or stale catalog.`
     );
   }
-  return mutate(input, (doc) => addFeatureToDoc(doc, ref, input.options ?? {}));
+  if (features.length > 1) {
+    throw new Error(
+      `'${input}' bundles multiple feature refs (${features.map((f) => f.ref).join(
+        ", "
+      )}). add-feature handles one at a time \u2014 pass the OCI ref directly.`
+    );
+  }
+  const [first] = features;
+  return {
+    ref: first.ref,
+    defaultOptions: { ...first.options ?? {} }
+  };
 }
 function runRemoveLanguage(input) {
   return mutate(input, (doc) => removeLanguageFromDoc(doc, input.language));
@@ -2752,7 +2959,7 @@ async function mutate(opts, apply) {
   const logger = opts.logger ?? defaultLogger();
   let oldText;
   try {
-    oldText = await fs7.readFile(ymlPath, "utf8");
+    oldText = await fs8.readFile(ymlPath, "utf8");
   } catch {
     throw new Error(
       `No such config: ${ymlPath}. Run \`monoceros init <template> ${opts.name}\` first.`
@@ -2776,7 +2983,7 @@ async function mutate(opts, apply) {
       return { status: "aborted" };
     }
   }
-  await fs7.writeFile(ymlPath, newText, "utf8");
+  await fs8.writeFile(ymlPath, newText, "utf8");
   logger.success(`Updated ${ymlPath}.`);
   logger.info(
     `Run \`monoceros apply ${opts.name}\` to rebuild the dev-container and pick up the change.`
@@ -2912,7 +3119,7 @@ var addFeatureCommand = defineCommand2({
     },
     ref: {
       type: "positional",
-      description: "Devcontainer feature ref (OCI image style, e.g. `ghcr.io/devcontainers/features/docker-in-docker:2`).",
+      description: "Feature to add. Either a Monoceros catalog short-name (e.g. `atlassian`, `atlassian/twg`, `claude` \u2014 see `monoceros list-components`) or a full OCI feature ref (e.g. `ghcr.io/devcontainers/features/docker-in-docker:2`). The short-name brings its catalog-defined default options; `-- key=value` overrides them.",
       required: true
     },
     yes: {
@@ -3245,12 +3452,12 @@ var addServiceCommand = defineCommand7({
 import { defineCommand as defineCommand8 } from "citty";
 
 // src/apply/index.ts
-import { existsSync as existsSync4, promises as fs10 } from "fs";
+import { existsSync as existsSync5, promises as fs11 } from "fs";
 import { consola as consola11 } from "consola";
 
 // src/config/state.ts
-import { promises as fs8 } from "fs";
-import path7 from "path";
+import { promises as fs9 } from "fs";
+import path8 from "path";
 function buildStateFile(opts) {
   return {
     schemaVersion: CONFIG_SCHEMA_VERSION,
@@ -3260,20 +3467,20 @@ function buildStateFile(opts) {
   };
 }
 function stateFilePath(targetDir) {
-  return path7.join(targetDir, ".monoceros", "state.json");
+  return path8.join(targetDir, ".monoceros", "state.json");
 }
 async function readStateFile(targetDir) {
   try {
-    const content = await fs8.readFile(stateFilePath(targetDir), "utf8");
+    const content = await fs9.readFile(stateFilePath(targetDir), "utf8");
     return JSON.parse(content);
   } catch {
     return void 0;
   }
 }
 async function writeStateFile(targetDir, state) {
-  const monocerosDir = path7.join(targetDir, ".monoceros");
-  await fs8.mkdir(monocerosDir, { recursive: true });
-  await fs8.writeFile(
+  const monocerosDir = path8.join(targetDir, ".monoceros");
+  await fs9.mkdir(monocerosDir, { recursive: true });
+  await fs9.writeFile(
     stateFilePath(targetDir),
     JSON.stringify(state, null, 2) + "\n"
   );
@@ -3343,8 +3550,8 @@ function solutionConfigToCreateOptions(config, featureDefaults = {}) {
 
 // src/devcontainer/compose.ts
 import { spawn as spawn5 } from "child_process";
-import { existsSync as existsSync3 } from "fs";
-import path9 from "path";
+import { existsSync as existsSync4 } from "fs";
+import path10 from "path";
 import { consola as consola9 } from "consola";
 
 // src/util/mask-secrets.ts
@@ -3407,7 +3614,7 @@ function createSecretMaskStream() {
 import { spawn as spawn4 } from "child_process";
 import { readFileSync as readFileSync2 } from "fs";
 import { createRequire } from "module";
-import path8 from "path";
+import path9 from "path";
 var require_ = createRequire(import.meta.url);
 var cachedBinaryPath = null;
 function devcontainerCliPath() {
@@ -3418,7 +3625,7 @@ function devcontainerCliPath() {
   if (!binEntry) {
     throw new Error("Could not resolve @devcontainers/cli bin entry.");
   }
-  cachedBinaryPath = path8.resolve(path8.dirname(pkgJsonPath), binEntry);
+  cachedBinaryPath = path9.resolve(path9.dirname(pkgJsonPath), binEntry);
   return cachedBinaryPath;
 }
 var spawnDevcontainer = (args, cwd, options = {}) => {
@@ -3490,16 +3697,16 @@ var spawnBash = (args, cwd) => {
   });
 };
 function composeProjectName(root) {
-  return `${path9.basename(root)}_devcontainer`;
+  return `${path10.basename(root)}_devcontainer`;
 }
 function resolveCompose(root) {
-  if (!existsSync3(path9.join(root, ".devcontainer"))) {
+  if (!existsSync4(path10.join(root, ".devcontainer"))) {
     throw new Error(
       `No .devcontainer/ at ${root}. Run \`monoceros apply <name>\` first.`
     );
   }
-  const composeFile = path9.join(root, ".devcontainer", "compose.yaml");
-  if (!existsSync3(composeFile)) {
+  const composeFile = path10.join(root, ".devcontainer", "compose.yaml");
+  if (!existsSync4(composeFile)) {
     throw new Error(
       `No compose.yaml at ${composeFile}. \`start\` / \`stop\` / \`status\` / \`logs\` require services configured via \`monoceros add-service <name> <svc>\`. Use \`monoceros shell <name>\` to enter the container directly.`
     );
@@ -3793,8 +4000,8 @@ function formatRootlessNotSupportedError() {
 
 // src/devcontainer/identity.ts
 import { spawn as spawn8 } from "child_process";
-import { promises as fs9 } from "fs";
-import path10 from "path";
+import { promises as fs10 } from "fs";
+import path11 from "path";
 import { consola as consola10 } from "consola";
 var realGitConfigGet = (key) => {
   return new Promise((resolve, reject) => {
@@ -3908,8 +4115,8 @@ async function resolveIdentityWithPrompt(options = {}) {
   };
 }
 async function collectGitIdentity(devContainerRoot, options = {}) {
-  const gitconfigDir = path10.join(devContainerRoot, ".monoceros");
-  const gitconfigPath = path10.join(gitconfigDir, "gitconfig");
+  const gitconfigDir = path11.join(devContainerRoot, ".monoceros");
+  const gitconfigPath = path11.join(gitconfigDir, "gitconfig");
   const logger = options.logger ?? { info: () => {
   }, warn: () => {
   } };
@@ -3922,8 +4129,8 @@ async function collectGitIdentity(devContainerRoot, options = {}) {
   const lines = ["[user]"];
   if (resolved.name !== void 0) lines.push(`	name = ${resolved.name}`);
   if (resolved.email !== void 0) lines.push(`	email = ${resolved.email}`);
-  await fs9.mkdir(gitconfigDir, { recursive: true });
-  await fs9.writeFile(gitconfigPath, lines.join("\n") + "\n");
+  await fs10.mkdir(gitconfigDir, { recursive: true });
+  await fs10.writeFile(gitconfigPath, lines.join("\n") + "\n");
   return {
     ...resolved.name !== void 0 ? { name: resolved.name } : {},
     ...resolved.email !== void 0 ? { email: resolved.email } : {},
@@ -3966,7 +4173,7 @@ async function readKeyFromHost(spawnFn, key, logger) {
 }
 async function readExistingGitconfig(filePath) {
   try {
-    const content = await fs9.readFile(filePath, "utf8");
+    const content = await fs10.readFile(filePath, "utf8");
     const result = {};
     const nameMatch = /^\s*name\s*=\s*(.+?)\s*$/m.exec(content);
     const emailMatch = /^\s*email\s*=\s*(.+?)\s*$/m.exec(content);
@@ -3999,7 +4206,7 @@ ${sectionLine(label)}
     );
   }
   const ymlPath = containerConfigPath(opts.name, home);
-  if (!existsSync4(ymlPath)) {
+  if (!existsSync5(ymlPath)) {
     throw new Error(
       `No such config: ${ymlPath}. Run \`monoceros init <template> ${opts.name}\` first.`
     );
@@ -4070,7 +4277,7 @@ ${sectionLine(label)}
   if (dockerMode === "rootless") {
     throw new Error(formatRootlessNotSupportedError());
   }
-  await fs10.mkdir(targetDir, { recursive: true });
+  await fs11.mkdir(targetDir, { recursive: true });
   await writeScaffold(createOpts, targetDir, { dockerMode });
   await writeStateFile(
     targetDir,
@@ -4128,8 +4335,8 @@ ${sectionLine(label)}
   return { targetDir, configPath: ymlPath, containerExitCode: exitCode };
 }
 async function assertSafeTargetDir(targetDir, expectedOrigin) {
-  if (!existsSync4(targetDir)) return;
-  const entries = await fs10.readdir(targetDir);
+  if (!existsSync5(targetDir)) return;
+  const entries = await fs11.readdir(targetDir);
   if (entries.length === 0) return;
   const state = await readStateFile(targetDir);
   if (state) {
@@ -4199,7 +4406,7 @@ async function persistPromptedIdentity(prompted, ymlPath, home, logger) {
   }
   if (wantContainer) {
     try {
-      const text = await fs10.readFile(ymlPath, "utf8");
+      const text = await fs11.readFile(ymlPath, "utf8");
       const parsed = parseConfig(text, ymlPath);
       const changed = setContainerGitUserInDoc(parsed.doc, {
         name: prompted.name,
@@ -4207,7 +4414,7 @@ async function persistPromptedIdentity(prompted, ymlPath, home, logger) {
       });
       if (changed) {
         const out = stringifyConfig(parsed.doc);
-        await fs10.writeFile(ymlPath, out, "utf8");
+        await fs11.writeFile(ymlPath, out, "utf8");
         logger.info(
           `Saved identity in this container \u2014 wrote git.user into ${prettyPath(ymlPath)}.`
         );
@@ -4221,7 +4428,7 @@ async function persistPromptedIdentity(prompted, ymlPath, home, logger) {
 }
 
 // src/version.ts
-var CLI_VERSION = true ? "1.8.0" : "dev";
+var CLI_VERSION = true ? "1.9.1" : "dev";
 
 // src/commands/_dispatch.ts
 import { consola as consola12 } from "consola";
@@ -4262,96 +4469,24 @@ var applyCommand = defineCommand8({
 
 // src/commands/completion.ts
 import { defineCommand as defineCommand9 } from "citty";
-var ALL_COMMANDS = [
-  "init",
-  "list-components",
-  "shell",
-  "run",
-  "logs",
-  "start",
-  "stop",
-  "status",
-  "apply",
-  "remove",
-  "restore",
-  "add-service",
-  "add-language",
-  "add-apt-packages",
-  "add-feature",
-  "add-from-url",
-  "add-repo",
-  "add-port",
-  "remove-service",
-  "remove-language",
-  "remove-apt-packages",
-  "remove-feature",
-  "remove-from-url",
-  "remove-repo",
-  "remove-port",
-  "port",
-  "completion"
-];
-var COMMANDS_WITH_CONTAINER_ARG = [
-  "shell",
-  "run",
-  "logs",
-  "start",
-  "stop",
-  "status",
-  "apply",
-  "remove",
-  "add-service",
-  "add-language",
-  "add-apt-packages",
-  "add-feature",
-  "add-from-url",
-  "add-repo",
-  "add-port",
-  "remove-service",
-  "remove-language",
-  "remove-apt-packages",
-  "remove-feature",
-  "remove-from-url",
-  "remove-repo",
-  "remove-port",
-  "port"
-];
 var SHELLS = ["bash", "zsh", "pwsh"];
 function renderCompletionScript(shell) {
-  const commands = ALL_COMMANDS.join(" ");
-  const containerCommandsRegex = COMMANDS_WITH_CONTAINER_ARG.join("|");
   if (shell === "bash") {
     return [
       "# bash completion for monoceros",
       "# install: source this file from .bashrc, e.g.",
       "#   monoceros completion bash > ~/.bash_completion.d/monoceros",
       '#   echo "source ~/.bash_completion.d/monoceros" >> ~/.bashrc',
+      "#",
+      "# The work is done by `monoceros __complete --line --point`; this",
+      "# shell wrapper only forwards the cursor view.",
       "",
       "_monoceros() {",
-      "  local cur prev cmd home configs_dir names",
-      '  cur="${COMP_WORDS[COMP_CWORD]}"',
-      "",
-      "  if [[ $COMP_CWORD -eq 1 ]]; then",
-      `    COMPREPLY=( $(compgen -W "${commands}" -- "$cur") )`,
-      "    return",
-      "  fi",
-      "",
-      '  cmd="${COMP_WORDS[1]}"',
-      "  if [[ $COMP_CWORD -eq 2 ]]; then",
-      '    case "$cmd" in',
-      `      ${containerCommandsRegex})`,
-      '        home="${MONOCEROS_HOME:-$HOME/.monoceros}"',
-      '        configs_dir="$home/container-configs"',
-      '        if [[ -d "$configs_dir" ]]; then',
-      `          names=$(cd "$configs_dir" && ls *.yml 2>/dev/null | sed 's/\\.yml$//')`,
-      '          COMPREPLY=( $(compgen -W "$names" -- "$cur") )',
-      "        fi",
-      "        ;;",
-      "      completion)",
-      `        COMPREPLY=( $(compgen -W "${SHELLS.join(" ")}" -- "$cur") )`,
-      "        ;;",
-      "    esac",
-      "  fi",
+      "  local IFS=$'\\n'",
+      "  local candidates",
+      '  candidates=$(monoceros __complete --line "$COMP_LINE" --point "$COMP_POINT" 2>/dev/null)',
+      '  local cur="${COMP_WORDS[COMP_CWORD]}"',
+      '  COMPREPLY=( $(compgen -W "$candidates" -- "$cur") )',
       "}",
       "complete -F _monoceros monoceros",
       ""
@@ -4363,44 +4498,20 @@ function renderCompletionScript(shell) {
       "# install: dot-source this file from your $PROFILE, e.g.",
       "#   monoceros completion pwsh > $HOME/.config/monoceros/completion.ps1",
       "#   Add-Content $PROFILE '. $HOME/.config/monoceros/completion.ps1'",
+      "#",
+      "# The work is done by `monoceros __complete --line --point`; this",
+      "# shell wrapper only forwards the cursor view.",
       "",
       "Register-ArgumentCompleter -Native -CommandName monoceros -ScriptBlock {",
       "    param($wordToComplete, $commandAst, $cursorPosition)",
-      "",
-      "    $commands = @(",
-      ...ALL_COMMANDS.map((c) => `        '${c}'`),
-      "    )",
-      `    $shells = @('${SHELLS.join("', '")}')`,
-      "    $containerCommands = @(",
-      ...COMMANDS_WITH_CONTAINER_ARG.map((c) => `        '${c}'`),
-      "    )",
-      "",
-      "    $tokens = $commandAst.CommandElements",
-      "    $position = $tokens.Count",
-      "    if ($wordToComplete) { $position-- }",
-      "",
-      "    if ($position -eq 1) {",
-      '        $commands | Where-Object { $_ -like "$wordToComplete*" } |',
-      '            ForEach-Object { [System.Management.Automation.CompletionResult]::new($_, $_, "ParameterValue", $_) }',
-      "        return",
-      "    }",
-      "",
-      "    if ($position -eq 2) {",
-      "        $cmd = $tokens[1].Value",
-      "        if ($containerCommands -contains $cmd) {",
-      '            $home = if ($env:MONOCEROS_HOME) { $env:MONOCEROS_HOME } else { Join-Path $env:USERPROFILE ".monoceros" }',
-      '            $configsDir = Join-Path $home "container-configs"',
-      "            if (Test-Path $configsDir) {",
-      '                Get-ChildItem -Path $configsDir -Filter "*.yml" |',
-      "                    ForEach-Object { $_.BaseName } |",
-      '                    Where-Object { $_ -like "$wordToComplete*" } |',
-      '                    ForEach-Object { [System.Management.Automation.CompletionResult]::new($_, $_, "ParameterValue", $_) }',
-      "            }",
-      '        } elseif ($cmd -eq "completion") {',
-      '            $shells | Where-Object { $_ -like "$wordToComplete*" } |',
-      '                ForEach-Object { [System.Management.Automation.CompletionResult]::new($_, $_, "ParameterValue", $_) }',
-      "        }",
-      "    }",
+      "    $line = $commandAst.Extent.Text",
+      "    $point = $cursorPosition - $commandAst.Extent.StartOffset",
+      "    if ($point -lt 0) { $point = 0 }",
+      "    $raw = & monoceros __complete --line $line --point $point 2>$null",
+      "    if (-not $raw) { return }",
+      '    $raw -split "`n" |',
+      '        Where-Object { $_.Length -gt 0 -and $_ -like "$wordToComplete*" } |',
+      '        ForEach-Object { [System.Management.Automation.CompletionResult]::new($_, $_, "ParameterValue", $_) }',
       "}",
       ""
     ].join("\n");
@@ -4411,36 +4522,17 @@ function renderCompletionScript(shell) {
     "# install: drop this file somewhere on your $fpath as `_monoceros`,",
     "# then start a new shell (or run `compinit`). Example:",
     '#   monoceros completion zsh > "${fpath[1]}/_monoceros"',
+    "#",
+    "# The work is done by `monoceros __complete --line --point`; this",
+    "# shell wrapper only forwards the cursor view.",
     "",
     "_monoceros() {",
-    "  local -a commands shells",
-    "  commands=(",
-    ...ALL_COMMANDS.map((c) => `    '${c}'`),
-    "  )",
-    `  shells=(${SHELLS.map((s) => `'${s}'`).join(" ")})`,
-    "",
-    "  if (( CURRENT == 2 )); then",
-    "    _describe 'monoceros command' commands",
-    "    return",
-    "  fi",
-    "",
-    "  local cmd=${words[2]}",
-    "  if (( CURRENT == 3 )); then",
-    "    case $cmd in",
-    `      ${containerCommandsRegex})`,
-    '        local home="${MONOCEROS_HOME:-$HOME/.monoceros}"',
-    '        local configs_dir="$home/container-configs"',
-    "        if [[ -d $configs_dir ]]; then",
-    "          local -a names",
-    "          names=(${configs_dir}/*.yml(N:t:r))",
-    "          _describe 'container' names",
-    "        fi",
-    "        ;;",
-    "      completion)",
-    "        _describe 'shell' shells",
-    "        ;;",
-    "    esac",
-    "  fi",
+    '  local line="$BUFFER"',
+    '  local point="$CURSOR"',
+    "  local -a candidates",
+    '  candidates=("${(@f)$(monoceros __complete --line "$line" --point "$point" 2>/dev/null)}")',
+    '  candidates=("${(@)candidates:#}")',
+    "  _describe 'completion' candidates",
     "}",
     "",
     '_monoceros "$@"',
@@ -4473,178 +4565,484 @@ var completionCommand = defineCommand9({
   }
 });
 
-// src/commands/init.ts
+// src/commands/__complete.ts
 import { defineCommand as defineCommand10 } from "citty";
-import { consola as consola14 } from "consola";
 
-// src/init/index.ts
+// src/completion/resolve.ts
 import { existsSync as existsSync7, promises as fs12 } from "fs";
-import { consola as consola13 } from "consola";
+import path13 from "path";
 
-// src/init/components.ts
-import { existsSync as existsSync5, promises as fs11 } from "fs";
-import path11 from "path";
-import { z as z3 } from "zod";
-import { parse as parseYaml } from "yaml";
-var CategorySchema = z3.enum(["language", "service", "feature"]);
-var FeatureContributionSchema = z3.object({
-  ref: z3.string().regex(REGEX.featureRef),
-  options: z3.record(z3.string(), FeatureOptionValueSchema).optional()
-});
-var ComponentFileSchema = z3.object({
-  displayName: z3.string().min(1),
-  description: z3.string().min(1),
-  category: CategorySchema,
-  contributes: z3.object({
-    languages: z3.array(z3.string().min(1)).optional(),
-    services: z3.array(z3.string().min(1)).optional(),
-    features: z3.array(FeatureContributionSchema).optional()
-  })
-}).superRefine((data, ctx) => {
-  const c = data.contributes;
-  const filled = [
-    c.languages && c.languages.length > 0 ? "languages" : null,
-    c.services && c.services.length > 0 ? "services" : null,
-    c.features && c.features.length > 0 ? "features" : null
-  ].filter((x) => x !== null);
-  if (filled.length === 0) {
-    ctx.addIssue({
-      code: z3.ZodIssueCode.custom,
-      message: "contributes must set at least one of languages/services/features"
-    });
-    return;
+// src/init/manifest.ts
+import { existsSync as existsSync6, readFileSync as readFileSync3 } from "fs";
+import path12 from "path";
+function resolveManifestPath(name, checkoutRoot) {
+  if (checkoutRoot) {
+    const checkoutPath = path12.join(
+      checkoutRoot,
+      "images",
+      "features",
+      name,
+      "devcontainer-feature.json"
+    );
+    if (existsSync6(checkoutPath)) return checkoutPath;
   }
-  if (filled.length > 1) {
-    ctx.addIssue({
-      code: z3.ZodIssueCode.custom,
-      message: `contributes must set exactly one of languages/services/features, got: ${filled.join(", ")}`
-    });
-    return;
+  const bundlePath = path12.join(
+    bundledFeaturesDir(),
+    name,
+    "devcontainer-feature.json"
+  );
+  if (existsSync6(bundlePath)) return bundlePath;
+  return null;
+}
+function loadFeatureManifestSummary(ref, checkoutRoot = workbenchCheckoutRoot()) {
+  const match = matchMonocerosFeature(ref);
+  if (!match) return void 0;
+  const manifestPath = resolveManifestPath(match.name, checkoutRoot);
+  if (!manifestPath) return void 0;
+  try {
+    const text = readFileSync3(manifestPath, "utf8");
+    const parsed = JSON.parse(text);
+    const rawHints = parsed["x-monoceros"]?.optionHints;
+    const optionHints = Array.isArray(rawHints) ? rawHints.filter(
+      (x) => typeof x === "string" && x.length > 0
+    ) : [];
+    const rawNotes = parsed["x-monoceros"]?.usageNotes;
+    const usageNotes = Array.isArray(rawNotes) ? rawNotes.filter(
+      (x) => typeof x === "string" && x.length > 0
+    ) : [];
+    const optionDescriptions = {};
+    const optionTypes = {};
+    const optionNames = [];
+    if (parsed.options) {
+      for (const [key, opt] of Object.entries(parsed.options)) {
+        if (!opt || typeof opt !== "object") continue;
+        optionNames.push(key);
+        if (typeof opt.description === "string" && opt.description.length > 0) {
+          optionDescriptions[key] = opt.description;
+        }
+        if (opt.type === "boolean") {
+          optionTypes[key] = "boolean";
+        } else if (opt.type === "string") {
+          optionTypes[key] = "string";
+        }
+      }
+    }
+    const name = typeof parsed.name === "string" ? parsed.name : "";
+    const description = typeof parsed.description === "string" ? parsed.description : "";
+    const rawUrl = typeof parsed.documentationURL === "string" ? parsed.documentationURL.trim() : "";
+    const documentationURL = rawUrl.length > 0 && rawUrl.toLowerCase() !== "tbd" ? rawUrl : void 0;
+    return {
+      name,
+      description,
+      documentationURL,
+      optionHints,
+      optionDescriptions,
+      optionNames,
+      optionTypes,
+      usageNotes
+    };
+  } catch {
+    return void 0;
   }
-  const expected = data.category === "language" ? "languages" : data.category === "service" ? "services" : "features";
-  if (filled[0] !== expected) {
-    ctx.addIssue({
-      code: z3.ZodIssueCode.custom,
-      message: `category '${data.category}' requires contributes.${expected}, got contributes.${filled[0]}`
-    });
+}
+
+// src/completion/resolve.ts
+async function resolveCompletions(line, point, opts = {}) {
+  const { prev, current } = parseCompletionLine(line, point);
+  const ctx = { prev, current, opts };
+  const head = prev[0];
+  const afterProgram = head === void 0 ? [] : prev.slice(1);
+  if (afterProgram.length === 0) {
+    return filterPrefix(ALL_COMMANDS, current);
+  }
+  const command = afterProgram[0];
+  const spec = COMMAND_SPECS[command];
+  if (!spec) {
+    return [];
+  }
+  const argTokens = afterProgram.slice(1);
+  return dispatchCommand(spec, argTokens, ctx);
+}
+function parseCompletionLine(line, point) {
+  const before = line.slice(0, Math.max(0, Math.min(point, line.length)));
+  const tokens = tokenize(before);
+  const lastChar = before.length > 0 ? before[before.length - 1] : "";
+  if (tokens.length === 0 || isShellWhitespace(lastChar)) {
+    return { prev: tokens, current: "" };
   }
-});
-async function loadComponentCatalog(rootDir = componentsDir()) {
-  if (!existsSync5(rootDir)) {
-    return /* @__PURE__ */ new Map();
+  return {
+    prev: tokens.slice(0, -1),
+    current: tokens[tokens.length - 1]
+  };
+}
+function tokenize(text) {
+  const out = [];
+  let i = 0;
+  while (i < text.length) {
+    while (i < text.length && isShellWhitespace(text[i])) i++;
+    if (i >= text.length) break;
+    let token = "";
+    let quote = null;
+    while (i < text.length) {
+      const ch = text[i];
+      if (quote === null && isShellWhitespace(ch)) break;
+      if (quote === null && (ch === '"' || ch === "'")) {
+        quote = ch;
+        i++;
+        continue;
+      }
+      if (quote !== null && ch === quote) {
+        quote = null;
+        i++;
+        continue;
+      }
+      token += ch;
+      i++;
+    }
+    out.push(token);
   }
-  const out = /* @__PURE__ */ new Map();
-  await walk(rootDir, rootDir, out);
   return out;
 }
-async function walk(baseDir, currentDir, out) {
-  const entries = await fs11.readdir(currentDir, { withFileTypes: true });
-  for (const entry2 of entries) {
-    const full = path11.join(currentDir, entry2.name);
-    if (entry2.isDirectory()) {
-      await walk(baseDir, full, out);
+function isShellWhitespace(ch) {
+  return ch === " " || ch === "	";
+}
+function dispatchCommand(spec, argTokens, ctx) {
+  const dashDashIdx = argTokens.indexOf("--");
+  const preDash = dashDashIdx < 0 ? argTokens : argTokens.slice(0, dashDashIdx);
+  const inPostDash = dashDashIdx >= 0;
+  if (inPostDash && spec.innerArgs) {
+    return resolveValues(spec.innerArgs, ctx, ctx.current);
+  }
+  return resolvePreDash(spec, preDash, ctx);
+}
+async function resolvePreDash(spec, preDash, ctx) {
+  const current = ctx.current;
+  if (current.startsWith("--") && current.includes("=")) {
+    const eqIdx = current.indexOf("=");
+    const flagName = current.slice(0, eqIdx);
+    const valueFragment = current.slice(eqIdx + 1);
+    const flag = spec.flags?.[flagName];
+    if (!flag || flag.type !== "value" || !flag.values) return [];
+    const completions = await resolveValues(flag.values, ctx, valueFragment);
+    return completions.map((v) => `${flagName}=${v}`);
+  }
+  if (current.startsWith("-")) {
+    return listFlagNames(spec.flags ?? {}, current);
+  }
+  const lastPrev = preDash[preDash.length - 1];
+  if (lastPrev && lastPrev.startsWith("--") && !lastPrev.includes("=")) {
+    const flag = spec.flags?.[lastPrev];
+    if (flag && flag.type === "value" && flag.values) {
+      return resolveValues(flag.values, ctx, current);
+    }
+  }
+  const positionalIdx = countCompletedPositionals(preDash, spec.flags ?? {});
+  const positionals = spec.positionals ?? [];
+  const expectedPositionalCount = spec.positionalCount ?? positionals.length;
+  if (positionalIdx < positionals.length) {
+    const positional = positionals[positionalIdx];
+    if (positional) return resolveValues(positional, ctx, current);
+  }
+  if (positionalIdx >= expectedPositionalCount) {
+    return listFlagNames(spec.flags ?? {}, current);
+  }
+  return [];
+}
+function listFlagNames(flags, fragment) {
+  const names = [];
+  for (const [name, spec] of Object.entries(flags)) {
+    names.push(name);
+    for (const alias of spec.aliases ?? []) names.push(alias);
+  }
+  return filterPrefix(names, fragment);
+}
+function countCompletedPositionals(preDash, flags) {
+  let count = 0;
+  for (let i = 0; i < preDash.length; i++) {
+    const t = preDash[i];
+    if (t.startsWith("--") && t.includes("=")) continue;
+    if (t.startsWith("-")) {
+      const flag = flags[t] ?? aliasFlag(flags, t);
+      if (flag && flag.type === "value" && i + 1 < preDash.length) {
+        i++;
+      }
       continue;
     }
-    if (!entry2.isFile() || !entry2.name.endsWith(".yml")) continue;
-    const relative = path11.relative(baseDir, full);
-    const name = relative.replace(/\.yml$/, "").split(path11.sep).join("/");
-    const text = await fs11.readFile(full, "utf8");
-    let raw;
-    try {
-      raw = parseYaml(text);
-    } catch (err) {
-      throw new Error(
-        `Failed to parse component ${name} (${full}): ${err.message}`
-      );
-    }
-    const parsed = ComponentFileSchema.safeParse(raw);
-    if (!parsed.success) {
-      const issues = parsed.error.issues.map((issue) => {
-        const where = issue.path.length > 0 ? issue.path.join(".") : "(root)";
-        return `  - ${where}: ${issue.message}`;
-      }).join("\n");
-      throw new Error(`Invalid component ${name} (${full}):
-${issues}`);
-    }
-    out.set(name, { name, sourcePath: full, file: parsed.data });
+    count++;
   }
+  return count;
 }
-function mergeComponents(resolved) {
-  const languages = [];
-  const services = [];
-  const featureByRef = /* @__PURE__ */ new Map();
-  for (const entry2 of resolved) {
-    const c = isResolvedComponent(entry2) ? entry2.component : entry2;
-    const version = isResolvedComponent(entry2) ? entry2.version : void 0;
-    const ct = c.file.contributes;
-    for (const lang of ct.languages ?? []) {
-      const value = version !== void 0 ? `${lang}:${version}` : lang;
-      if (!languages.includes(value)) languages.push(value);
-    }
-    for (const svc of ct.services ?? []) {
-      if (!services.includes(svc)) services.push(svc);
-    }
-    for (const f of ct.features ?? []) {
-      const existing = featureByRef.get(f.ref);
-      if (!existing) {
-        featureByRef.set(f.ref, {
-          ref: f.ref,
-          options: { ...f.options ?? {} }
-        });
-        continue;
-      }
-      existing.options = mergeFeatureOptions(existing.options, f.options ?? {});
-    }
+function aliasFlag(flags, token) {
+  for (const f of Object.values(flags)) {
+    if (f.aliases?.includes(token)) return f;
   }
-  return {
-    languages,
-    services,
-    features: [...featureByRef.values()]
-  };
+  return void 0;
 }
-function isResolvedComponent(x) {
-  return "component" in x;
+async function resolveValues(source, ctx, fragment) {
+  const values = await source(ctx);
+  const commaIdx = fragment.lastIndexOf(",");
+  if (commaIdx < 0) {
+    return filterPrefix(values, fragment);
+  }
+  const prefix = fragment.slice(0, commaIdx + 1);
+  const tail = fragment.slice(commaIdx + 1);
+  return filterPrefix(values, tail).map((v) => `${prefix}${v}`);
+}
+function filterPrefix(values, fragment) {
+  if (fragment.length === 0) return [...values];
+  return values.filter((v) => v.startsWith(fragment));
+}
+async function listContainerNames(ctx) {
+  const home = ctx.opts.monocerosHome ?? monocerosHome();
+  const dir = path13.join(home, "container-configs");
+  if (!existsSync7(dir)) return [];
+  const entries = await fs12.readdir(dir);
+  return entries.filter((e) => e.endsWith(".yml")).map((e) => e.slice(0, -".yml".length)).sort();
+}
+async function listAllCatalogComponents() {
+  const catalog = await loadComponentCatalog();
+  return [...catalog.keys()].sort();
+}
+async function listFeatureComponents() {
+  const catalog = await loadComponentCatalog();
+  return [...catalog.values()].filter((c) => c.file.category === "feature").map((c) => c.name).sort();
+}
+function listLanguageNames() {
+  return knownLanguages().sort();
+}
+function listServiceNames() {
+  return knownServices().sort();
+}
+function listProviders() {
+  return [...PROVIDER_VALUES];
+}
+function listShellNames() {
+  return ["bash", "zsh", "pwsh"];
+}
+async function listFeatureOptionInnerArgs(ctx) {
+  const after = ctx.prev.slice(2);
+  let positionalCount = 0;
+  let featureToken;
+  for (let i = 0; i < after.length; i++) {
+    const t = after[i];
+    if (t === "--") break;
+    if (t.startsWith("-")) continue;
+    positionalCount++;
+    if (positionalCount === 2) {
+      featureToken = t;
+      break;
+    }
+  }
+  if (!featureToken) return [];
+  const ref = await resolveFeatureRefForCompletion(featureToken);
+  if (!ref) return [];
+  const summary = loadFeatureManifestSummary(ref);
+  if (!summary) return [];
+  const dashDash = ctx.prev.indexOf("--");
+  const innerSoFar = dashDash >= 0 ? ctx.prev.slice(dashDash + 1) : [];
+  const usedKeys = /* @__PURE__ */ new Set();
+  for (const t of innerSoFar) {
+    const eq = t.indexOf("=");
+    if (eq > 0) usedKeys.add(t.slice(0, eq));
+  }
+  const eqIdx = ctx.current.indexOf("=");
+  if (eqIdx >= 0) {
+    const key = ctx.current.slice(0, eqIdx);
+    const valueFragment = ctx.current.slice(eqIdx + 1);
+    const type = summary.optionTypes[key];
+    if (type === "boolean") {
+      return ["true", "false"].filter((v) => v.startsWith(valueFragment)).map((v) => `${key}=${v}`);
+    }
+    return [];
+  }
+  return summary.optionNames.filter((n) => !usedKeys.has(n));
+}
+async function resolveFeatureRefForCompletion(token) {
+  if (REGEX.featureRef.test(token)) return token;
+  const catalog = await loadComponentCatalog();
+  const c = catalog.get(token);
+  if (!c || c.file.category !== "feature") return void 0;
+  const f = c.file.contributes.features?.[0];
+  return f?.ref;
 }
-function mergeFeatureOptions(a, b) {
-  const result = { ...a };
-  for (const [key, valueB] of Object.entries(b)) {
-    const valueA = result[key];
-    if (typeof valueA === "boolean" && typeof valueB === "boolean") {
-      result[key] = valueA || valueB;
-      continue;
+var ALL_COMMANDS = [
+  "init",
+  "list-components",
+  "shell",
+  "run",
+  "logs",
+  "start",
+  "stop",
+  "status",
+  "apply",
+  "remove",
+  "restore",
+  "add-service",
+  "add-language",
+  "add-apt-packages",
+  "add-feature",
+  "add-from-url",
+  "add-repo",
+  "add-port",
+  "remove-service",
+  "remove-language",
+  "remove-apt-packages",
+  "remove-feature",
+  "remove-from-url",
+  "remove-repo",
+  "remove-port",
+  "port",
+  "completion"
+];
+var containerName = (ctx) => listContainerNames(ctx);
+var COMMAND_SPECS = {
+  init: {
+    // First positional is a FRESH name → no suggestion source, but
+    // the slot exists. Once the cursor is past it (after the name +
+    // space), `--with` / `--with-repo` / `--with-ports` surface as
+    // flag suggestions.
+    positionalCount: 1,
+    flags: {
+      "--with": { type: "value", values: () => listAllCatalogComponents() },
+      "--with-repo": { type: "value" },
+      "--with-ports": { type: "value" }
     }
-    result[key] = valueB;
+  },
+  apply: {
+    positionals: [containerName],
+    flags: { "--yes": { type: "boolean", aliases: ["-y"] } }
+  },
+  remove: {
+    positionals: [containerName],
+    flags: {
+      "--yes": { type: "boolean", aliases: ["-y"] },
+      "--no-backup": { type: "boolean" }
+    }
+  },
+  shell: { positionals: [containerName] },
+  run: { positionals: [containerName] },
+  logs: { positionals: [containerName] },
+  start: { positionals: [containerName] },
+  stop: { positionals: [containerName] },
+  status: { positionals: [containerName] },
+  "add-language": {
+    positionals: [containerName, () => listLanguageNames()]
+  },
+  "add-service": {
+    positionals: [containerName, () => listServiceNames()]
+  },
+  "add-apt-packages": {
+    positionals: [containerName],
+    innerArgs: () => []
+    // freeform package names — no useful suggestion list
+  },
+  "add-feature": {
+    positionals: [containerName, () => listFeatureComponents()],
+    flags: { "--yes": { type: "boolean", aliases: ["-y"] } },
+    innerArgs: (ctx) => listFeatureOptionInnerArgs(ctx)
+  },
+  "add-from-url": { positionals: [containerName] },
+  "add-repo": {
+    positionals: [containerName],
+    flags: {
+      "--path": { type: "value" },
+      "--git-name": { type: "value" },
+      "--git-email": { type: "value" },
+      "--provider": { type: "value", values: () => listProviders() },
+      "--yes": { type: "boolean", aliases: ["-y"] }
+    }
+  },
+  "add-port": {
+    positionals: [containerName],
+    flags: {
+      "--default": { type: "boolean" },
+      "--yes": { type: "boolean", aliases: ["-y"] }
+    },
+    innerArgs: () => []
+  },
+  "remove-language": {
+    positionals: [containerName, () => listLanguageNames()]
+  },
+  "remove-service": {
+    positionals: [containerName, () => listServiceNames()]
+  },
+  "remove-apt-packages": {
+    positionals: [containerName],
+    innerArgs: () => []
+  },
+  "remove-feature": {
+    positionals: [containerName, () => listFeatureComponents()],
+    flags: { "--yes": { type: "boolean", aliases: ["-y"] } }
+  },
+  "remove-from-url": { positionals: [containerName] },
+  "remove-repo": { positionals: [containerName] },
+  "remove-port": {
+    positionals: [containerName],
+    flags: { "--yes": { type: "boolean", aliases: ["-y"] } },
+    innerArgs: () => []
+  },
+  port: {
+    positionals: [containerName],
+    flags: { "--default": { type: "boolean" } },
+    innerArgs: () => []
+  },
+  completion: {
+    positionals: [() => listShellNames()]
+  },
+  "list-components": {},
+  restore: {
+    // First positional is a backup-path; no value suggestions today
+    // (could plug filesystem completion later). Slot still exists so
+    // Tab is silent inside it rather than offering flags prematurely.
+    positionalCount: 1
   }
-  return result;
-}
-function resolveComponents(catalog, names) {
-  const unknown = [];
-  const out = [];
-  for (const raw of names) {
-    const colon = raw.indexOf(":");
-    const name = colon === -1 ? raw : raw.slice(0, colon);
-    const version = colon === -1 ? void 0 : raw.slice(colon + 1);
-    const c = catalog.get(name);
-    if (!c) {
-      unknown.push(raw);
-      continue;
+};
+var COMPLETION_COMMAND_SPEC_KEYS = Object.keys(COMMAND_SPECS);
+
+// src/commands/__complete.ts
+var __completeCommand = defineCommand10({
+  meta: {
+    name: "__complete",
+    group: "internal",
+    description: "Internal \u2014 shell completion engine. Used by the wrappers emitted by `monoceros completion <shell>`. Output one candidate completion per line."
+  },
+  args: {
+    line: {
+      type: "string",
+      description: "Full command line buffer up to (and possibly past) the cursor.",
+      default: ""
+    },
+    point: {
+      type: "string",
+      description: "Byte offset of the cursor within --line. Default: end of line.",
+      default: ""
     }
-    if (version !== void 0 && c.file.category !== "language") {
-      throw new Error(
-        `Component '${name}' is a ${c.file.category}, not a language \u2014 a ':${version}' suffix has no meaning here.`
+  },
+  async run({ args }) {
+    const line = String(args.line ?? "");
+    const point = args.point && String(args.point).length > 0 ? Number.parseInt(String(args.point), 10) : line.length;
+    let candidates;
+    try {
+      candidates = await resolveCompletions(
+        line,
+        Number.isFinite(point) ? point : line.length
       );
+    } catch {
+      candidates = [];
+    }
+    if (candidates.length > 0) {
+      process.stdout.write(candidates.join("\n") + "\n");
     }
-    out.push({ component: c, ...version !== void 0 ? { version } : {} });
-  }
-  if (unknown.length > 0) {
-    const available = [...catalog.keys()].sort();
-    throw new Error(
-      `Unknown component${unknown.length > 1 ? "s" : ""}: ${unknown.join(", ")}.
-Available: ${available.join(", ")}.`
-    );
   }
-  return out;
-}
+});
+
+// src/commands/init.ts
+import { defineCommand as defineCommand11 } from "citty";
+import { consola as consola14 } from "consola";
+
+// src/init/index.ts
+import { existsSync as existsSync8, promises as fs13 } from "fs";
+import { consola as consola13 } from "consola";
 
 // src/init/generator.ts
 var SCHEMA_HEADER_ACTIVE = "# Solution-config \u2014 describes what should be inside your dev-container.\n# Edit any section, then run `monoceros apply <name>` to (re-)build.";
@@ -5011,69 +5409,6 @@ function ensureTrailingNewline(s) {
   return s.endsWith("\n") ? s : s + "\n";
 }
 
-// src/init/manifest.ts
-import { existsSync as existsSync6, readFileSync as readFileSync3 } from "fs";
-import path12 from "path";
-function resolveManifestPath(name, checkoutRoot) {
-  if (checkoutRoot) {
-    const checkoutPath = path12.join(
-      checkoutRoot,
-      "images",
-      "features",
-      name,
-      "devcontainer-feature.json"
-    );
-    if (existsSync6(checkoutPath)) return checkoutPath;
-  }
-  const bundlePath = path12.join(
-    bundledFeaturesDir(),
-    name,
-    "devcontainer-feature.json"
-  );
-  if (existsSync6(bundlePath)) return bundlePath;
-  return null;
-}
-function loadFeatureManifestSummary(ref, checkoutRoot = workbenchCheckoutRoot()) {
-  const match = matchMonocerosFeature(ref);
-  if (!match) return void 0;
-  const manifestPath = resolveManifestPath(match.name, checkoutRoot);
-  if (!manifestPath) return void 0;
-  try {
-    const text = readFileSync3(manifestPath, "utf8");
-    const parsed = JSON.parse(text);
-    const rawHints = parsed["x-monoceros"]?.optionHints;
-    const optionHints = Array.isArray(rawHints) ? rawHints.filter(
-      (x) => typeof x === "string" && x.length > 0
-    ) : [];
-    const rawNotes = parsed["x-monoceros"]?.usageNotes;
-    const usageNotes = Array.isArray(rawNotes) ? rawNotes.filter(
-      (x) => typeof x === "string" && x.length > 0
-    ) : [];
-    const optionDescriptions = {};
-    if (parsed.options) {
-      for (const [key, opt] of Object.entries(parsed.options)) {
-        if (opt && typeof opt === "object" && typeof opt.description === "string" && opt.description.length > 0) {
-          optionDescriptions[key] = opt.description;
-        }
-      }
-    }
-    const name = typeof parsed.name === "string" ? parsed.name : "";
-    const description = typeof parsed.description === "string" ? parsed.description : "";
-    const rawUrl = typeof parsed.documentationURL === "string" ? parsed.documentationURL.trim() : "";
-    const documentationURL = rawUrl.length > 0 && rawUrl.toLowerCase() !== "tbd" ? rawUrl : void 0;
-    return {
-      name,
-      description,
-      documentationURL,
-      optionHints,
-      optionDescriptions,
-      usageNotes
-    };
-  } catch {
-    return void 0;
-  }
-}
-
 // src/init/index.ts
 async function runInit(opts) {
   const workbench = opts.workbenchRoot ?? workbenchRoot();
@@ -5088,7 +5423,7 @@ async function runInit(opts) {
     );
   }
   const dest = containerConfigPath(opts.name, home);
-  if (existsSync7(dest)) {
+  if (existsSync8(dest)) {
     throw new Error(
       `Config already exists: ${dest}. Delete it manually before re-running \`monoceros init\` \u2014 this protects any hand-edits.`
     );
@@ -5165,8 +5500,8 @@ async function runInit(opts) {
     const components = resolveComponents(catalog, requested);
     text = generateComposedYml(opts.name, components, lookup, repos, ports);
   }
-  await fs12.mkdir(containerConfigsDir(home), { recursive: true });
-  await fs12.writeFile(dest, text, "utf8");
+  await fs13.mkdir(containerConfigsDir(home), { recursive: true });
+  await fs13.writeFile(dest, text, "utf8");
   if (promptedIdentity?.prompted) {
     const { name, email, scope } = promptedIdentity.prompted;
     if (scope === "g" || scope === "b") {
@@ -5196,11 +5531,11 @@ async function runInit(opts) {
     }
     if (scope === "c" || scope === "b") {
       try {
-        const written = await fs12.readFile(dest, "utf8");
+        const written = await fs13.readFile(dest, "utf8");
         const parsed = parseConfig(written, dest);
         const changed = setContainerGitUserInDoc(parsed.doc, { name, email });
         if (changed) {
-          await fs12.writeFile(dest, stringifyConfig(parsed.doc), "utf8");
+          await fs13.writeFile(dest, stringifyConfig(parsed.doc), "utf8");
           logger.info(
             `Saved identity in ${prettyPath(dest)} (container-level git.user).`
           );
@@ -5230,7 +5565,7 @@ async function runInit(opts) {
 }
 
 // src/commands/init.ts
-var initCommand = defineCommand10({
+var initCommand = defineCommand11({
   meta: {
     name: "init",
     group: "lifecycle",
@@ -5349,7 +5684,7 @@ function collectWithList(withArg, rawArgs) {
 }
 
 // src/commands/list-components.ts
-import { defineCommand as defineCommand11 } from "citty";
+import { defineCommand as defineCommand12 } from "citty";
 import { consola as consola15 } from "consola";
 var CATEGORY_LABELS = {
   language: "Languages",
@@ -5361,7 +5696,7 @@ var CATEGORY_ORDER = [
   "service",
   "feature"
 ];
-var listComponentsCommand = defineCommand11({
+var listComponentsCommand = defineCommand12({
   meta: {
     name: "list-components",
     group: "discovery",
@@ -5430,8 +5765,8 @@ var listComponentsCommand = defineCommand11({
 });
 
 // src/commands/logs.ts
-import { defineCommand as defineCommand12 } from "citty";
-var logsCommand = defineCommand12({
+import { defineCommand as defineCommand13 } from "citty";
+var logsCommand = defineCommand13({
   meta: {
     name: "logs",
     group: "run",
@@ -5466,7 +5801,7 @@ var logsCommand = defineCommand12({
 });
 
 // src/commands/port.ts
-import { defineCommand as defineCommand13 } from "citty";
+import { defineCommand as defineCommand14 } from "citty";
 import { consola as consola16 } from "consola";
 async function runPortListing(opts) {
   const out = opts.out ?? process.stdout;
@@ -5518,7 +5853,7 @@ async function runPortListing(opts) {
   }
   return 0;
 }
-var portCommand = defineCommand13({
+var portCommand = defineCommand14({
   meta: {
     name: "port",
     group: "discovery",
@@ -5543,9 +5878,9 @@ var portCommand = defineCommand13({
 });
 
 // src/commands/remove-apt-packages.ts
-import { defineCommand as defineCommand14 } from "citty";
+import { defineCommand as defineCommand15 } from "citty";
 import { consola as consola17 } from "consola";
-var removeAptPackagesCommand = defineCommand14({
+var removeAptPackagesCommand = defineCommand15({
   meta: {
     name: "remove-apt-packages",
     group: "edit",
@@ -5587,9 +5922,9 @@ var removeAptPackagesCommand = defineCommand14({
 });
 
 // src/commands/remove-feature.ts
-import { defineCommand as defineCommand15 } from "citty";
+import { defineCommand as defineCommand16 } from "citty";
 import { consola as consola18 } from "consola";
-var removeFeatureCommand = defineCommand15({
+var removeFeatureCommand = defineCommand16({
   meta: {
     name: "remove-feature",
     group: "edit",
@@ -5629,13 +5964,13 @@ var removeFeatureCommand = defineCommand15({
 });
 
 // src/commands/remove.ts
-import { defineCommand as defineCommand16 } from "citty";
+import { defineCommand as defineCommand17 } from "citty";
 import { consola as consola20 } from "consola";
 import { createInterface } from "readline/promises";
 
 // src/remove/index.ts
-import { existsSync as existsSync8, promises as fs13 } from "fs";
-import path13 from "path";
+import { existsSync as existsSync9, promises as fs14 } from "fs";
+import path14 from "path";
 import { consola as consola19 } from "consola";
 async function runRemove(opts) {
   const home = opts.monocerosHome ?? monocerosHome();
@@ -5651,8 +5986,8 @@ async function runRemove(opts) {
   }
   const ymlPath = containerConfigPath(opts.name, home);
   const containerPath = containerDir(opts.name, home);
-  const hasYml = existsSync8(ymlPath);
-  const hasContainer = existsSync8(containerPath);
+  const hasYml = existsSync9(ymlPath);
+  const hasContainer = existsSync9(containerPath);
   if (!hasYml && !hasContainer) {
     throw new Error(
       `Nothing to remove for '${opts.name}': neither ${ymlPath} nor ${containerPath} exists.`
@@ -5686,23 +6021,23 @@ async function runRemove(opts) {
   let backupPath = null;
   if (!opts.noBackup && (hasYml || hasContainer)) {
     const ts = (opts.now ?? /* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-    backupPath = path13.join(home, "container-backups", `${opts.name}-${ts}`);
-    await fs13.mkdir(backupPath, { recursive: true });
+    backupPath = path14.join(home, "container-backups", `${opts.name}-${ts}`);
+    await fs14.mkdir(backupPath, { recursive: true });
     if (hasYml) {
-      await fs13.copyFile(ymlPath, path13.join(backupPath, `${opts.name}.yml`));
+      await fs14.copyFile(ymlPath, path14.join(backupPath, `${opts.name}.yml`));
     }
     if (hasContainer) {
-      await fs13.cp(containerPath, path13.join(backupPath, "container"), {
+      await fs14.cp(containerPath, path14.join(backupPath, "container"), {
         recursive: true
       });
     }
     logger.info(`Backup written to ${prettyPath(backupPath)}.`);
   }
   if (hasYml) {
-    await fs13.rm(ymlPath, { force: true });
+    await fs14.rm(ymlPath, { force: true });
   }
   if (hasContainer) {
-    await fs13.rm(containerPath, { recursive: true, force: true });
+    await fs14.rm(containerPath, { recursive: true, force: true });
   }
   logger.success(
     `Removed '${opts.name}': docker objects gone, container-configs entry deleted, container directory deleted.`
@@ -5739,7 +6074,7 @@ async function runRemove(opts) {
 }
 
 // src/commands/remove.ts
-var removeCommand = defineCommand16({
+var removeCommand = defineCommand17({
   meta: {
     name: "remove",
     group: "lifecycle",
@@ -5800,12 +6135,12 @@ var removeCommand = defineCommand16({
 });
 
 // src/commands/restore.ts
-import { defineCommand as defineCommand17 } from "citty";
+import { defineCommand as defineCommand18 } from "citty";
 import { consola as consola22 } from "consola";
 
 // src/restore/index.ts
-import { existsSync as existsSync9, promises as fs14 } from "fs";
-import path14 from "path";
+import { existsSync as existsSync10, promises as fs15 } from "fs";
+import path15 from "path";
 import { consola as consola21 } from "consola";
 async function runRestore(opts) {
   const home = opts.monocerosHome ?? monocerosHome();
@@ -5813,15 +6148,15 @@ async function runRestore(opts) {
     info: (msg) => consola21.info(msg),
     success: (msg) => consola21.success(msg)
   };
-  const backup = path14.resolve(opts.backupPath);
-  if (!existsSync9(backup)) {
+  const backup = path15.resolve(opts.backupPath);
+  if (!existsSync10(backup)) {
     throw new Error(`Backup not found: ${backup}.`);
   }
-  const stat = await fs14.stat(backup);
+  const stat = await fs15.stat(backup);
   if (!stat.isDirectory()) {
     throw new Error(`Backup path is not a directory: ${backup}.`);
   }
-  const entries = await fs14.readdir(backup);
+  const entries = await fs15.readdir(backup);
   const ymlFiles = entries.filter((f) => f.endsWith(".yml"));
   if (ymlFiles.length === 0) {
     throw new Error(
@@ -5835,24 +6170,24 @@ async function runRestore(opts) {
   }
   const ymlFile = ymlFiles[0];
   const name = ymlFile.replace(/\.yml$/, "");
-  const containerInBackup = path14.join(backup, "container");
-  const hasContainer = existsSync9(containerInBackup);
+  const containerInBackup = path15.join(backup, "container");
+  const hasContainer = existsSync10(containerInBackup);
   const destYml = containerConfigPath(name, home);
   const destContainer = containerDir(name, home);
-  if (existsSync9(destYml)) {
+  if (existsSync10(destYml)) {
     throw new Error(
       `Refusing to restore: ${destYml} already exists. Remove the current container first (\`monoceros remove ${name}\`) or rename the existing config.`
     );
   }
-  if (hasContainer && existsSync9(destContainer)) {
+  if (hasContainer && existsSync10(destContainer)) {
     throw new Error(
       `Refusing to restore: ${destContainer} already exists. Remove the current container first (\`monoceros remove ${name}\`).`
     );
   }
-  await fs14.mkdir(containerConfigsDir(home), { recursive: true });
-  await fs14.copyFile(path14.join(backup, ymlFile), destYml);
+  await fs15.mkdir(containerConfigsDir(home), { recursive: true });
+  await fs15.copyFile(path15.join(backup, ymlFile), destYml);
   if (hasContainer) {
-    await fs14.cp(containerInBackup, destContainer, { recursive: true });
+    await fs15.cp(containerInBackup, destContainer, { recursive: true });
   }
   logger.success(`Restored '${name}' from ${prettyPath(backup)}.`);
   logger.info(
@@ -5866,7 +6201,7 @@ async function runRestore(opts) {
 }
 
 // src/commands/restore.ts
-var restoreCommand = defineCommand17({
+var restoreCommand = defineCommand18({
   meta: {
     name: "restore",
     group: "lifecycle",
@@ -5890,9 +6225,9 @@ var restoreCommand = defineCommand17({
 });
 
 // src/commands/remove-from-url.ts
-import { defineCommand as defineCommand18 } from "citty";
+import { defineCommand as defineCommand19 } from "citty";
 import { consola as consola23 } from "consola";
-var removeFromUrlCommand = defineCommand18({
+var removeFromUrlCommand = defineCommand19({
   meta: {
     name: "remove-from-url",
     group: "edit",
@@ -5932,9 +6267,9 @@ var removeFromUrlCommand = defineCommand18({
 });
 
 // src/commands/remove-language.ts
-import { defineCommand as defineCommand19 } from "citty";
+import { defineCommand as defineCommand20 } from "citty";
 import { consola as consola24 } from "consola";
-var removeLanguageCommand = defineCommand19({
+var removeLanguageCommand = defineCommand20({
   meta: {
     name: "remove-language",
     group: "edit",
@@ -5974,9 +6309,9 @@ var removeLanguageCommand = defineCommand19({
 });
 
 // src/commands/remove-port.ts
-import { defineCommand as defineCommand20 } from "citty";
+import { defineCommand as defineCommand21 } from "citty";
 import { consola as consola25 } from "consola";
-var removePortCommand = defineCommand20({
+var removePortCommand = defineCommand21({
   meta: {
     name: "remove-port",
     group: "edit",
@@ -6022,9 +6357,9 @@ function coerceToken2(raw) {
 }
 
 // src/commands/remove-repo.ts
-import { defineCommand as defineCommand21 } from "citty";
+import { defineCommand as defineCommand22 } from "citty";
 import { consola as consola26 } from "consola";
-var removeRepoCommand = defineCommand21({
+var removeRepoCommand = defineCommand22({
   meta: {
     name: "remove-repo",
     group: "edit",
@@ -6064,9 +6399,9 @@ var removeRepoCommand = defineCommand21({
 });
 
 // src/commands/remove-service.ts
-import { defineCommand as defineCommand22 } from "citty";
+import { defineCommand as defineCommand23 } from "citty";
 import { consola as consola27 } from "consola";
-var removeServiceCommand = defineCommand22({
+var removeServiceCommand = defineCommand23({
   meta: {
     name: "remove-service",
     group: "edit",
@@ -6106,12 +6441,12 @@ var removeServiceCommand = defineCommand22({
 });
 
 // src/commands/run.ts
-import { defineCommand as defineCommand23 } from "citty";
+import { defineCommand as defineCommand24 } from "citty";
 import { consola as consola28 } from "consola";
 
 // src/devcontainer/shell.ts
-import { existsSync as existsSync10 } from "fs";
-import path15 from "path";
+import { existsSync as existsSync11 } from "fs";
+import path16 from "path";
 async function runShell(opts) {
   assertContainerExists(opts.root);
   const spawnFn = opts.spawn ?? spawnDevcontainer;
@@ -6134,7 +6469,7 @@ async function runShell(opts) {
   );
 }
 function assertContainerExists(root) {
-  if (!existsSync10(path15.join(root, ".devcontainer"))) {
+  if (!existsSync11(path16.join(root, ".devcontainer"))) {
     throw new Error(
       `No .devcontainer/ at ${root}. Run \`monoceros apply <name>\` first.`
     );
@@ -6170,7 +6505,7 @@ async function runInContainer(opts) {
 }
 
 // src/commands/run.ts
-var runCommand = defineCommand23({
+var runCommand = defineCommand24({
   meta: {
     name: "run",
     group: "run",
@@ -6205,9 +6540,9 @@ var runCommand = defineCommand23({
 });
 
 // src/commands/shell.ts
-import { defineCommand as defineCommand24 } from "citty";
+import { defineCommand as defineCommand25 } from "citty";
 import { consola as consola29 } from "consola";
-var shellCommand = defineCommand24({
+var shellCommand = defineCommand25({
   meta: {
     name: "shell",
     group: "run",
@@ -6232,9 +6567,9 @@ var shellCommand = defineCommand24({
 });
 
 // src/commands/start.ts
-import { defineCommand as defineCommand25 } from "citty";
+import { defineCommand as defineCommand26 } from "citty";
 import { consola as consola30 } from "consola";
-var startCommand = defineCommand25({
+var startCommand = defineCommand26({
   meta: {
     name: "start",
     group: "run",
@@ -6273,8 +6608,8 @@ var startCommand = defineCommand25({
 });
 
 // src/commands/status.ts
-import { defineCommand as defineCommand26 } from "citty";
-var statusCommand = defineCommand26({
+import { defineCommand as defineCommand27 } from "citty";
+var statusCommand = defineCommand27({
   meta: {
     name: "status",
     group: "run",
@@ -6302,9 +6637,9 @@ var statusCommand = defineCommand26({
 });
 
 // src/commands/stop.ts
-import { defineCommand as defineCommand27 } from "citty";
+import { defineCommand as defineCommand28 } from "citty";
 import { consola as consola31 } from "consola";
-var stopCommand = defineCommand27({
+var stopCommand = defineCommand28({
   meta: {
     name: "stop",
     group: "run",
@@ -6342,7 +6677,7 @@ var stopCommand = defineCommand27({
 });
 
 // src/main.ts
-var main = defineCommand28({
+var main = defineCommand29({
   meta: {
     name: "monoceros",
     version: CLI_VERSION,
@@ -6375,7 +6710,8 @@ var main = defineCommand28({
     "remove-repo": removeRepoCommand,
     "remove-port": removePortCommand,
     port: portCommand,
-    completion: completionCommand
+    completion: completionCommand,
+    __complete: __completeCommand
   }
 });