argsbarg 4.1.0 → 4.1.1

package/src/install/target-types.ts

@@ -12,8 +12,6 @@ export type InstallPlanMode =
 
 export interface InstallScope {
   all?: boolean;
-  app?: boolean;
-  completions?: boolean;
   skill?: boolean;
   mcp?: boolean;
   configure?: boolean;
@@ -29,7 +27,6 @@ export type CliInstallArtifactKey =
   | "claudeSkill"
   | "codexMcp"
   | "codexSkill"
-  | "completions"
   | "configure"
   | "cursorMcp"
   | "cursorSkill"
@@ -40,7 +37,6 @@ export type CliInstallArtifactKey =
 
 export type InstallActionKind =
   | "app"
-  | "completions"
   | "cursor-skill"
   | "claude-skill"
   | "codex-skill"
@@ -73,9 +69,6 @@ export interface UninstallAction {
 
 export interface InstalledArtifacts {
   app: boolean;
-  bashCompletion: boolean;
-  zshCompletion: boolean;
-  fishCompletion: boolean;
   cursorSkill: boolean;
   claudeSkill: boolean;
   codexSkill: boolean;
@@ -88,15 +81,10 @@ export interface InstalledArtifacts {
   codexMcp: boolean;
   openclawMcp: boolean;
   chatGptMcp: boolean;
-  bashRcPath: boolean;
-  zshRcFpath: boolean;
 }
 
 export interface InstallStatus {
   app?: string;
-  bashCompletion?: string;
-  zshCompletion?: string;
-  fishCompletion?: string;
   cursorSkill?: string;
   claudeSkill?: string;
   codexSkill?: string;
@@ -117,13 +105,9 @@ export interface DetectedSnapshot extends InstalledArtifacts {
 
 export interface InstallOpts {
   all?: boolean;
-  app?: boolean;
-  completions?: boolean;
   skill?: boolean;
   mcp?: boolean;
   reinstall?: boolean;
-  update?: boolean;
-  from?: string;
   status?: boolean;
   uninstall?: boolean;
   configure?: boolean;

package/src/install/targets/app.ts

@@ -1,6 +1,5 @@
-import { existsSync } from "node:fs";
 import type { CliProgram } from "../../types.ts";
-import { installApp, uninstallApp } from "../app.ts";
+import { isExternallyManagedBinary } from "../binary-placement.ts";
 import { displayInstallPath, type InstallPaths } from "../paths.ts";
 import { InstallTarget } from "../target-base.ts";
 import type {
@@ -12,57 +11,49 @@ import type {
   UninstallAction,
 } from "../target-types.ts";
 
-/** Installs the compiled app to ~/.local/bin/<key>. */
+/** Reports app install location (Homebrew PATH or legacy ~/.local/bin). No self-install actions. */
 class AppInstallTarget extends InstallTarget {
   readonly key = "app" as const;
   readonly actionKind = "app" as const;
   readonly category = "core" as const;
 
+  defaultIncludedInAll(): boolean {
+    return false;
+  }
+
   isAvailable(_root: CliProgram, _paths: InstallPaths): boolean {
     return true;
   }
 
-  isDetected(paths: InstallPaths, _root: CliProgram): boolean {
-    return existsSync(paths.appPath);
+  isDetected(paths: InstallPaths, root: CliProgram): boolean {
+    return isExternallyManagedBinary(root.key) || false;
   }
 
-  applyDetected(paths: InstallPaths, root: CliProgram, out: InstalledArtifacts): void {
-    out.app = this.isDetected(paths, root);
+  applyDetected(_paths: InstallPaths, root: CliProgram, out: InstalledArtifacts): void {
+    out.app = isExternallyManagedBinary(root.key);
   }
 
   protected isDetectedFromSnapshot(detected: DetectedSnapshot): boolean {
     return detected.app;
   }
 
-  protected formatStatusLine(paths: InstallPaths, _root: CliProgram): string {
-    return displayInstallPath(paths.appPath);
+  protected formatStatusLine(_paths: InstallPaths, root: CliProgram): string {
+    if (isExternallyManagedBinary(root.key)) {
+      return "system (PATH)";
+    }
+    return "not installed (use Homebrew)";
   }
 
   protected assignStatusLine(status: InstallStatus, line: string): void {
     status.app = line;
   }
 
-  protected buildInstallActions(ctx: TargetPlanContext): InstallAction[] {
-    const sourcePath = ctx.opts.from ?? process.execPath;
-    return [
-      {
-        kind: this.actionKind,
-        summary: `app: ${displayInstallPath(ctx.paths.appPath)}`,
-        message: `Installing app to ${displayInstallPath(ctx.paths.appPath)}`,
-        run: () => installApp(ctx.root, ctx.paths, ctx.dry, sourcePath).changedFiles,
-      },
-    ];
+  protected buildInstallActions(_ctx: TargetPlanContext): InstallAction[] {
+    return [];
   }
 
-  protected buildUninstallActions(ctx: TargetPlanContext): UninstallAction[] {
-    return [
-      {
-        kind: this.actionKind,
-        summary: `app: ${displayInstallPath(ctx.paths.appPath)}`,
-        message: `Removing app ${displayInstallPath(ctx.paths.appPath)}`,
-        run: () => uninstallApp(ctx.root, ctx.paths, ctx.dry),
-      },
-    ];
+  protected buildUninstallActions(_ctx: TargetPlanContext): UninstallAction[] {
+    return [];
   }
 }
 

package/src/install/targets/configure.ts

@@ -1,5 +1,5 @@
 import { appConfigInstalled, displayAppConfigPath, uninstallAppConfig } from "../../config/file.ts";
-import type { CliProgram } from "../../types.ts";
+import type { CliProgram, InstallAgentIntegration } from "../../types.ts";
 import type { InstallPaths } from "../paths.ts";
 import { InstallTarget } from "../target-base.ts";
 import type {
@@ -17,6 +17,10 @@ class ConfigureInstallTarget extends InstallTarget {
   readonly actionKind = "configure" as const;
   readonly category = "core" as const;
 
+  defaultIncludedInAll(_integration: InstallAgentIntegration): boolean {
+    return false;
+  }
+
   isAvailable(root: CliProgram, _paths: InstallPaths): boolean {
     return root.appConfig !== undefined;
   }

package/src/install/targets/index.ts

@@ -6,7 +6,6 @@ import { claudeDesktopMcpTarget } from "./claude-desktop-mcp.ts";
 import { claudeSkillTarget } from "./claude-skill.ts";
 import { codexMcpTarget } from "./codex-mcp.ts";
 import { codexSkillTarget } from "./codex-skill.ts";
-import { completionsTarget } from "./completions.ts";
 import { configureTarget } from "./configure.ts";
 import { cursorMcpTarget } from "./cursor-mcp.ts";
 import { cursorSkillTarget } from "./cursor-skill.ts";
@@ -18,7 +17,6 @@ import { opencodeSkillTarget } from "./opencode-skill.ts";
 /** Ordered install targets (plan iteration order). */
 export const INSTALL_TARGETS: InstallTarget[] = [
   appTarget,
-  completionsTarget,
   cursorSkillTarget,
   claudeSkillTarget,
   codexSkillTarget,
@@ -42,7 +40,6 @@ export {
   claudeSkillTarget,
   codexMcpTarget,
   codexSkillTarget,
-  completionsTarget,
   configureTarget,
   cursorMcpTarget,
   cursorSkillTarget,

package/src/install/targets.test.ts

@@ -1,11 +1,7 @@
 import { describe, expect, test } from "bun:test";
-import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
 import type { CliProgram } from "../types.ts";
-import { maybeBootstrapInstallArgv } from "./bootstrap.ts";
 import { normalizeInstallRawOpts } from "./normalize.ts";
-import { resolveInstallPaths } from "./paths.ts";
+import { normalizeUninstallRawOpts } from "./normalize-uninstall.ts";
 import { resolveAgentIntegration, resolveEffectiveInstallTargets } from "./target-effective.ts";
 import { isArtifactInScope } from "./target-scope.ts";
 
@@ -15,7 +11,7 @@ describe("normalizeInstallRawOpts", () => {
   });
 
   test("bare uninstall sets all", () => {
-    expect(normalizeInstallRawOpts({ uninstall: "1" })).toEqual({
+    expect(normalizeUninstallRawOpts({})).toEqual({
       uninstall: "1",
       all: "1",
     });
@@ -37,11 +33,10 @@ describe("resolveAgentIntegration", () => {
 });
 
 describe("resolveEffectiveInstallTargets", () => {
-  test("defaults app completions configure includedInAll", () => {
+  test("defaults app and configure not in --all", () => {
     const t = resolveEffectiveInstallTargets(undefined);
-    expect(t.app.includedInAll).toBe(true);
-    expect(t.completions.includedInAll).toBe(true);
-    expect(t.configure.includedInAll).toBe(true);
+    expect(t.app.includedInAll).toBe(false);
+    expect(t.configure.includedInAll).toBe(false);
   });
 
   test("skill mode includes skills in --all not MCP pairs", () => {
@@ -99,38 +94,25 @@ describe("resolveEffectiveInstallTargets", () => {
       ),
     ).toBe(true);
   });
-});
-
-describe("maybeBootstrapInstallArgv", () => {
-  const program: CliProgram = {
-    key: "bootapp",
-    version: "1.0.0",
-    description: "Boot",
-    handler: () => {},
-  };
-
-  test("rewrites empty argv when app missing and TTY", () => {
-    const prev = process.stdin.isTTY;
-    Object.defineProperty(process.stdin, "isTTY", { value: true, configurable: true });
-    try {
-      expect(maybeBootstrapInstallArgv([], program)).toEqual(["install"]);
-    } finally {
-      Object.defineProperty(process.stdin, "isTTY", { value: prev, configurable: true });
-    }
-  });
 
-  test("does not rewrite when app exists", () => {
-    const home = mkdtempSync(join(tmpdir(), "boot-"));
-    const prevHome = process.env.HOME;
-    process.env.HOME = home;
-    const paths = resolveInstallPaths(program);
-    try {
-      mkdirSync(paths.appDir, { recursive: true });
-      writeFileSync(paths.appPath, "x", "utf8");
-      expect(maybeBootstrapInstallArgv([], program)).toEqual([]);
-    } finally {
-      process.env.HOME = prevHome;
-      rmSync(home, { recursive: true, force: true });
-    }
+  test("scoped --mcp --skill --configure includes skill and mcp not only configure", () => {
+    const program: CliProgram = {
+      key: "app",
+      version: "1",
+      description: "x",
+      mcpServer: { enabled: true },
+      install: { agentIntegration: "both" },
+      handler: () => {},
+    };
+    const effective = resolveEffectiveInstallTargets(program.install, program);
+    const scope = { mcp: true, skill: true, configure: true };
+    expect(isArtifactInScope("cursorSkill", scope, effective, "install-scoped", program)).toBe(
+      true,
+    );
+    expect(isArtifactInScope("cursorMcp", scope, effective, "install-scoped", program)).toBe(true);
+    expect(isArtifactInScope("configure", scope, effective, "install-scoped", program)).toBe(true);
+    expect(isArtifactInScope("claudeSkill", scope, effective, "install-scoped", program)).toBe(
+      true,
+    );
   });
 });

package/src/mcp/env.test.ts

@@ -0,0 +1,92 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { chmodSync, mkdtempSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { applyShellEnv, bootstrapMcpEnv } from "./env.ts";
+
+const TEST_VAR = "ARGS_BARG_SHELL_ENV_TEST";
+
+describe("mcp/env", () => {
+  test("applyShellEnv merges PATH and fills missing vars", () => {
+    const prevPath = process.env.PATH;
+    const prevTest = process.env[TEST_VAR];
+    delete process.env[TEST_VAR];
+    try {
+      process.env.PATH = "/host/bin";
+      applyShellEnv({
+        PATH: "/shell/bin:/host/bin",
+        [TEST_VAR]: "from-shell",
+      });
+      expect(process.env.PATH).toBe("/shell/bin:/host/bin");
+      expect(process.env[TEST_VAR]).toBe("from-shell");
+    } finally {
+      if (prevPath === undefined) delete process.env.PATH;
+      else process.env.PATH = prevPath;
+      if (prevTest === undefined) delete process.env[TEST_VAR];
+      else process.env[TEST_VAR] = prevTest;
+    }
+  });
+
+  test("applyShellEnv does not overwrite host vars except PATH merge", () => {
+    const prev = process.env.HOME;
+    process.env.HOME = "/host/home";
+    try {
+      applyShellEnv({ HOME: "/shell/home" });
+      expect(process.env.HOME).toBe("/host/home");
+    } finally {
+      if (prev === undefined) delete process.env.HOME;
+      else process.env.HOME = prev;
+    }
+  });
+});
+
+describe("bootstrapMcpEnv", () => {
+  let fakeShell: string;
+  let prevShell: string | undefined;
+  let prevTest: string | undefined;
+
+  beforeEach(() => {
+    const dir = mkdtempSync(join(tmpdir(), "argsbarg-shell-env-"));
+    fakeShell = join(dir, "fake-shell.sh");
+    writeFileSync(
+      fakeShell,
+      `#!/bin/sh
+if [ "$1" = "-l" ] && [ "$2" = "-c" ] && [ "$3" = "env" ]; then
+  echo "${TEST_VAR}=from_fake_shell"
+fi
+`,
+    );
+    chmodSync(fakeShell, 0o755);
+    prevShell = process.env.SHELL;
+    prevTest = process.env[TEST_VAR];
+    delete process.env[TEST_VAR];
+    process.env.SHELL = fakeShell;
+  });
+
+  afterEach(() => {
+    if (prevShell === undefined) delete process.env.SHELL;
+    else process.env.SHELL = prevShell;
+    if (prevTest === undefined) delete process.env[TEST_VAR];
+    else process.env[TEST_VAR] = prevTest;
+  });
+
+  test("defaults on when shellEnv is undefined", () => {
+    bootstrapMcpEnv({});
+    expect(process.env[TEST_VAR]).toBe("from_fake_shell");
+  });
+
+  test("runs when shellEnv is true", () => {
+    bootstrapMcpEnv({ shellEnv: true });
+    expect(process.env[TEST_VAR]).toBe("from_fake_shell");
+  });
+
+  test("uses explicit shell path when shellEnv is a string", () => {
+    bootstrapMcpEnv({ shellEnv: fakeShell });
+    expect(process.env[TEST_VAR]).toBe("from_fake_shell");
+  });
+
+  test("skips capture when shellEnv is false", () => {
+    bootstrapMcpEnv({ shellEnv: false });
+    expect(process.env[TEST_VAR]).toBeUndefined();
+  });
+});

package/src/mcp/env.ts

@@ -39,21 +39,22 @@ export function applyShellEnv(env: Record<string, string>): void {
   }
 }
 
-/** Applies mcpServer shellEnv bootstrap. */
+/** Applies mcpServer shellEnv bootstrap (default on; opt out with `shellEnv: false`). */
 export function bootstrapMcpEnv(config: { shellEnv?: boolean | string }): void {
+  if (config.shellEnv === false) {
+    return;
+  }
   const shellEnvCfg = config.shellEnv;
-  if (shellEnvCfg) {
-    const shell =
-      typeof shellEnvCfg === "string"
-        ? shellEnvCfg
-        : (process.env.SHELL ?? (process.platform === "darwin" ? "/bin/zsh" : "/bin/bash"));
-    const captured = captureShellEnv(shell);
-    if (Object.keys(captured).length === 0) {
-      process.stderr.write(
-        `[argsbarg] shellEnv: failed to capture shell environment from ${shell}\n`,
-      );
-    } else {
-      applyShellEnv(captured);
-    }
+  const shell =
+    typeof shellEnvCfg === "string"
+      ? shellEnvCfg
+      : (process.env.SHELL ?? (process.platform === "darwin" ? "/bin/zsh" : "/bin/bash"));
+  const captured = captureShellEnv(shell);
+  if (Object.keys(captured).length === 0) {
+    process.stderr.write(
+      `[argsbarg] shellEnv: failed to capture shell environment from ${shell}\n`,
+    );
+  } else {
+    applyShellEnv(captured);
   }
 }

package/src/parse.test.ts

@@ -495,7 +495,7 @@ test("leaf completion help prints correctly", async () => {
   const out = stdout.toString();
   expect(exitCode).toBe(0);
   expect(out).toContain("Show help for this command.");
-  expect(out).toContain("Manual install:");
+  expect(out).toContain("Homebrew");
   expect(stderr.toString()).toBe("");
 });
 
@@ -529,6 +529,7 @@ test("docs schema exports JSON for leaf roots", async () => {
     "completion",
     "version",
     "install",
+    "uninstall",
     "docs",
   ]);
 });
@@ -614,7 +615,7 @@ test("cliSchemaExport resolves program key in install notes", () => {
 
   const json = cliSchemaJson(root);
   expect(json).not.toContain("{argsbarg:program}");
-  expect(json).toContain("myapp install --yes");
+  expect(json).toContain("brew install");
 });
 
 test("cliSchemaExport resolves {argsbarg:program} in consumer notes", () => {

package/src/prompt.ts

@@ -0,0 +1,10 @@
+/** Shared terminal prompt helpers. */
+
+import { readSync } from "node:fs";
+
+/** Read one line from stdin (no masking). */
+export function readPromptLine(): string {
+  const buf = Buffer.alloc(4096);
+  const n = readSync(0, buf, { length: 4096 });
+  return buf.toString("utf8", 0, n).replace(/\r?\n$/, "");
+}

package/src/schema.ts

@@ -13,7 +13,15 @@ import {
   leafOutputSchema,
 } from "./types.ts";
 
-const RESERVED = new Set(["completion", "install", "docs", "mcp", "version", "config"]);
+const RESERVED = new Set([
+  "completion",
+  "install",
+  "uninstall",
+  "docs",
+  "mcp",
+  "version",
+  "config",
+]);
 
 function exportCommand(cmd: CliNode, root: CliProgram): CliSchemaExport | null {
   if (cmd.hidden) {

package/src/types.ts

@@ -202,6 +202,26 @@ export interface CliUpdateArtifact {
 /** Fetches the latest release binary for `install --update`. */
 export type CliUpdateGetLatest = (ctx: { version: string }) => Promise<CliUpdateArtifact>;
 
+/** Context passed to {@link CliAppConfigEntry.resolve} for one config key. */
+export interface CliAppConfigResolveContext {
+  /** Schema key being resolved. */
+  key: string;
+  /** Entry metadata for this key. */
+  entry: CliAppConfigEntry;
+  /** Program root (read-only). */
+  program: CliProgram;
+  /** Raw value from the config file, if any. */
+  fileValue: unknown;
+  /** Non-empty host env string when `entry.env` is set; otherwise `undefined`. */
+  envValue: string | undefined;
+}
+
+/**
+ * Optional fallback resolver for one config key (e.g. `gh auth token` when `GH_TOKEN` is unset).
+ * Return `undefined` to continue resolution (env, then default).
+ */
+export type CliAppConfigResolveFn = (ctx: CliAppConfigResolveContext) => unknown;
+
 /**
  * Metadata overlay for one key in {@link CliAppConfig.entries}.
  * Types and validation come from {@link CliAppConfig.jsonSchema} when set; otherwise all values are strings.
@@ -222,6 +242,11 @@ export interface CliAppConfigEntry {
   sensitive?: boolean;
   /** When set: non-empty `process.env[env]` overrides file; value exported after resolve. */
   env?: string;
+  /**
+   * Optional fallback after file when env is empty.
+   * Return `undefined` to fall back to `env` (if set) and schema defaults.
+   */
+  resolve?: CliAppConfigResolveFn;
 }
 
 /**
@@ -248,11 +273,6 @@ export interface CliInstallConfig {
   agentIntegration?: InstallAgentIntegration;
   /** Per-artifact gates for full install/uninstall. See {@link resolveEffectiveInstallTargets}. */
   targets?: CliInstallTargets;
-  /**
-   * When set, enables `install --update` on the program root.
-   * Should download or locate the latest release binary and return its path.
-   */
-  updateGetLatest?: CliUpdateGetLatest;
 }
 
 /** Agent integration mode for install — MCP vs shell skill per host. */
@@ -275,7 +295,7 @@ export interface ResolvedInstallTarget {
 
 /** Per-artifact gates for full install/uninstall. See {@link resolveEffectiveInstallTargets}. */
 export interface CliInstallTargets {
-  /** Copy app to `~/.local/bin/<key>`. Default includedInAll true (opt-out). */
+  /** App binary status only (Homebrew PATH); no self-install. */
   app?: InstallTargetSpec;
   /** ChatGPT desktop MCP. Default false. */
   chatgptMcp?: InstallTargetSpec;
@@ -289,9 +309,7 @@ export interface CliInstallTargets {
   codexMcp?: InstallTargetSpec;
   /** Codex skill. Default false. */
   codexSkill?: InstallTargetSpec;
-  /** Shell completions for detected shells. Default includedInAll true (opt-out). */
-  completions?: InstallTargetSpec;
-  /** App config: wizard on install, file removal on uninstall. Default includedInAll true. */
+  /** App config: wizard via install --configure only. Default not in --all. */
   configure?: InstallTargetSpec;
   /** Cursor MCP. Default false. */
   cursorMcp?: InstallTargetSpec;

package/src/validate.ts

@@ -81,6 +81,11 @@ function validateConfigBlock(appConfigBlock: import("./types.ts").CliAppConfig):
       }
       envNames.add(entry.env);
     }
+    if (entry.resolve !== undefined && typeof entry.resolve !== "function") {
+      throw new CliSchemaValidationError(
+        `program.appConfig.entries['${key}'].resolve must be a function when set`,
+      );
+    }
   }
 
   const jsonSchema = appConfigBlock.jsonSchema;
@@ -197,17 +202,6 @@ export function cliValidateProgram(program: CliProgram): void {
     validateConfigBlock(program.appConfig);
   }
 
-  if (program.install?.updateGetLatest !== undefined) {
-    if (program.install.enabled === false) {
-      throw new CliSchemaValidationError(
-        "install.updateGetLatest requires install to be enabled (omit install.enabled: false)",
-      );
-    }
-    if (typeof program.install.updateGetLatest !== "function") {
-      throw new CliSchemaValidationError("install.updateGetLatest must be a function");
-    }
-  }
-
   if (program.install !== undefined) {
     validateInstallConfig(program);
   }

package/docs/templates/cursor/rules/cli-program.mdc

@@ -1,31 +0,0 @@
----
-description: Argsbarg schema — read framework docs before editing CLI commands
-globs: "src/**/commands/**/*.{ts,tsx},src/index.{ts,tsx}"
-alwaysApply: false
----
-
-When adding or changing argsbarg schema, leaf handlers, or MCP exposure:
-
-1. **Read** `node_modules/argsbarg/docs/cli-program.md` (required — authoritative guide).
-2. MCP tools, varargs, `inputSchema` → also `node_modules/argsbarg/docs/mcp.md`.
-3. JSON stdout / `outputSchema` guide and codegen → `node_modules/argsbarg/docs/output-schema.md`.
-4. App config / `program.appConfig` guide and codegen → `node_modules/argsbarg/docs/config-schema.md`.
-5. `install`, `install.targets`, completions, skills → `node_modules/argsbarg/docs/install.md`.
-6. Bundled `docs` built-in → `node_modules/argsbarg/docs/bundled-docs.md`.
-7. **Examples** (shipped under `node_modules/argsbarg/examples/`):
-   - Concepts / minimal config → `examples/config-app/`
-   - **Copy template** (all builtins, schemagen, `outputSchema`) → `examples/consumer-app/`
-
-**Hard rules** (details and examples are in the docs above — do not contradict them):
-
-- Reserved root commands: `completion`, `install`, `mcp`, `version`, `docs`, `update`, `config`.
-- `satisfies CliProgram` / `CliLeaf`; action-oriented `description` on root, commands, options, and positionals.
-- Omit `mcpTool` unless genuinely CLI-only (`enabled: false`) or an irreducible wire limit — fix schema and headless handlers first.
-- Interactive leaves: one headless path for MCP, non-TTY CLI, and `--yes` / `--dry-run` / `--json` (`shouldRunHeadless*`, `requireYesInNonTty`); not raw `isTTY`.
-- String options: `format` / `default` / `pattern` per `cli-program.md`; `readLeafInputs()` for multi-flag leaves.
-- Varargs (`argMax: 0`): CLI space-separated; MCP JSON array only — no comma-splitting positionals.
-- Multi-surface leaves (Ink + headless + MCP): one **`read*Flags(ctx)`** per command (or shared family helper + extensions); one **`resolve*Input(flags)`** for cross-field rules — handler reads ctx once, all paths share the struct.
-- JSON stdout: `outputSchema` on the leaf from generated constants in `outputSchemas.ts` — see `output-schema.md`; mark roots with **`JSON payload`** JSDoc in `src/**/types.ts`; do not hand-edit `src/schemas/generated/` or `outputSchemas.ts`.
-- App config: `program.appConfig.jsonSchema` from generated `configSchemas.ts` — see `config-schema.md`; mark roots with **`Config schema`** JSDoc; prefer the layout in `node_modules/argsbarg/examples/consumer-app/` when adding new schema roots.
-
-**App-specific conventions:** replace this line with a `**<your-app> conventions:**` section (bullets only). Keep it at the bottom of this file — `just consumer-dev` / `just consumers-sync` in the argsbarg repo refresh the template above and preserve this block. Do not duplicate `cli-program.md` here; link paths and patterns only. For a second rule file (e.g. `.cursor/argsbarg.mdc`), that is fine too.

package/examples/config-app/main.ts

@@ -1,20 +0,0 @@
-#!/usr/bin/env bun
-/*
-Multi-file consumer example for program.appConfig.
-
-Files:
-  types.ts   — AppConfig interface (Config schema JSDoc marker for schemagen)
-  schema.ts  — APP_CONFIG_JSON_SCHEMA (inline; production apps generate this)
-  program.ts — CliProgram with appConfig block and commands using ctx.appConfig
-
-Try:
-  CONFIG_APP_API_TOKEN=dev bun ./examples/config-app/main.ts show --json
-  CONFIG_APP_API_TOKEN=dev bun ./examples/config-app/main.ts config get
-  CONFIG_APP_API_TOKEN=dev bun ./examples/config-app/main.ts ping
-*/
-
-import { Cli } from "../../src/index.ts";
-import { program } from "./program.ts";
-
-const cli = new Cli(program);
-await cli.run();