argsbarg 4.1.0 → 4.1.1

package/src/install/install.test.ts

@@ -1,20 +1,24 @@
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-import { existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { chmodSync, existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { writeAppConfigFile } from "../config/file.ts";
 import type { CliProgram } from "../types.ts";
 import { detectInstalledArtifacts } from "./detect-installed.ts";
 import {
+  cliInstall,
   interactiveSelectionAssumesApp,
   mergeInteractiveSelection,
   parseInstallOpts,
   runInstallMutation,
+  runUninstallMutation,
   validateInstallOpts,
+  validateUninstallOpts,
 } from "./index.ts";
 import { opencodeConfigDir } from "./mcp-opencode.ts";
+import { normalizeUninstallRawOpts } from "./normalize-uninstall.ts";
 import { resolveClaudeDesktopMcpPath, resolveInstallPaths } from "./paths.ts";
-import { buildInstallPlan } from "./plan.ts";
+import { buildInstallPlan, buildUpdatePlan } from "./plan.ts";
 import { printInstallStatus, writeInteractiveInstallIntro } from "./status.ts";
 import { buildUninstallPlan } from "./uninstall.ts";
 
@@ -28,7 +32,6 @@ const fixture: CliProgram = {
 
 let home: string;
 let prevHome: string | undefined;
-
 let prevXdg: string | undefined;
 
 beforeEach(() => {
@@ -48,16 +51,10 @@ afterEach(() => {
 });
 
 describe("install paths", () => {
-  test("resolveInstallPaths uses ~/.local/bin for app", () => {
+  test("resolveInstallPaths includes skill and mcp paths", () => {
     const paths = resolveInstallPaths(fixture);
-    expect(paths.appPath).toBe(join(home, ".local", "bin", "testapp"));
-  });
-
-  test("fish completion uses XDG_CONFIG_HOME", () => {
-    const xdg = join(home, "xdg");
-    process.env.XDG_CONFIG_HOME = xdg;
-    const paths = resolveInstallPaths(fixture);
-    expect(paths.fishCompletion).toBe(join(xdg, "fish", "completions", "testapp.fish"));
+    expect(paths.cursorSkillDir).toContain(".cursor/skills");
+    expect(paths.cursorMcpPath).toContain("mcp.json");
   });
 
   test("claude desktop mcp path on darwin", () => {
@@ -74,38 +71,39 @@ describe("install paths", () => {
 });
 
 describe("detect installed", () => {
-  test("detects app and completions", () => {
+  test("detects cursor mcp when configured", () => {
     const paths = resolveInstallPaths(fixture);
-    mkdirSync(paths.appDir, { recursive: true });
-    writeFileSync(paths.appPath, "fake", "utf8");
-    mkdirSync(join(home, ".bash_completion.d"), { recursive: true });
-    writeFileSync(paths.bashCompletion, "# bash", "utf8");
+    mkdirSync(join(home, ".cursor"), { recursive: true });
+    writeFileSync(
+      paths.cursorMcpPath,
+      JSON.stringify({ mcpServers: { testapp: { command: "testapp", args: ["mcp"] } } }),
+      "utf8",
+    );
 
     const detected = detectInstalledArtifacts(paths, fixture);
-    expect(detected.app).toBe(true);
-    expect(detected.bashCompletion).toBe(true);
-    expect(detected.zshCompletion).toBe(false);
+    expect(detected.cursorMcp).toBe(true);
+    expect(detected.app).toBe(false);
   });
 });
 
 describe("install plan", () => {
-  test("buildInstallPlan --all includes app", () => {
+  test("buildInstallPlan --all omits app self-install", () => {
     const paths = resolveInstallPaths(fixture);
     const plan = buildInstallPlan(fixture, paths, parseInstallOpts({ all: "1" }));
-    expect(plan.some((a) => a.kind === "app")).toBe(true);
+    expect(plan.some((a) => a.kind === "app")).toBe(false);
+    expect(plan.some((a) => a.kind.endsWith("-mcp"))).toBe(true);
   });
 
-  test("buildInstallPlan --mcp --yes also includes app", () => {
+  test("buildInstallPlan --mcp without yes omits implicit app", () => {
     const paths = resolveInstallPaths(fixture);
-    const opts = parseInstallOpts({ mcp: "1", yes: "1" });
-    validateInstallOpts(opts);
-    const plan = buildInstallPlan(fixture, paths, opts);
-    expect(plan.some((a) => a.kind === "app")).toBe(true);
+    const plan = buildInstallPlan(fixture, paths, parseInstallOpts({ mcp: "1" }));
+    expect(plan.some((a) => a.kind === "app")).toBe(false);
   });
 
-  test("buildInstallPlan --mcp without yes omits app", () => {
+  test("buildUpdatePlan greenfield falls back to install-all", () => {
     const paths = resolveInstallPaths(fixture);
-    const plan = buildInstallPlan(fixture, paths, parseInstallOpts({ mcp: "1" }));
+    const plan = buildUpdatePlan(fixture, paths, parseInstallOpts({ reinstall: "1", yes: "1" }));
+    expect(plan.length).toBeGreaterThan(0);
     expect(plan.some((a) => a.kind === "app")).toBe(false);
   });
 
@@ -130,12 +128,6 @@ describe("install plan", () => {
     expect(plan.some((a) => a.kind === "claude-mcp")).toBe(true);
   });
 
-  test("buildInstallPlan --mcp skips claude desktop without app data", () => {
-    const paths = resolveInstallPaths(fixture);
-    const plan = buildInstallPlan(fixture, paths, parseInstallOpts({ mcp: "1" }));
-    expect(plan.some((a) => a.kind === "claude-desktop-mcp")).toBe(false);
-  });
-
   test("buildInstallPlan --mcp includes opencode when config dir exists", () => {
     const paths = resolveInstallPaths(fixture);
     mkdirSync(opencodeConfigDir(home), { recursive: true });
@@ -143,21 +135,37 @@ describe("install plan", () => {
     expect(plan.some((a) => a.kind === "opencode-mcp")).toBe(true);
   });
 
-  test("buildInstallPlan --mcp includes chatgpt when app data exists", () => {
-    const paths = resolveInstallPaths(fixture);
-    if (process.platform === "darwin") {
-      mkdirSync(join(home, "Library", "Application Support", "ChatGPT"), { recursive: true });
-      const plan = buildInstallPlan(fixture, paths, parseInstallOpts({ mcp: "1" }));
-      expect(plan.some((a) => a.kind === "chatgpt-desktop-mcp")).toBe(true);
-    }
+  test("buildInstallPlan --mcp --skill --configure is not empty when agents exist", () => {
+    const program: CliProgram = {
+      ...fixture,
+      install: { agentIntegration: "both" },
+      appConfig: {
+        entries: { token: { description: "API token." } },
+      },
+    };
+    const paths = resolveInstallPaths(program);
+    mkdirSync(join(home, ".cursor"), { recursive: true });
+    mkdirSync(join(home, ".claude"), { recursive: true });
+    const plan = buildInstallPlan(
+      program,
+      paths,
+      parseInstallOpts({ mcp: "1", skill: "1", configure: "1" }),
+    );
+    expect(plan.length).toBeGreaterThan(0);
+    expect(plan.some((a) => a.kind.endsWith("-mcp"))).toBe(true);
+    expect(plan.some((a) => a.kind.endsWith("-skill"))).toBe(true);
   });
 });
 
 describe("install status", () => {
-  test("printInstallStatus human output", () => {
+  test("printInstallStatus human output with MCP", () => {
     const paths = resolveInstallPaths(fixture);
-    mkdirSync(paths.appDir, { recursive: true });
-    writeFileSync(paths.appPath, "fake", "utf8");
+    mkdirSync(join(home, ".cursor"), { recursive: true });
+    writeFileSync(
+      paths.cursorMcpPath,
+      JSON.stringify({ mcpServers: { testapp: { command: "testapp", args: ["mcp"] } } }),
+      "utf8",
+    );
 
     const chunks: string[] = [];
     const orig = process.stdout.write;
@@ -169,7 +177,7 @@ describe("install status", () => {
       printInstallStatus(fixture, {});
       const out = chunks.join("");
       expect(out).toContain("Installed artifacts for testapp");
-      expect(out).toContain("~/.local/bin/testapp");
+      expect(out).toContain("cursor mcp");
     } finally {
       process.stdout.write = orig;
     }
@@ -207,17 +215,9 @@ describe("interactive selection", () => {
     expect(mergeInteractiveSelection([2, 3], 5, false)).toEqual([2, 3]);
   });
 
-  test("interactiveSelectionAssumesApp when install plan starts with app", () => {
+  test("interactiveSelectionAssumesApp is always false", () => {
     const paths = resolveInstallPaths(fixture);
     const plan = buildInstallPlan(fixture, paths, parseInstallOpts({ all: "1" }));
-    expect(interactiveSelectionAssumesApp(plan, false)).toBe(true);
-    expect(interactiveSelectionAssumesApp(plan, true)).toBe(false);
-  });
-
-  test("interactiveSelectionAssumesApp false when app not in plan", () => {
-    const paths = resolveInstallPaths(fixture);
-    const plan = buildInstallPlan(fixture, paths, parseInstallOpts({ completions: "1" }));
-    expect(plan.some((a) => a.kind === "app")).toBe(false);
     expect(interactiveSelectionAssumesApp(plan, false)).toBe(false);
   });
 });
@@ -239,34 +239,34 @@ describe("install output", () => {
   });
 });
 
-describe("parseInstallOpts", () => {
-  test("json implies yes in validate path via cliInstall", () => {
-    const opts = parseInstallOpts({ json: "1", all: "1" });
-    expect(opts.json).toBe(true);
+describe("validateUninstallOpts", () => {
+  test("bare uninstall normalizes to --all", () => {
+    const opts = parseInstallOpts(normalizeUninstallRawOpts({ yes: "1" }));
+    expect(validateUninstallOpts(opts)).toBeNull();
     expect(opts.all).toBe(true);
   });
-});
-
-describe("validateInstallOpts", () => {
-  test("uninstall requires a target flag", () => {
-    const opts = parseInstallOpts({ uninstall: "1", yes: "1" });
-    expect(validateInstallOpts(opts)).toContain("Specify at least one target");
-  });
 
   test("uninstall allows --all", () => {
     const opts = parseInstallOpts({ uninstall: "1", all: "1", yes: "1" });
-    expect(validateInstallOpts(opts)).toBeNull();
+    expect(validateUninstallOpts(opts)).toBeNull();
   });
 
   test("uninstall rejects --reinstall", () => {
     const opts = parseInstallOpts({ uninstall: "1", reinstall: "1", all: "1" });
-    expect(validateInstallOpts(opts)).toContain("--reinstall");
+    expect(validateUninstallOpts(opts)).toContain("--reinstall");
+  });
+});
+
+describe("validateInstallOpts", () => {
+  test("install --uninstall is rejected", () => {
+    const opts = parseInstallOpts({ uninstall: "1", all: "1", yes: "1" });
+    expect(validateInstallOpts(opts)).toContain("uninstall");
   });
 });
 
 describe("install mutation", () => {
   test("uninstall --all with nothing installed succeeds", async () => {
-    const result = await runInstallMutation(fixture, { uninstall: "1", all: "1", yes: "1" });
+    const result = await runUninstallMutation(fixture, { all: "1", yes: "1" });
     expect(result.changed).toEqual([]);
   });
 
@@ -277,29 +277,30 @@ describe("install mutation", () => {
     ).toBe(true);
   });
 
-  test("uninstall --all removes detected app", async () => {
-    const paths = resolveInstallPaths(fixture);
-    mkdirSync(paths.appDir, { recursive: true });
-    writeFileSync(paths.appPath, "fake", "utf8");
-
-    const result = await runInstallMutation(fixture, { uninstall: "1", all: "1", yes: "1" });
-    expect(result.changed).toContain(paths.appPath);
-    expect(existsSync(paths.appPath)).toBe(false);
-    expect(existsSync(paths.appDir)).toBe(true);
+  test("install --all --yes dry-run succeeds when stdin is not a TTY", async () => {
+    const program: CliProgram = {
+      ...fixture,
+      appConfig: {
+        entries: { token: { description: "API token." } },
+      },
+    };
+    const origIsTTY = process.stdin.isTTY;
+    Object.defineProperty(process.stdin, "isTTY", { value: false, configurable: true });
+    const exitCode = await new Promise<number>((resolve) => {
+      const origExit = process.exit;
+      process.exit = ((code?: number) => {
+        process.exit = origExit;
+        resolve(code ?? 0);
+      }) as typeof process.exit;
+      void cliInstall(program, { all: "1", yes: "1", dry: "1" });
+    });
+    Object.defineProperty(process.stdin, "isTTY", { value: origIsTTY, configurable: true });
+    expect(exitCode).toBe(0);
   });
 });
 
 describe("uninstall plan", () => {
-  test("buildUninstallPlan --all scopes like install --all", () => {
-    const paths = resolveInstallPaths(fixture);
-    mkdirSync(paths.appDir, { recursive: true });
-    writeFileSync(paths.appPath, "fake", "utf8");
-
-    const plan = buildUninstallPlan(fixture, paths, parseInstallOpts({ uninstall: "1", all: "1" }));
-    expect(plan.some((a) => a.summary.startsWith("app:"))).toBe(true);
-  });
-
-  test("buildUninstallPlan --all runs configure last", () => {
+  test("buildUninstallPlan --all runs configure last when config exists", () => {
     const program: CliProgram = {
       ...fixture,
       appConfig: {
@@ -307,27 +308,10 @@ describe("uninstall plan", () => {
       },
     };
     const paths = resolveInstallPaths(program);
-    mkdirSync(paths.appDir, { recursive: true });
-    writeFileSync(paths.appPath, "fake", "utf8");
     writeAppConfigFile(program, { token: "secret" });
 
     const plan = buildUninstallPlan(program, paths, parseInstallOpts({ uninstall: "1", all: "1" }));
-    const appIdx = plan.findIndex((a) => a.summary.startsWith("app:"));
     const configureIdx = plan.findIndex((a) => a.summary.startsWith("app config:"));
-    expect(appIdx).toBeGreaterThanOrEqual(0);
-    expect(configureIdx).toBeGreaterThan(appIdx);
     expect(configureIdx).toBe(plan.length - 1);
   });
-
-  test("buildUninstallPlan --app ignores completions", () => {
-    const paths = resolveInstallPaths(fixture);
-    mkdirSync(paths.appDir, { recursive: true });
-    writeFileSync(paths.appPath, "fake", "utf8");
-    mkdirSync(join(home, ".bash_completion.d"), { recursive: true });
-    writeFileSync(paths.bashCompletion, "# bash", "utf8");
-
-    const plan = buildUninstallPlan(fixture, paths, parseInstallOpts({ uninstall: "1", app: "1" }));
-    expect(plan).toHaveLength(1);
-    expect(plan[0]?.summary.startsWith("app:")).toBe(true);
-  });
 });

package/src/install/normalize-uninstall.ts

@@ -0,0 +1,11 @@
+/** Normalizes bare `uninstall` to `--all`. */
+export function normalizeUninstallRawOpts(raw: Record<string, string>): Record<string, string> {
+  const flag = (name: string) => raw[name] === "1";
+  const out: Record<string, string> = { ...raw, uninstall: "1" };
+
+  const hasUninstallTarget = flag("all") || flag("skill") || flag("mcp") || flag("configure");
+  if (!hasUninstallTarget) {
+    out.all = "1";
+  }
+  return out;
+}

package/src/install/normalize.ts

@@ -1,30 +1,15 @@
-/** Normalizes bare `install` / `install --uninstall` to `--all`. */
+/** Normalizes bare `install` to `--all`. */
 export function normalizeInstallRawOpts(raw: Record<string, string>): Record<string, string> {
   const flag = (name: string) => raw[name] === "1";
   const out = { ...raw };
 
-  if (flag("status") || flag("reinstall") || flag("update")) {
+  if (flag("status") || flag("reinstall")) {
     return out;
   }
 
-  const hasInstallTarget =
-    flag("all") || flag("app") || flag("completions") || flag("skill") || flag("mcp");
-  const hasUninstallTarget =
-    flag("all") ||
-    flag("app") ||
-    flag("completions") ||
-    flag("skill") ||
-    flag("mcp") ||
-    flag("configure");
+  const hasInstallTarget = flag("all") || flag("skill") || flag("mcp");
 
-  if (flag("configure") && !flag("uninstall") && !hasInstallTarget) {
-    return out;
-  }
-
-  if (flag("uninstall")) {
-    if (!hasUninstallTarget) {
-      out.all = "1";
-    }
+  if (flag("configure") && !hasInstallTarget) {
     return out;
   }
 

package/src/install/paths.ts

@@ -8,11 +8,6 @@ import { resolveOpenclawConfigPath } from "./mcp-openclaw.ts";
 import { resolveOpenCodeConfigPathForInstall } from "./mcp-opencode.ts";
 
 export interface InstallPaths {
-  appDir: string;
-  appPath: string;
-  bashCompletion: string;
-  zshCompletion: string;
-  fishCompletion: string;
   cursorSkillDir: string;
   claudeSkillDir: string;
   codexSkillDir: string;
@@ -25,8 +20,6 @@ export interface InstallPaths {
   chatGptMcpPath: string;
   codexConfigPath: string;
   openclawConfigPath: string;
-  bashRc: string;
-  zshRc: string;
   mcpName: string;
   skillDirName: string;
 }
@@ -38,11 +31,6 @@ export function displayInstallPath(path: string): string {
   return displayHomePath(path);
 }
 
-/** App install directory (`~/.local/bin`). */
-export function resolveAppDir(): string {
-  return join(userHome(), ".local", "bin");
-}
-
 /** Resolves Claude Desktop `claude_desktop_config.json` for the current OS. */
 export function resolveClaudeDesktopMcpPath(home: string): string {
   if (process.platform === "darwin") {
@@ -80,22 +68,14 @@ export function chatGptDesktopPresent(_home: string, configPath: string): boolea
 /** Resolves all install artifact paths for a program root. */
 export function resolveInstallPaths(root: CliProgram): InstallPaths {
   const home = userHome();
-  const appDir = resolveAppDir();
-  const key = root.key;
   const skillDirName = sanitizeToolSegment(root.key);
   const codexSlug = skillDirNameForTarget(root.key, "codex");
   const opencodeSlug = skillDirNameForTarget(root.key, "opencode");
   const openclawSlug = skillDirNameForTarget(root.key, "openclaw");
-  const xdgConfig = xdgConfigHome(home);
   const claudeDesktopMcpPath = resolveClaudeDesktopMcpPath(home);
   const chatGptMcpPath = resolveChatGptMcpPath(home);
 
   return {
-    appDir,
-    appPath: join(appDir, key),
-    bashCompletion: join(home, ".bash_completion.d", key),
-    zshCompletion: join(home, ".zsh", "completions", `_${key}`),
-    fishCompletion: join(xdgConfig, "fish", "completions", `${key}.fish`),
     cursorSkillDir: join(home, ".cursor", "skills", skillDirName),
     claudeSkillDir: join(home, ".claude", "skills", skillDirName),
     codexSkillDir: join(home, ".codex", "skills", codexSlug),
@@ -108,8 +88,6 @@ export function resolveInstallPaths(root: CliProgram): InstallPaths {
     chatGptMcpPath,
     codexConfigPath: join(home, ".codex", "config.toml"),
     openclawConfigPath: resolveOpenclawConfigPath(home),
-    bashRc: join(home, ".bashrc"),
-    zshRc: join(home, ".zshrc"),
     mcpName: mcpServerId(root),
     skillDirName,
   };

package/src/install/plan.ts

@@ -15,26 +15,34 @@ export function buildInstallPlan(
   return buildInstallPlanFromTargets(root, paths, opts);
 }
 
-/** Builds update/reinstall actions for detected artifacts within effective targets. */
+/** Builds update/reinstall actions; greenfield fallback when nothing detected. */
 export function buildUpdatePlan(
   root: CliProgram,
   paths: InstallPaths,
   opts: InstallOpts,
 ): InstallAction[] {
-  return buildInstallPlan(root, paths, { ...opts, reinstall: true, all: true });
+  const refresh = buildInstallPlanFromTargets(root, paths, {
+    ...opts,
+    reinstall: true,
+    all: true,
+  });
+  if (refresh.length > 0) {
+    return refresh;
+  }
+  return buildInstallPlanFromTargets(root, paths, { ...opts, reinstall: false, all: true });
 }
 
 /** @deprecated Use resolveInstallPlanMode + shouldIncludeArtifact. */
-export function wantsInstallApp(opts: InstallOpts): boolean {
-  return !!(opts.all || opts.app || opts.reinstall);
+export function wantsInstallApp(_opts: InstallOpts): boolean {
+  return false;
 }
 
 /** @deprecated Use {@link wantsInstallApp}. */
 export const wantsInstallBin = wantsInstallApp;
 
 /** @deprecated Use resolveInstallPlanMode + shouldIncludeArtifact. */
-export function wantsInstallCompletions(opts: InstallOpts): boolean {
-  return !!(opts.all || opts.completions);
+export function wantsInstallCompletions(_opts: InstallOpts): boolean {
+  return false;
 }
 
 /** @deprecated Use resolveInstallPlanMode + shouldIncludeArtifact. */

package/src/install/shell.ts

@@ -21,20 +21,6 @@ export function rcMarkerEnd(appKey: string, tag: string): string {
   return `# end ${appKey}:${tag}`;
 }
 
-/** Returns rc snippet block for PATH, or null if already present. */
-export function buildPathRcBlock(appKey: string, appDir: string): string {
-  const start = rcMarkerStart(appKey, "path");
-  const end = rcMarkerEnd(appKey, "path");
-  return [start, `export PATH="${appDir}:$PATH"`, end].join("\n");
-}
-
-/** Returns rc snippet block for zsh fpath, or null if already present. */
-export function buildZshFpathRcBlock(appKey: string, completionsDir: string): string {
-  const start = rcMarkerStart(appKey, "fpath");
-  const end = rcMarkerEnd(appKey, "fpath");
-  return [start, `fpath=(${completionsDir} $fpath)`, end].join("\n");
-}
-
 /** Removes a marker-delimited block from rc file content. */
 export function removeRcBlock(content: string, appKey: string, tag: string): string {
   const start = rcMarkerStart(appKey, tag);

package/src/install/status.test.ts

@@ -34,9 +34,9 @@ describe("resolveInstallTargetPreview", () => {
     const paths = resolveInstallPaths(program);
     const preview = resolveInstallTargetPreview(program, paths);
     expect(preview.agentIntegration).toBe("mcp");
-    expect(preview.all).toContain("app");
-    expect(preview.all).toContain("completions");
-    expect(preview.skill).toEqual([]);
+    expect(preview.all).not.toContain("app");
+    expect(preview.all.length).toBeGreaterThan(0);
+    expect(preview.all.every((k) => k.endsWith("Mcp") || k === "configure")).toBe(true);
   });
 
   test("shell app previews skill keys", () => {
@@ -49,7 +49,8 @@ describe("resolveInstallTargetPreview", () => {
     const paths = resolveInstallPaths(program);
     const preview = resolveInstallTargetPreview(program, paths);
     expect(preview.agentIntegration).toBe("skill");
-    expect(preview.all).toContain("app");
+    expect(preview.all).not.toContain("app");
+    expect(preview.all.length).toBeGreaterThan(0);
     expect(preview.mcp).toEqual([]);
   });
 });
@@ -76,8 +77,7 @@ describe("printInstallStatus json", () => {
         effective: { all: string[]; mcp: string[]; skill: string[] };
       };
       expect(parsed.agentIntegration).toBe("mcp");
-      expect(parsed.effective.all).toContain("app");
-      expect(Array.isArray(parsed.effective.skill)).toBe(true);
+      expect(parsed.effective.all.length).toBeGreaterThan(0);
     } finally {
       process.stdout.write = orig;
     }

package/src/install/status.ts

@@ -42,9 +42,6 @@ export function printInstallStatus(root: CliProgram, opts: InstallOpts): void {
       },
     };
     if (status.app) json.app = status.app;
-    if (status.bashCompletion) json.bashCompletion = status.bashCompletion;
-    if (status.zshCompletion) json.zshCompletion = status.zshCompletion;
-    if (status.fishCompletion) json.fishCompletion = status.fishCompletion;
     if (status.cursorSkill) json.cursorSkill = status.cursorSkill;
     if (status.claudeSkill) json.claudeSkill = status.claudeSkill;
     if (status.cursorMcp) json.cursorMcp = status.cursorMcp;
@@ -60,9 +57,6 @@ export function printInstallStatus(root: CliProgram, opts: InstallOpts): void {
   installOut(`Installed artifacts for ${root.key}:`, opts);
   const lines: [string, string | undefined][] = [
     ["app", status.app],
-    ["bash completion", status.bashCompletion],
-    ["zsh completion", status.zshCompletion],
-    ["fish completion", status.fishCompletion],
     ["cursor skill", status.cursorSkill],
     ["claude skill", status.claudeSkill],
     ["cursor mcp", status.cursorMcp],

package/src/install/target-effective.ts

@@ -107,8 +107,6 @@ export interface InstallTargetPreview {
 /** Derives plan mode from install CLI flags. */
 export function resolveInstallPlanMode(opts: {
   all?: boolean;
-  app?: boolean;
-  completions?: boolean;
   skill?: boolean;
   mcp?: boolean;
   configure?: boolean;

package/src/install/target-scope.ts

@@ -30,9 +30,6 @@ export { mcpCategoryEnabled } from "./target-effective.ts";
 function emptyInstalledArtifacts(): InstalledArtifacts {
   return {
     app: false,
-    bashCompletion: false,
-    zshCompletion: false,
-    fishCompletion: false,
     cursorSkill: false,
     claudeSkill: false,
     codexSkill: false,
@@ -45,8 +42,6 @@ function emptyInstalledArtifacts(): InstalledArtifacts {
     codexMcp: false,
     openclawMcp: false,
     chatGptMcp: false,
-    bashRcPath: false,
-    zshRcFpath: false,
   };
 }
 
@@ -62,18 +57,10 @@ export function detectInstalledArtifacts(
   return out;
 }
 
-function isNonInteractiveInstall(opts: InstallOpts): boolean {
-  return !!(opts.yes || opts.json || opts.reinstall || opts.update || opts.dry);
-}
-
-/** Scope flags; non-interactive `install --mcp` implicitly includes app. */
+/** Scope flags for install/uninstall. */
 export function resolveInstallScope(opts: InstallOpts): InstallScope {
-  const assumeApp =
-    !opts.uninstall && opts.mcp && !opts.all && !opts.app && isNonInteractiveInstall(opts);
   return {
     all: opts.all,
-    app: opts.app || assumeApp,
-    completions: opts.completions,
     skill: opts.skill,
     mcp: opts.mcp,
     configure: opts.configure,
@@ -133,22 +120,20 @@ export function isArtifactInScope(
     return t.enabled && t.includedInAll;
   }
 
-  const scoped =
-    scope.app || scope.completions || scope.skill || scope.mcp || scope.configure || false;
-
   if (mode === "uninstall-scoped" || mode === "install-scoped") {
     if (!effective[key].enabled) return false;
-    if (scope.configure) return key === "configure";
-    if (scope.app) return key === "app";
-    if (scope.completions) return key === "completions";
+
+    let inScope = false;
     if (scope.skill) {
-      return agentCategoryInScope(key, SKILL_KEYS, "skill", effective, targets, root);
+      inScope = inScope || agentCategoryInScope(key, SKILL_KEYS, "skill", effective, targets, root);
     }
     if (scope.mcp) {
-      return agentCategoryInScope(key, MCP_KEYS, "mcp", effective, targets, root);
+      inScope = inScope || agentCategoryInScope(key, MCP_KEYS, "mcp", effective, targets, root);
     }
-    if (!scoped && mode === "install-scoped") return false;
-    return false;
+    if (scope.configure && key === "configure") {
+      inScope = true;
+    }
+    return inScope;
   }
 
   return false;
@@ -174,7 +159,11 @@ export function shouldIncludeArtifact(
     return false;
   }
   if (mode === "refresh" && detected) {
-    if (!detected[key]) return false;
+    if (key === "app") {
+      // app is status-only; refresh skills/MCP only
+    } else if (!detected[key]) {
+      return false;
+    }
   }
   if ((mode === "uninstall-all" || mode === "uninstall-scoped") && detected) {
     const det = detected[key];
@@ -194,6 +183,7 @@ export function shouldIncludeArtifact(
     return isArtifactInScope(key, scope, effective, mode, root, targets);
   }
   if (mode === "refresh") {
+    if (key === "app") return false;
     return effective[key].enabled;
   }
   return isArtifactInScope(key, scope, effective, mode, root, targets);
@@ -235,9 +225,6 @@ export function detectedForArtifact(
   detected: DetectedSnapshot,
 ): boolean {
   const target = installTargetForKey(key);
-  if (key === "completions") {
-    return detected.bashCompletion || detected.zshCompletion || detected.fishCompletion;
-  }
   if (key === "configure") {
     return detected.appConfig ?? false;
   }