argsbarg 4.1.0 → 5.0.1

package/src/install/binary-placement.test.ts

@@ -0,0 +1,101 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { chmodSync, mkdirSync, mkdtempSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type { CliProgram } from "../types.ts";
+import {
+  isAppInstalled,
+  isExternallyManagedBinary,
+  resolvePathCommand,
+} from "./binary-placement.ts";
+
+const program: CliProgram = {
+  key: "placementapp",
+  version: "1.0.0",
+  description: "x",
+  handler: () => {},
+};
+
+let tmp: string;
+let prevPath: string | undefined;
+
+beforeEach(() => {
+  tmp = mkdtempSync(join(tmpdir(), "argsbarg-placement-"));
+  prevPath = process.env.PATH;
+});
+
+afterEach(() => {
+  if (prevPath === undefined) delete process.env.PATH;
+  else process.env.PATH = prevPath;
+  rmSync(tmp, { recursive: true, force: true });
+});
+
+describe("isExternallyManagedBinary", () => {
+  test("false when command is not on PATH", () => {
+    process.env.PATH = tmp;
+    expect(isExternallyManagedBinary("placementapp-not-on-path")).toBe(false);
+  });
+
+  test("true when PATH resolves to execPath", () => {
+    const bin = join(tmp, "placementapp");
+    writeFileSync(bin, "#!/bin/sh\n", "utf8");
+    chmodSync(bin, 0o755);
+    process.env.PATH = tmp;
+    expect(isExternallyManagedBinary("placementapp", bin)).toBe(true);
+  });
+
+  test("true when PATH entry is a symlink to execPath", () => {
+    const bin = join(tmp, "placementapp");
+    const target = join(tmp, "real-binary");
+    writeFileSync(target, "fake", "utf8");
+    symlinkSync(target, bin);
+    process.env.PATH = tmp;
+    expect(isExternallyManagedBinary("placementapp", target)).toBe(true);
+  });
+
+  test("false when PATH points at a different binary", () => {
+    const bin = join(tmp, "placementapp");
+    const other = join(tmp, "other");
+    writeFileSync(bin, "a", "utf8");
+    writeFileSync(other, "b", "utf8");
+    process.env.PATH = tmp;
+    expect(isExternallyManagedBinary("placementapp", other)).toBe(false);
+  });
+});
+
+describe("isAppInstalled", () => {
+  test("true when externally managed", () => {
+    const bin = join(tmp, program.key);
+    const prevExec = process.execPath;
+    writeFileSync(bin, "x", "utf8");
+    chmodSync(bin, 0o755);
+    process.env.PATH = tmp;
+    process.execPath = bin;
+    try {
+      expect(isAppInstalled(program)).toBe(true);
+    } finally {
+      process.execPath = prevExec;
+    }
+  });
+
+  test("false when not on PATH and no local copy", () => {
+    const home = mkdtempSync(join(tmpdir(), "argsbarg-placement-home-"));
+    const prevHome = process.env.HOME;
+    process.env.HOME = home;
+    process.env.PATH = tmp;
+    try {
+      expect(isAppInstalled(program)).toBe(false);
+    } finally {
+      if (prevHome === undefined) delete process.env.HOME;
+      else process.env.HOME = prevHome;
+      rmSync(home, { recursive: true, force: true });
+    }
+  });
+});
+
+describe("resolvePathCommand", () => {
+  test("returns undefined when missing", () => {
+    process.env.PATH = tmp;
+    expect(resolvePathCommand("missing-cmd")).toBeUndefined();
+  });
+});

package/src/install/binary-placement.ts

@@ -0,0 +1,47 @@
+import { accessSync, constants, realpathSync } from "node:fs";
+import { delimiter, join } from "node:path";
+import type { CliProgram } from "../types.ts";
+
+/** Resolves a command name on PATH to its real path, if present. */
+export function resolvePathCommand(key: string): string | undefined {
+  const pathEnv = process.env.PATH ?? "";
+  for (const dir of pathEnv.split(delimiter)) {
+    if (!dir) continue;
+    const candidate = join(dir, key);
+    try {
+      accessSync(candidate, constants.F_OK);
+      return realpathSync(candidate);
+    } catch {}
+  }
+
+  const found = Bun.which(key);
+  if (found === null) return undefined;
+  try {
+    return realpathSync(found);
+  } catch {
+    return found;
+  }
+}
+
+function realpathOrSelf(path: string): string {
+  try {
+    return realpathSync(path);
+  } catch {
+    return path;
+  }
+}
+
+/** True when PATH resolves to the running executable (e.g. Homebrew Cellar). */
+export function isExternallyManagedBinary(
+  key: string,
+  execPath: string = process.execPath,
+): boolean {
+  const resolved = resolvePathCommand(key);
+  if (!resolved) return false;
+  return resolved === realpathOrSelf(execPath);
+}
+
+/** True when the app binary is available on PATH (e.g. Homebrew). */
+export function isAppInstalled(program: CliProgram): boolean {
+  return isExternallyManagedBinary(program.key);
+}

package/src/install/install-validate.test.ts

@@ -10,7 +10,7 @@ const base: CliProgram = {
   handler: () => {},
 };
 
-describe("validateInstallConfig", () => {
+describe("validateConfigureConfig", () => {
   test("accepts empty install config", () => {
     expect(() => cliValidateProgram(base)).not.toThrow();
   });
@@ -18,7 +18,7 @@ describe("validateInstallConfig", () => {
   test("rejects removed allSkills shorthand", () => {
     const program = {
       ...base,
-      install: { targets: { allSkills: true } },
+      configure: { targets: { allSkills: true } },
     } as CliProgram;
     expect(() => cliValidateProgram(program)).toThrow(CliSchemaValidationError);
     expect(() => cliValidateProgram(program)).toThrow(/allSkills/);
@@ -28,7 +28,7 @@ describe("validateInstallConfig", () => {
     const program: CliProgram = {
       ...base,
       mcpServer: { enabled: true },
-      install: {
+      configure: {
         agentIntegration: "mcp",
         targets: { cursorMcp: true, cursorSkill: true },
       },
@@ -39,7 +39,7 @@ describe("validateInstallConfig", () => {
   test("rejects explicit MCP target in skill integration mode", () => {
     const program: CliProgram = {
       ...base,
-      install: {
+      configure: {
         agentIntegration: "skill",
         targets: { cursorMcp: true },
       },
@@ -51,7 +51,7 @@ describe("validateInstallConfig", () => {
     const program: CliProgram = {
       ...base,
       mcpServer: { enabled: true },
-      install: {
+      configure: {
         agentIntegration: "both",
         targets: { cursorMcp: true, cursorSkill: 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/opts.ts

@@ -0,0 +1,17 @@
+import type { InstallOpts } from "./target-types.ts";
+
+export function parseInstallOpts(raw: Record<string, string>): InstallOpts {
+  const flag = (name: string) => raw[name] === "1";
+  return {
+    all: flag("all"),
+    skill: flag("skill"),
+    mcp: flag("mcp"),
+    reinstall: flag("reinstall"),
+    status: flag("status"),
+    uninstall: flag("uninstall"),
+    configure: flag("configure"),
+    yes: flag("yes"),
+    dry: flag("dry"),
+    json: flag("json"),
+  };
+}

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

@@ -1,7 +1,7 @@
 import { resolveCapabilities } from "../capabilities.ts";
 import type {
-  CliInstallConfig,
-  CliInstallTargets,
+  CliConfigureConfig,
+  CliConfigureTargets,
   CliProgram,
   InstallAgentIntegration,
   InstallTargetSpec,
@@ -15,10 +15,10 @@ export type { InstallTargetSpec, ResolvedInstallTarget } from "../types.ts";
 export type { InstallPlanMode, InstallScope } from "./target-types.ts";
 
 export function resolveAgentIntegration(
-  install?: CliInstallConfig,
+  configure?: CliConfigureConfig,
   mcpEnabled = false,
 ): InstallAgentIntegration {
-  return install?.agentIntegration ?? (mcpEnabled ? "mcp" : "skill");
+  return configure?.agentIntegration ?? (mcpEnabled ? "mcp" : "skill");
 }
 
 /** Resolves a boolean or object target spec against category defaults. */
@@ -52,7 +52,7 @@ function artifactDefaults(
 
 function applyAgentPairDedupe(
   out: Record<CliInstallArtifactKey, { enabled: boolean; includedInAll: boolean }>,
-  user: CliInstallTargets | undefined,
+  user: CliConfigureTargets | undefined,
   integration: InstallAgentIntegration,
 ): void {
   if (integration === "both") return;
@@ -78,12 +78,12 @@ function applyAgentPairDedupe(
 
 /** Effective per-artifact gates for install.targets. */
 export function resolveEffectiveInstallTargets(
-  install?: CliInstallConfig,
+  configure?: CliConfigureConfig,
   program?: Pick<CliProgram, "mcpServer">,
 ): Record<CliInstallArtifactKey, { enabled: boolean; includedInAll: boolean }> {
   const mcpEnabled = program?.mcpServer?.enabled === true;
-  const integration = resolveAgentIntegration(install, mcpEnabled);
-  const user = install?.targets;
+  const integration = resolveAgentIntegration(configure, mcpEnabled);
+  const user = configure?.targets;
   const out = {} as Record<CliInstallArtifactKey, { enabled: boolean; includedInAll: boolean }>;
   for (const key of INSTALL_ARTIFACT_KEYS) {
     out[key] = resolveInstallTargetSpec(user?.[key], artifactDefaults(key, integration));
@@ -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

@@ -1,6 +1,6 @@
 import { resolveCapabilities } from "../capabilities.ts";
 import { appConfigInstalled } from "../config/file.ts";
-import type { CliInstallTargets, CliProgram } from "../types.ts";
+import type { CliConfigureTargets, CliProgram } from "../types.ts";
 import type { InstallPaths } from "./paths.ts";
 import {
   type InstallPlanMode,
@@ -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,
@@ -91,7 +78,7 @@ export function buildDetectedSnapshot(root: CliProgram, paths: InstallPaths): De
 }
 
 function targetExplicitlyConfigured(
-  user: CliInstallTargets | undefined,
+  user: CliConfigureTargets | undefined,
   key: CliInstallArtifactKey,
 ): boolean {
   return user?.[key] !== undefined;
@@ -102,7 +89,7 @@ function agentCategoryInScope(
   categoryKeys: readonly CliInstallArtifactKey[],
   category: "skill" | "mcp",
   effective: Record<CliInstallArtifactKey, { enabled: boolean; includedInAll: boolean }>,
-  targets: CliInstallTargets | undefined,
+  targets: CliConfigureTargets | undefined,
   root: CliProgram,
 ): boolean {
   if (!categoryKeys.includes(key)) return false;
@@ -118,7 +105,7 @@ export function isArtifactInScope(
   effective: Record<CliInstallArtifactKey, { enabled: boolean; includedInAll: boolean }>,
   mode: InstallPlanMode,
   root: CliProgram,
-  targets?: CliInstallTargets,
+  targets?: CliConfigureTargets,
 ): boolean {
   if (mode === "uninstall-all") {
     return true;
@@ -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;
@@ -165,7 +150,7 @@ export function shouldIncludeArtifact(
   detected?: Partial<Record<CliInstallArtifactKey, boolean>>,
 ): boolean {
   const target = installTargetForKey(key);
-  const targets = root.install?.targets;
+  const targets = root.configure?.targets;
 
   if (key !== "configure" && target && !target.isAvailable(root, paths)) {
     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);
@@ -206,7 +196,7 @@ export function buildTargetPlanContext(
   opts: InstallOpts,
   detected: DetectedSnapshot,
 ): TargetPlanContext {
-  const effective = resolveEffectiveInstallTargets(root.install, root);
+  const effective = resolveEffectiveInstallTargets(root.configure, root);
   const mode = resolveInstallPlanMode(opts);
   const scope = resolveInstallScope(opts);
   const detPartial = Object.fromEntries(
@@ -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;
   }
@@ -249,8 +236,11 @@ export function resolveInstallTargetPreview(
   program: CliProgram,
   paths: InstallPaths,
 ): InstallTargetPreview {
-  const effective = resolveEffectiveInstallTargets(program.install, program);
-  const integration = resolveAgentIntegration(program.install, program.mcpServer?.enabled === true);
+  const effective = resolveEffectiveInstallTargets(program.configure, program);
+  const integration = resolveAgentIntegration(
+    program.configure,
+    program.mcpServer?.enabled === true,
+  );
 
   const keysForScope = (scope: InstallScope, mode: InstallPlanMode): CliInstallArtifactKey[] =>
     INSTALL_ARTIFACT_KEYS.filter((key) =>