argsbarg 4.1.1 → 5.0.2

package/src/docs/mcp-resources.test.ts

@@ -1,3 +1,7 @@
+/*
+Tests for docs/mcp-resources module behavior.
+*/
+
 import { expect, test } from "bun:test";
 import type { CliProgram } from "../types.ts";
 import {
@@ -30,14 +34,17 @@ function fixture(opts?: { docs?: boolean; mcp?: boolean }): CliProgram {
   };
 }
 
+/** DefaultDocsTopicResourceUri. */
 test("defaultDocsTopicResourceUri", () => {
   expect(defaultDocsTopicResourceUri("my_app", "readme")).toBe("my_app://docs/readme");
 });
 
+/** ResolveDocsTopicResourceUri sanitizes program key. */
 test("resolveDocsTopicResourceUri sanitizes program key", () => {
   expect(resolveDocsTopicResourceUri(fixture(), "readme")).toBe("my_app://docs/readme");
 });
 
+/** DocsMcpResources when docs and MCP enabled. */
 test("docsMcpResources when docs and MCP enabled", () => {
   const resources = docsMcpResources(fixture());
   expect(resources.map((r) => r.uri)).toEqual(["my_app://docs/readme", "my_app://docs/arch"]);
@@ -47,14 +54,17 @@ test("docsMcpResources when docs and MCP enabled", () => {
   expect(resources[0]?.load()).toBe("# Readme\n");
 });
 
+/** DocsMcpResources empty when docs disabled. */
 test("docsMcpResources empty when docs disabled", () => {
   expect(docsMcpResources(fixture({ docs: false }))).toEqual([]);
 });
 
+/** DocsMcpResources empty when MCP disabled. */
 test("docsMcpResources empty when MCP disabled", () => {
   expect(docsMcpResources(fixture({ mcp: false }))).toEqual([]);
 });
 
+/** Tests that reservedDocsTopicResourceUris matches docsMcpResources URIs. */
 test("reservedDocsTopicResourceUris matches docsMcpResources URIs", () => {
   const program = fixture();
   expect(reservedDocsTopicResourceUris(program)).toEqual(

package/src/formats.test.ts

@@ -1,3 +1,7 @@
+/*
+Tests for formats module behavior.
+*/
+
 import { expect, test } from "bun:test";
 import {
   parseCommaList,
@@ -8,6 +12,7 @@ import {
 } from "./formats.ts";
 import { CliValueFormat } from "./types.ts";
 
+/** ParseDurationMs parses minutes and hours. */
 test("parseDurationMs parses minutes and hours", () => {
   expect(parseDurationMs("30s")).toBe(30_000);
   expect(parseDurationMs("5m")).toBe(5 * 60 * 1000);
@@ -15,21 +20,25 @@ test("parseDurationMs parses minutes and hours", () => {
   expect(parseDurationMs("1d")).toBe(24 * 60 * 60 * 1000);
 });
 
+/** ParseCommaList splits and trims. */
 test("parseCommaList splits and trims", () => {
   expect(parseCommaList("a,b")).toEqual(["a", "b"]);
   expect(parseCommaList(" a , b , ")).toEqual(["a", "b"]);
 });
 
+/** ParseDate validates calendar dates. */
 test("parseDate validates calendar dates", () => {
   expect(parseDate("2026-06-22")).toBe("2026-06-22");
   expect(() => parseDate("2026-02-30")).toThrow();
 });
 
+/** ParseDateTime normalizes to UTC ISO. */
 test("parseDateTime normalizes to UTC ISO", () => {
   expect(parseDateTime("2026-06-22T15:00:00Z")).toBe("2026-06-22T15:00:00.000Z");
   expect(() => parseDateTime("2026-06-22")).toThrow();
 });
 
+/** ValidateFormatValue rejects invalid duration. */
 test("validateFormatValue rejects invalid duration", () => {
   expect(() => validateFormatValue("nope", CliValueFormat.Duration)).toThrow();
 });

package/src/headless.test.ts

@@ -1,3 +1,7 @@
+/*
+Tests for headless module behavior.
+*/
+
 import { expect, test } from "bun:test";
 import {
   formatDryRunMessage,
@@ -8,12 +12,14 @@ import {
   wantsExplicitJson,
 } from "./headless.ts";
 
+/** WantsExplicitJson includes MCP invocation. */
 test("wantsExplicitJson includes MCP invocation", () => {
   expect(wantsExplicitJson({ invocation: "cli" }, false)).toBe(false);
   expect(wantsExplicitJson({ invocation: "mcp" }, false)).toBe(true);
   expect(wantsExplicitJson({ invocation: "cli" }, true)).toBe(true);
 });
 
+/** Tests that shouldRunHeadless is true for MCP and json. */
 test("shouldRunHeadless is true for MCP and json", () => {
   expect(shouldRunHeadless({ invocation: "mcp" }, false)).toBe(true);
   expect(shouldRunHeadless({ invocation: "cli" }, true)).toBe(true);
@@ -21,6 +27,7 @@ test("shouldRunHeadless is true for MCP and json", () => {
   expect(shouldRunHeadless({ invocation: "cli" }, false, false, false)).toBe(true);
 });
 
+/** Tests that shouldRunHeadlessWithPositionals requires positionals in non-tty. */
 test("shouldRunHeadlessWithPositionals requires positionals in non-tty", () => {
   expect(shouldRunHeadlessWithPositionals({ invocation: "cli" }, false, [], false, false)).toBe(
     false,
@@ -30,6 +37,7 @@ test("shouldRunHeadlessWithPositionals requires positionals in non-tty", () => {
   );
 });
 
+/** Tests that shouldRunHeadlessWithYes requires yes in non-tty. */
 test("shouldRunHeadlessWithYes requires yes in non-tty", () => {
   expect(
     shouldRunHeadlessWithYes({ invocation: "cli" }, { yes: true, hasRequiredArgs: true }, false),
@@ -46,11 +54,13 @@ test("shouldRunHeadlessWithYes requires yes in non-tty", () => {
   ).toBe(true);
 });
 
+/** Tests that formatDryRunMessage prefixes dry-run output. */
 test("formatDryRunMessage prefixes dry-run output", () => {
   expect(formatDryRunMessage("hello", false)).toBe("hello");
   expect(formatDryRunMessage("hello", true)).toBe("[DRY RUN] hello");
 });
 
+/** Tests that requireYesInNonTty exits without yes in non-tty. */
 test("requireYesInNonTty exits without yes in non-tty", () => {
   const originalExit = process.exit;
   let code: number | undefined;

package/src/hidden-mcpb.test.ts

@@ -1,3 +1,7 @@
+/*
+Tests for hidden-mcpb module behavior.
+*/
+
 import { describe, expect, test } from "bun:test";
 import { mkdirSync, mkdtempSync, readFileSync, realpathSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
@@ -53,12 +57,15 @@ const hiddenFixture: CliProgram = {
   ],
 };
 
+/** Tests for hidden commands and options. */
 describe("hidden commands and options", () => {
+  /** Parse root includes hidden commands. */
   test("parse root includes hidden commands", () => {
     const parse = cliParseRoot(hiddenFixture);
     expect(parse.commands?.map((c) => c.key)).toContain("secret");
   });
 
+  /** Presentation root omits hidden commands. */
   test("presentation root omits hidden commands", () => {
     const presentation = cliPresentationRoot(hiddenFixture);
     const keys = presentation.commands?.map((c) => c.key) ?? [];
@@ -66,23 +73,27 @@ describe("hidden commands and options", () => {
     expect(keys).not.toContain("secret");
   });
 
+  /** Root help omits hidden commands. */
   test("root help omits hidden commands", () => {
     const help = cliHelpRender(cliParseRoot(hiddenFixture), [], false);
     expect(help).toContain("public");
     expect(help).not.toContain("secret");
   });
 
+  /** Hidden command -h still works. */
   test("hidden command -h still works", () => {
     const help = cliHelpRender(cliParseRoot(hiddenFixture), ["secret"], false);
     expect(help).toContain("Hidden command.");
   });
 
+  /** Tests that help omits hidden options. */
   test("help omits hidden options", () => {
     const help = cliHelpRender(cliParseRoot(hiddenFixture), ["flags"], false);
     expect(help).toContain("--visible");
     expect(help).not.toContain("secret-flag");
   });
 
+  /** Tests that schema export omits hidden nodes and options. */
   test("schema export omits hidden nodes and options", () => {
     const schema = cliSchemaExport(hiddenFixture);
     const keys = schema.commands?.map((c) => c.key) ?? [];
@@ -92,13 +103,16 @@ describe("hidden commands and options", () => {
     expect(flags?.options?.map((o) => o.name)).toEqual(["visible"]);
   });
 
+  /** MCP tools omit hidden commands. */
   test("MCP tools omit hidden commands", () => {
     const tools = collectMcpTools(hiddenFixture);
     expect(tools.map((t) => t.name)).toEqual(["public", "flags"]);
   });
 });
 
+/** Tests for mcp router. */
 describe("mcp router", () => {
+  /** Presentation exposes mcp bundle but not hidden serve. */
   test("presentation exposes mcp bundle but not hidden serve", () => {
     const builtins = exportPresentationBuiltins(hiddenFixture);
     const mcp = builtins.find((b) => b.key === "mcp");
@@ -107,6 +121,7 @@ describe("mcp router", () => {
     expect(mcp?.fallbackCommand).toBe("serve");
   });
 
+  /** Mcp help lists bundle. */
   test("mcp help lists bundle", () => {
     const help = cliHelpRender(cliParseRoot(hiddenFixture), ["mcp"], false);
     expect(help).toContain("bundle");
@@ -114,7 +129,9 @@ describe("mcp router", () => {
   });
 });
 
+/** Tests for mcp bundle. */
 describe("mcp bundle", () => {
+  /** Tests that generateMcpManifest uses mcpServerId and binary entry. */
   test("generateMcpManifest uses mcpServerId and binary entry", () => {
     const manifest = generateMcpManifest(hiddenFixture, "myapp");
     expect(manifest.name).toBe("myapp");
@@ -128,6 +145,7 @@ describe("mcp bundle", () => {
     expect((manifest.compatibility as { platforms: string[] }).platforms).toEqual(["darwin"]);
   });
 
+  /** DefaultMcpBundlePaths. */
   test("defaultMcpBundlePaths", () => {
     const cwd = "/tmp/work";
     const paths = defaultMcpBundlePaths(hiddenFixture, cwd);
@@ -135,6 +153,7 @@ describe("mcp bundle", () => {
     expect(paths.outPath).toBe(join(cwd, "dist", "myapp.mcpb"));
   });
 
+  /** Tests that packMcpBundle writes zip with manifest and binary. */
   test("packMcpBundle writes zip with manifest and binary", () => {
     const work = mkdtempSync(join(tmpdir(), "mcpb-test-"));
     try {
@@ -155,6 +174,7 @@ describe("mcp bundle", () => {
     }
   });
 
+  /** RunMcpBundle prints mcpb and plugin paths. */
   test("runMcpBundle prints mcpb and plugin paths", () => {
     const work = mkdtempSync(join(tmpdir(), "mcpb-run-"));
     const stdout: string[] = [];
@@ -188,6 +208,7 @@ describe("mcp bundle", () => {
     }
   });
 
+  /** RunMcpBundle with claudePlugin only prints plugin path. */
   test("runMcpBundle with claudePlugin only prints plugin path", () => {
     const work = mkdtempSync(join(tmpdir(), "mcpb-run-"));
     const stdout: string[] = [];
@@ -220,6 +241,7 @@ describe("mcp bundle", () => {
     }
   });
 
+  /** RunMcpBundle errors when no bundle flags enabled. */
   test("runMcpBundle errors when no bundle flags enabled", () => {
     const fixture: CliProgram = {
       ...hiddenFixture,

package/src/index.ts

@@ -34,11 +34,11 @@ export type {
   CliAppConfigEntry,
   CliAppConfigResolveContext,
   CliAppConfigResolveFn,
+  CliConfigureConfig,
+  CliConfigureTargets,
   CliDocsConfig,
   CliDocsTopic,
   CliHandler,
-  CliInstallConfig,
-  CliInstallTargets,
   CliInvocation,
   CliMcpBundleConfig,
   CliMcpResource,

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

@@ -1,3 +1,7 @@
+/*
+Tests for install/binary-placement module behavior.
+*/
+
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 import { chmodSync, mkdirSync, mkdtempSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
@@ -30,12 +34,15 @@ afterEach(() => {
   rmSync(tmp, { recursive: true, force: true });
 });
 
+/** Tests for isExternallyManagedBinary. */
 describe("isExternallyManagedBinary", () => {
+  /** Tests that false when command is not on PATH. */
   test("false when command is not on PATH", () => {
     process.env.PATH = tmp;
     expect(isExternallyManagedBinary("placementapp-not-on-path")).toBe(false);
   });
 
+  /** Tests that true when PATH resolves to execPath. */
   test("true when PATH resolves to execPath", () => {
     const bin = join(tmp, "placementapp");
     writeFileSync(bin, "#!/bin/sh\n", "utf8");
@@ -44,6 +51,7 @@ describe("isExternallyManagedBinary", () => {
     expect(isExternallyManagedBinary("placementapp", bin)).toBe(true);
   });
 
+  /** Tests that true when PATH entry is a symlink to execPath. */
   test("true when PATH entry is a symlink to execPath", () => {
     const bin = join(tmp, "placementapp");
     const target = join(tmp, "real-binary");
@@ -53,6 +61,7 @@ describe("isExternallyManagedBinary", () => {
     expect(isExternallyManagedBinary("placementapp", target)).toBe(true);
   });
 
+  /** Tests that false when PATH points at a different binary. */
   test("false when PATH points at a different binary", () => {
     const bin = join(tmp, "placementapp");
     const other = join(tmp, "other");
@@ -63,7 +72,9 @@ describe("isExternallyManagedBinary", () => {
   });
 });
 
+/** Tests for isAppInstalled. */
 describe("isAppInstalled", () => {
+  /** Tests that true when externally managed. */
   test("true when externally managed", () => {
     const bin = join(tmp, program.key);
     const prevExec = process.execPath;
@@ -78,6 +89,7 @@ describe("isAppInstalled", () => {
     }
   });
 
+  /** Tests that false when not on PATH and no local copy. */
   test("false when not on PATH and no local copy", () => {
     const home = mkdtempSync(join(tmpdir(), "argsbarg-placement-home-"));
     const prevHome = process.env.HOME;
@@ -93,7 +105,9 @@ describe("isAppInstalled", () => {
   });
 });
 
+/** Tests for resolvePathCommand. */
 describe("resolvePathCommand", () => {
+  /** Tests that returns undefined when missing. */
   test("returns undefined when missing", () => {
     process.env.PATH = tmp;
     expect(resolvePathCommand("missing-cmd")).toBeUndefined();

package/src/install/gh-release-update.test.ts

@@ -1,22 +1,31 @@
+/*
+Tests for install/gh-release-update module behavior.
+*/
+
 import { expect, test } from "bun:test";
 import { isAlreadyCurrent, parseReleaseTag } from "./gh-release-update.ts";
 
+/** ParseReleaseTag strips leading v. */
 test("parseReleaseTag strips leading v", () => {
   expect(parseReleaseTag("v1.4.3")).toBe("1.4.3");
 });
 
+/** ParseReleaseTag leaves bare semver unchanged. */
 test("parseReleaseTag leaves bare semver unchanged", () => {
   expect(parseReleaseTag("1.4.3")).toBe("1.4.3");
 });
 
+/** ParseReleaseTag throws on empty tag. */
 test("parseReleaseTag throws on empty tag", () => {
   expect(() => parseReleaseTag("")).toThrow("Release tag is empty");
 });
 
+/** Tests that isAlreadyCurrent returns true when versions match. */
 test("isAlreadyCurrent returns true when versions match", () => {
   expect(isAlreadyCurrent("1.4.3", "1.4.3")).toBe(true);
 });
 
+/** Tests that isAlreadyCurrent returns false when versions differ. */
 test("isAlreadyCurrent returns false when versions differ", () => {
   expect(isAlreadyCurrent("1.4.2", "1.4.3")).toBe(false);
 });

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

@@ -1,3 +1,7 @@
+/*
+Tests for install/install-validate module behavior.
+*/
+
 import { describe, expect, test } from "bun:test";
 import type { CliProgram } from "../types.ts";
 import { CliSchemaValidationError } from "../types.ts";
@@ -10,25 +14,29 @@ const base: CliProgram = {
   handler: () => {},
 };
 
-describe("validateInstallConfig", () => {
+/** Tests for validateConfigureConfig. */
+describe("validateConfigureConfig", () => {
+  /** Tests that accepts empty install config. */
   test("accepts empty install config", () => {
     expect(() => cliValidateProgram(base)).not.toThrow();
   });
 
+  /** Rejects removed allSkills shorthand. */
   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/);
   });
 
+  /** Rejects both sides of pair without both integration. */
   test("rejects both sides of pair without both integration", () => {
     const program: CliProgram = {
       ...base,
       mcpServer: { enabled: true },
-      install: {
+      configure: {
         agentIntegration: "mcp",
         targets: { cursorMcp: true, cursorSkill: true },
       },
@@ -36,10 +44,11 @@ describe("validateInstallConfig", () => {
     expect(() => cliValidateProgram(program)).toThrow(/both/);
   });
 
+  /** Rejects explicit MCP target in skill integration mode. */
   test("rejects explicit MCP target in skill integration mode", () => {
     const program: CliProgram = {
       ...base,
-      install: {
+      configure: {
         agentIntegration: "skill",
         targets: { cursorMcp: true },
       },
@@ -47,11 +56,12 @@ describe("validateInstallConfig", () => {
     expect(() => cliValidateProgram(program)).toThrow(/cursorMcp/);
   });
 
+  /** Allows explicit pair targets with both integration. */
   test("allows explicit pair targets with both integration", () => {
     const program: CliProgram = {
       ...base,
       mcpServer: { enabled: true },
-      install: {
+      configure: {
         agentIntegration: "both",
         targets: { cursorMcp: true, cursorSkill: true },
       },

package/src/install/mcp-codex.test.ts

@@ -1,3 +1,7 @@
+/*
+Tests for install/mcp-codex module behavior.
+*/
+
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
@@ -19,7 +23,9 @@ afterEach(() => {
   rmSync(home, { recursive: true, force: true });
 });
 
+/** Tests for codex mcp config. */
 describe("codex mcp config", () => {
+  /** ReadCodexMcpEntry parses simple command/args. */
   test("readCodexMcpEntry parses simple command/args", () => {
     const path = resolveCodexConfigPath(home);
     mkdirSync(join(home, ".codex"), { recursive: true });
@@ -38,6 +44,7 @@ args = ["mcp"]
     expect(codexMcpHasServer(home, "testapp")).toBe(true);
   });
 
+  /** ReadCodexMcpEntry parses transport stdio block. */
   test("readCodexMcpEntry parses transport stdio block", () => {
     const path = resolveCodexConfigPath(home);
     mkdirSync(join(home, ".codex"), { recursive: true });

package/src/install/mcp-openclaw.test.ts

@@ -1,3 +1,7 @@
+/*
+Tests for install/mcp-openclaw module behavior.
+*/
+
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
@@ -19,7 +23,9 @@ afterEach(() => {
   rmSync(home, { recursive: true, force: true });
 });
 
+/** Tests for openclaw mcp config. */
 describe("openclaw mcp config", () => {
+  /** OpenclawMcpHasServer detects configured server. */
   test("openclawMcpHasServer detects configured server", () => {
     const path = resolveOpenclawConfigPath(home);
     mkdirSync(join(home, ".openclaw"), { recursive: true });

package/src/install/mcp-opencode.test.ts

@@ -1,3 +1,7 @@
+/*
+Tests for install/mcp-opencode module behavior.
+*/
+
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
@@ -41,7 +45,9 @@ afterEach(() => {
   rmSync(home, { recursive: true, force: true });
 });
 
+/** Tests for opencode mcp config. */
 describe("opencode mcp config", () => {
+  /** ResolveOpenCodeConfigPathForInstall prefers existing file. */
   test("resolveOpenCodeConfigPathForInstall prefers existing file", () => {
     const dir = opencodeConfigDir(home);
     mkdirSync(dir, { recursive: true });
@@ -50,6 +56,7 @@ describe("opencode mcp config", () => {
     expect(resolveOpenCodeConfigPathForInstall(home)).toBe(existing);
   });
 
+  /** ResolveOpenCodeConfigPathForInstall defaults to config.json. */
   test("resolveOpenCodeConfigPathForInstall defaults to config.json", () => {
     mkdirSync(opencodeConfigDir(home), { recursive: true });
     expect(resolveOpenCodeConfigPathForInstall(home)).toBe(
@@ -57,6 +64,7 @@ describe("opencode mcp config", () => {
     );
   });
 
+  /** MergeOpenCodeMcpConfig writes mcp block. */
   test("mergeOpenCodeMcpConfig writes mcp block", () => {
     const path = resolveOpenCodeConfigPathForInstall(home);
     mkdirSync(opencodeConfigDir(home), { recursive: true });
@@ -70,6 +78,7 @@ describe("opencode mcp config", () => {
     expect(data.mcp.testapp).toEqual(entry);
   });
 
+  /** DetectOpenCodeMcpConfigPath finds entry across filenames. */
   test("detectOpenCodeMcpConfigPath finds entry across filenames", () => {
     const dir = opencodeConfigDir(home);
     mkdirSync(dir, { recursive: true });
@@ -86,6 +95,7 @@ describe("opencode mcp config", () => {
     expect(detectOpenCodeMcpConfigPath(home, "testapp")).toBe(path);
   });
 
+  /** RemoveOpenCodeMcpConfig deletes server entry. */
   test("removeOpenCodeMcpConfig deletes server entry", () => {
     const path = resolveOpenCodeConfigPathForInstall(home);
     mkdirSync(opencodeConfigDir(home), { recursive: true });

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/status.test.ts

@@ -1,3 +1,7 @@
+/*
+Tests for install/status module behavior.
+*/
+
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 import { mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
@@ -22,7 +26,9 @@ afterEach(() => {
   rmSync(home, { recursive: true, force: true });
 });
 
+/** Tests for resolveInstallTargetPreview. */
 describe("resolveInstallTargetPreview", () => {
+  /** Mcp app previews MCP keys for all and mcp scopes. */
   test("mcp app previews MCP keys for all and mcp scopes", () => {
     const program: CliProgram = {
       key: "mcpapp",
@@ -39,6 +45,7 @@ describe("resolveInstallTargetPreview", () => {
     expect(preview.all.every((k) => k.endsWith("Mcp") || k === "configure")).toBe(true);
   });
 
+  /** Tests that shell app previews skill keys. */
   test("shell app previews skill keys", () => {
     const program: CliProgram = {
       key: "cliapp",
@@ -55,7 +62,9 @@ describe("resolveInstallTargetPreview", () => {
   });
 });
 
+/** Tests for printInstallStatus json. */
 describe("printInstallStatus json", () => {
+  /** Includes agentIntegration and effective scopes. */
   test("includes agentIntegration and effective scopes", () => {
     const program: CliProgram = {
       key: "app",

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));