argsbarg 5.1.7 → 5.1.9

package/src/builtins/presentation.ts

@@ -64,9 +64,7 @@ export function cliPresentationRoot(program: CliProgram): CliRouter {
     };
   }
 
-  const userCommands = program.commands
-    .map((ch) => presentationNode(ch))
-    .filter((ch): ch is CliNode => ch !== null);
+  const userCommands = program.commands.map((ch) => presentationNode(ch)).filter((ch): ch is CliNode => ch !== null);
 
   return {
     key: program.key,
@@ -80,10 +78,7 @@ export function cliPresentationRoot(program: CliProgram): CliRouter {
 }
 
 /** Root help notes: consumer `program.notes` plus agent discovery when `docs` is enabled. */
-export function presentationRootNotes(
-  program: CliProgram,
-  caps: CliCapabilities,
-): string | undefined {
+export function presentationRootNotes(program: CliProgram, caps: CliCapabilities): string | undefined {
   const parts: string[] = [];
   if ((program.notes ?? "").trim().length > 0) {
     parts.push((program.notes ?? "").trim());

package/src/builtins/registry.ts

@@ -8,11 +8,7 @@ import { cliBuiltinVersionCommand } from "./version.ts";
 
 type BuiltinFactory = (program: CliProgram) => CliNode | null;
 
-function pushBuiltin(
-  builtins: CliNode[],
-  program: CliProgram,
-  factory: BuiltinFactory | null,
-): void {
+function pushBuiltin(builtins: CliNode[], program: CliProgram, factory: BuiltinFactory | null): void {
   if (!factory) {
     return;
   }

package/src/cli-tool/create.test.ts

@@ -52,13 +52,10 @@ describe("argsbarg create", () => {
 
   /** ResolveCreateOptions derives identity defaults from key. */
   test("resolveCreateOptions derives identity defaults from key", () => {
-    expect(resolveCreateOptions({ key: "1password", releaseRepo: "org/1password" }).className).toBe(
-      "App1password",
+    expect(resolveCreateOptions({ key: "1password", releaseRepo: "org/1password" }).className).toBe("App1password");
+    expect(resolveCreateOptions({ key: "my-cli", className: "Custom", releaseRepo: "org/my-cli" }).className).toBe(
+      "Custom",
     );
-    expect(
-      resolveCreateOptions({ key: "my-cli", className: "Custom", releaseRepo: "org/my-cli" })
-        .className,
-    ).toBe("Custom");
     const opts = resolveCreateOptions({ key: "at1", releaseRepo: "bdombro/at1" });
     expect(opts.tap).toBe("bdombro/at1");
     expect(opts.releaseRepo).toBe("bdombro/at1");

package/src/cli-tool/create.ts

@@ -70,9 +70,7 @@ function tapLibraryParts(tap: string): { org: string; repo: string } {
 }
 
 /** Parse `scripts/create-identity.ts` for inference and template defaults. */
-export function parseCreateIdentityFile(
-  path: string,
-): Partial<CreateOptions> & { envPrefix?: string } {
+export function parseCreateIdentityFile(path: string): Partial<CreateOptions> & { envPrefix?: string } {
   if (!existsSync(path)) return {};
   const text = readFileSync(path, "utf8");
   const pick = (field: string) => text.match(new RegExp(`${field}:\\s*"([^"]*)"`))?.[1];
@@ -109,18 +107,8 @@ export function templateIdentity(): {
   };
 }
 
-export function inferCreateOptions(
-  baseDir: string,
-  partial: Partial<CreateOptions>,
-): Partial<CreateOptions> {
-  if (
-    partial.key &&
-    partial.className &&
-    partial.homepage &&
-    partial.releaseRepo &&
-    partial.desc &&
-    partial.tap
-  ) {
+export function inferCreateOptions(baseDir: string, partial: Partial<CreateOptions>): Partial<CreateOptions> {
+  if (partial.key && partial.className && partial.homepage && partial.releaseRepo && partial.desc && partial.tap) {
     return partial;
   }
   const fromIdentity = parseCreateIdentityFile(join(baseDir, CREATE_IDENTITY_REL));
@@ -146,19 +134,14 @@ function assertReleaseRepoFormat(releaseRepo: string): void {
   }
 }
 
-export function resolveCreateOptions(
-  partial: Partial<CreateOptions>,
-  baseDir?: string,
-): CreateOptions {
+export function resolveCreateOptions(partial: Partial<CreateOptions>, baseDir?: string): CreateOptions {
   const merged = baseDir ? inferCreateOptions(baseDir, partial) : partial;
   const tmpl = templateIdentity();
   const key = merged.key ?? tmpl.key ?? "full-example";
   const className = merged.className ?? classNameFromKey(key);
   const releaseRepo = merged.releaseRepo;
   if (!releaseRepo) {
-    throw new Error(
-      "GitHub release repo (org/repo) is required. Pass --release-repo or use the interactive wizard.",
-    );
+    throw new Error("GitHub release repo (org/repo) is required. Pass --release-repo or use the interactive wizard.");
   }
   assertReleaseRepoFormat(releaseRepo);
   const devTemplate = merged.devTemplate ?? (baseDir ? isDevTemplateDir(baseDir) : false);

package/src/cli-tool/post-create.ts

@@ -69,9 +69,7 @@ export async function runPostCreate(targetDir: string, dryRun: boolean): Promise
       run: () => {
         if (dryRun) return;
         if (shouldSkipGitBootstrap(abs)) {
-          process.stderr.write(
-            "Skipping git bootstrap (existing repo or nested in git work tree).\n",
-          );
+          process.stderr.write("Skipping git bootstrap (existing repo or nested in git work tree).\n");
           return;
         }
         let proc = Bun.spawnSync(["git", "init"], {

package/src/cli-tool/program.ts

@@ -40,8 +40,7 @@ export const program = {
         },
         {
           name: "desc",
-          description:
-            "App + formula description (default: <ClassName> CLI; stored in create-identity.ts).",
+          description: "App + formula description (default: <ClassName> CLI; stored in create-identity.ts).",
           kind: CliOptionKind.String,
         },
         { name: "force", description: "Overwrite existing files.", kind: CliOptionKind.Presence },

package/src/cli-tool/run-create.ts

@@ -39,9 +39,7 @@ function collectInteractiveOptions(
   );
 
   process.stderr.write(`\nTarget: ${baseDir}\n`);
-  process.stderr.write(
-    `Key: ${opts.key}  Class: ${opts.className}  Tap: ${opts.tap}  Release: ${opts.releaseRepo}\n`,
-  );
+  process.stderr.write(`Key: ${opts.key}  Class: ${opts.className}  Tap: ${opts.tap}  Release: ${opts.releaseRepo}\n`);
   process.stderr.write(`Homepage: ${opts.homepage}\n\n`);
   const tree = renderCreateTree(opts);
   process.stderr.write(`Files (${tree.size}):\n`);
@@ -101,11 +99,7 @@ export async function runCreate(input: Partial<CreateOptions> & { dir?: string }
   }
 }
 
-async function runCreateApply(
-  baseDir: string,
-  opts: CreateOptions,
-  dryRun: boolean,
-): Promise<number> {
+async function runCreateApply(baseDir: string, opts: CreateOptions, dryRun: boolean): Promise<number> {
   if (dryRun) {
     const written = applyCreate(baseDir, { ...opts, dryRun: true, check: false });
     process.stdout.write(`Would write ${written.length} file(s) under ${baseDir}\n`);

package/src/cli.ts

@@ -11,12 +11,9 @@ import {
   resolveCapabilities,
   skipsRequiredAppConfigExit,
 } from "./capabilities.ts";
-import {
-  bootstrapAppConfig,
-  type EnsureAppConfigOpts,
-  ensureAppConfig,
-} from "./config/bootstrap.ts";
+import { bootstrapAppConfig, type EnsureAppConfigOpts, ensureAppConfig } from "./config/bootstrap.ts";
 import { type AnyAppConfigSnapshot, createAppConfigSnapshot } from "./config/context.ts";
+import { readAppConfigFileRaw, resolveAppConfigPath } from "./config/file.ts";
 import { effectiveJsonSchema } from "./config/schema.ts";
 import { CliContext } from "./context.ts";
 import { cliHelpRender } from "./help.ts";
@@ -124,15 +121,7 @@ export class Cli {
       exitOnMissing: !skipRequiredConfig,
     });
 
-    const ctx = new CliContext(
-      this.program.key,
-      pr.path,
-      pr.args,
-      pr.opts,
-      this.program,
-      "cli",
-      snapshot,
-    );
+    const ctx = new CliContext(this.program.key, pr.path, pr.args, pr.opts, this.program, "cli", snapshot);
     try {
       await Promise.resolve(leaf.handler(ctx));
       process.exit(0);
@@ -171,15 +160,7 @@ export class Cli {
       exitOnMissing: false,
     });
 
-    const ctx = new CliContext(
-      this.program.key,
-      pr.path,
-      pr.args,
-      pr.opts,
-      this.program,
-      "mcp",
-      snapshot,
-    );
+    const ctx = new CliContext(this.program.key, pr.path, pr.args, pr.opts, this.program, "mcp", snapshot);
 
     let stdout = "";
     let stderr = "";
@@ -293,9 +274,7 @@ export class Cli {
   ): PreparedDispatch | { error: ParseResult } {
     const program = this.program;
     let parseRoot: CliNode;
-    let completionParseRoot: CliRouter = opts?.presentationFallback
-      ? this.presentationRoot
-      : this.parseRootMerged;
+    let completionParseRoot: CliRouter = opts?.presentationFallback ? this.presentationRoot : this.parseRootMerged;
     let isLeafCompletionIntercept = false;
 
     if (isCliLeaf(program)) {
@@ -387,7 +366,7 @@ export class Cli {
     const bootstrap = ensureAppConfig(this.program, opts);
     const snapshot = bootstrap
       ? createAppConfigSnapshot(this.program, bootstrap.fileData, bootstrap.resolved)
-      : createAppConfigSnapshot(this.program, {}, {});
+      : createAppConfigSnapshot(this.program, readAppConfigFileRaw(resolveAppConfigPath(this.program)), {});
     this._appConfig = snapshot;
     return snapshot;
   }

package/src/config/bindings.test.ts

@@ -0,0 +1,72 @@
+/*
+Tests for config/bindings module.
+*/
+
+import { describe, expect, test } from "bun:test";
+import type { CliAppConfigEntry } from "../types.ts";
+import {
+  bindingForKey,
+  CONFIG_BINDINGS_KEY,
+  clearBinding,
+  clearFileValue,
+  isKeyAddressed,
+  readBindings,
+  setBinding,
+} from "./bindings.ts";
+
+const optionalEntry: CliAppConfigEntry = { description: "Optional.", required: false };
+const requiredEntry: CliAppConfigEntry = { description: "Required.", env: "API_TOKEN" };
+
+describe("config/bindings", () => {
+  test("readBindings returns empty when absent", () => {
+    expect(readBindings({})).toEqual({});
+  });
+
+  test("setBinding and readBindings round-trip", () => {
+    const next = setBinding({}, "apiToken", "env");
+    expect(readBindings(next)).toEqual({ apiToken: "env" });
+    expect(next[CONFIG_BINDINGS_KEY]).toEqual({ apiToken: "env" });
+  });
+
+  test("clearBinding removes entry", () => {
+    const withBinding = setBinding({}, "apiToken", "env");
+    const cleared = clearBinding(withBinding, "apiToken");
+    expect(readBindings(cleared)).toEqual({});
+    expect(CONFIG_BINDINGS_KEY in cleared).toBe(false);
+  });
+
+  test("clearFileValue removes literal", () => {
+    expect(clearFileValue({ apiToken: "x" }, "apiToken")).toEqual({});
+  });
+
+  test("isKeyAddressed with binding env", () => {
+    const data = setBinding({}, "apiToken", "env");
+    expect(isKeyAddressed("apiToken", data, requiredEntry)).toBe(true);
+  });
+
+  test("isKeyAddressed with literal file value", () => {
+    expect(isKeyAddressed("apiToken", { apiToken: "tok" }, requiredEntry)).toBe(true);
+  });
+
+  test("isKeyAddressed false when unaddressed", () => {
+    expect(isKeyAddressed("apiToken", {}, requiredEntry)).toBe(false);
+  });
+
+  test("isKeyAddressed skip binding", () => {
+    const data = setBinding({}, "note", "skip");
+    expect(isKeyAddressed("note", data, optionalEntry)).toBe(true);
+  });
+
+  test("bindingForKey prefers explicit binding", () => {
+    const data = setBinding({}, "apiToken", "env");
+    expect(bindingForKey("apiToken", data, true)).toBe("env");
+  });
+
+  test("bindingForKey infers file from literal", () => {
+    expect(bindingForKey("apiToken", { apiToken: "x" }, true)).toBe("file");
+  });
+
+  test("bindingForKey missing when unset", () => {
+    expect(bindingForKey("apiToken", {}, false)).toBe("missing");
+  });
+});

package/src/config/bindings.ts

@@ -0,0 +1,115 @@
+/*
+Per-key config binding metadata (`_bindings`) — records how each schema key is satisfied.
+*/
+
+import type { CliAppConfigEntry } from "../types.ts";
+
+/** Reserved top-level config file key for per-entry binding metadata. */
+export const CONFIG_BINDINGS_KEY = "_bindings";
+
+export type ConfigBinding = "env" | "file" | "skip";
+
+const BINDING_VALUES = new Set<string>(["env", "file", "skip"]);
+
+/** True for argsbarg-reserved top-level keys (e.g. `_bindings`). */
+export function isFrameworkConfigKey(key: string): boolean {
+  return key.startsWith("_");
+}
+
+function isPresent(value: unknown): boolean {
+  if (value === undefined || value === null) return false;
+  if (typeof value === "string" && value.length === 0) return false;
+  return true;
+}
+
+/** Read `_bindings` from raw file data; returns `{}` when absent or invalid. */
+export function readBindings(fileData: Record<string, unknown>): Record<string, ConfigBinding> {
+  const raw = fileData[CONFIG_BINDINGS_KEY];
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+    return {};
+  }
+  const out: Record<string, ConfigBinding> = {};
+  for (const [key, val] of Object.entries(raw)) {
+    if (typeof val === "string" && BINDING_VALUES.has(val)) {
+      out[key] = val as ConfigBinding;
+    }
+  }
+  return out;
+}
+
+/** Validate `_bindings` shape when present. */
+export function validateBindingsShape(fileData: Record<string, unknown>, pathPrefix = "$"): string[] {
+  const raw = fileData[CONFIG_BINDINGS_KEY];
+  if (raw === undefined) return [];
+  const errors: string[] = [];
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+    errors.push(`${pathPrefix}.${CONFIG_BINDINGS_KEY}: must be object`);
+    return errors;
+  }
+  for (const [key, val] of Object.entries(raw)) {
+    if (typeof val !== "string" || !BINDING_VALUES.has(val)) {
+      errors.push(`${pathPrefix}.${CONFIG_BINDINGS_KEY}.${key}: must be "env", "file", or "skip"`);
+    }
+  }
+  return errors;
+}
+
+/** Return a new file object with an updated binding for `key`. */
+export function setBinding(
+  fileData: Record<string, unknown>,
+  key: string,
+  binding: ConfigBinding,
+): Record<string, unknown> {
+  const bindings = { ...readBindings(fileData), [key]: binding };
+  return { ...fileData, [CONFIG_BINDINGS_KEY]: bindings };
+}
+
+/** Return a new file object without a binding for `key`. */
+export function clearBinding(fileData: Record<string, unknown>, key: string): Record<string, unknown> {
+  const bindings = readBindings(fileData);
+  if (!(key in bindings)) {
+    return fileData;
+  }
+  const nextBindings = { ...bindings };
+  delete nextBindings[key];
+  const next = { ...fileData };
+  if (Object.keys(nextBindings).length === 0) {
+    delete next[CONFIG_BINDINGS_KEY];
+  } else {
+    next[CONFIG_BINDINGS_KEY] = nextBindings;
+  }
+  return next;
+}
+
+/** Remove a literal value from file data (used when binding to env). */
+export function clearFileValue(fileData: Record<string, unknown>, key: string): Record<string, unknown> {
+  if (!(key in fileData)) {
+    return fileData;
+  }
+  const next = { ...fileData };
+  delete next[key];
+  return next;
+}
+
+/** Whether the user already addressed this key (skip wizard re-prompt). */
+export function isKeyAddressed(key: string, fileData: Record<string, unknown>, _entry: CliAppConfigEntry): boolean {
+  const bindings = readBindings(fileData);
+  if (bindings[key] === "skip" || bindings[key] === "env" || bindings[key] === "file") {
+    return true;
+  }
+  return isPresent(fileData[key]);
+}
+
+/** Binding for status display; `missing` when unset. */
+export function bindingForKey(
+  key: string,
+  fileData: Record<string, unknown>,
+  resolvedPresent: boolean,
+): ConfigBinding | "missing" {
+  const bindings = readBindings(fileData);
+  const b = bindings[key];
+  if (b) return b;
+  if (isPresent(fileData[key])) return "file";
+  if (resolvedPresent) return "env";
+  return "missing";
+}

package/src/config/bootstrap.ts

@@ -6,14 +6,10 @@ settings are present before the CLI or MCP server handles a request.
 import { readSync } from "node:fs";
 import { readPromptLine as readStdinLine } from "../prompt.ts";
 import type { CliAppConfigEntry, CliProgram } from "../types.ts";
+import { bindingForKey, clearFileValue, isKeyAddressed, readBindings, setBinding } from "./bindings.ts";
+import { configEntryRequired, configEntrySensitive, defaultConfigEntryTitle, jsonSchemaRequiredKeys } from "./entry.ts";
 import {
-  configEntryRequired,
-  configEntrySensitive,
-  defaultConfigEntryTitle,
-  jsonSchemaRequiredKeys,
-} from "./entry.ts";
-import {
-  appConfigInstalled,
+  appConfigFileExists,
   displayAppConfigPath,
   readAppConfigFile,
   readAppConfigFileRaw,
@@ -53,13 +49,8 @@ export interface ConfigBootstrapResult {
 }
 
 /** Read the config file, merge env overrides, and export mapped values into `process.env`. */
-export function bootstrapAppConfig(
-  program: CliProgram,
-  opts: { validateFile: boolean },
-): ConfigBootstrapResult {
-  const fileData = opts.validateFile
-    ? readAppConfigFile(program)
-    : readAppConfigFileRaw(resolveAppConfigPath(program));
+export function bootstrapAppConfig(program: CliProgram, opts: { validateFile: boolean }): ConfigBootstrapResult {
+  const fileData = opts.validateFile ? readAppConfigFile(program) : readAppConfigFileRaw(resolveAppConfigPath(program));
   const hostEnv = captureMappedHostEnv(program);
   const resolved = resolveAppConfig(program, fileData, hostEnv);
   exportConfigToEnv(program, resolved, hostEnv);
@@ -88,7 +79,6 @@ function readSensitiveLine(): string {
       }
       const byte = buf[0];
       if (byte === 3) {
-        // Raw mode delivers Ctrl+C as ETX instead of SIGINT.
         process.stderr.write("\n");
         process.exit(130);
       }
@@ -130,10 +120,7 @@ function readPromptLine(mask: boolean): string {
 }
 
 /** Whether this setting already has a non-empty value in the user's shell environment. */
-function resolvedFromEnv(
-  entry: CliAppConfigEntry,
-  hostEnv: Record<string, string | undefined>,
-): boolean {
+function resolvedFromEnv(entry: CliAppConfigEntry, hostEnv: Record<string, string | undefined>): boolean {
   if (!entry.env) {
     return false;
   }
@@ -165,7 +152,7 @@ function promptConfigKey(
   if (hasCurrent) {
     process.stderr.write(`  Current: ${sensitive ? "REDACTED" : stringifyConfigValue(current)}\n`);
     const acceptPrompt = resolvedFromEnv(entry, hostEnv)
-      ? `  Value (Enter to copy from env)${valueHintSuffix}: `
+      ? `  Value (Enter to use env)${valueHintSuffix}: `
       : `  Value (Enter to keep)${valueHintSuffix}: `;
     process.stderr.write(acceptPrompt);
   } else {
@@ -202,6 +189,16 @@ function shouldShowConfigureSetupHeading(program: CliProgram): boolean {
   return Object.keys(program.appConfig.entries).length > 0;
 }
 
+function isPresent(value: unknown): boolean {
+  if (value === undefined || value === null) return false;
+  if (typeof value === "string" && value.length === 0) return false;
+  return true;
+}
+
+function bindingsDiffer(a: Record<string, unknown>, b: Record<string, unknown>): boolean {
+  return JSON.stringify(readBindings(a)) !== JSON.stringify(readBindings(b));
+}
+
 /** Ask the user for each required setting that is still empty; returns updates to save to the config file. */
 function promptMissingRequired(program: CliProgram): Record<string, unknown> {
   const appConfig = program.appConfig;
@@ -212,31 +209,29 @@ function promptMissingRequired(program: CliProgram): Record<string, unknown> {
   const jsonSchema = effectiveJsonSchema(program);
   const fromSchema = jsonSchema ? jsonSchemaRequiredKeys(jsonSchema) : undefined;
   const hostEnv = captureMappedHostEnv(program);
-  const { resolved } = bootstrapAppConfig(program, { validateFile: false });
+  const path = resolveAppConfigPath(program);
+  const fileData = readAppConfigFileRaw(path);
+  const resolved = resolveAppConfig(program, fileData, hostEnv);
   let headingWritten = false;
   for (const [key, entry] of Object.entries(appConfig.entries)) {
     if (!configEntryRequired(key, entry, fromSchema)) {
       continue;
     }
-    const current = resolved[key];
-    if (current !== undefined && current !== null && String(current).length > 0) {
+    const bindings = readBindings(fileData);
+    if (bindings[key] === "env" && !isPresent(resolved[key])) {
+      // Re-prompt when env binding is broken.
+    } else if (isKeyAddressed(key, fileData, entry) && isPresent(resolved[key])) {
       continue;
     }
+    const current = resolved[key];
     if (!headingWritten) {
       writeConfigureSetupHeading();
       headingWritten = true;
     }
-    const { value, userTyped } = promptConfigKey(
-      key,
-      entry,
-      undefined,
-      false,
-      fromSchema,
-      hostEnv,
-      jsonSchema,
-    );
-    if (value !== undefined && String(value).length > 0) {
+    const { value, userTyped } = promptConfigKey(key, entry, current, false, fromSchema, hostEnv, jsonSchema);
+    if (userTyped && value !== undefined && String(value).length > 0) {
       updates[key] = value;
+      Object.assign(updates, setBinding(updates, key, "file"));
     }
   }
   return updates;
@@ -267,7 +262,7 @@ export function runConfigure(
   const jsonSchema = effectiveJsonSchema(program);
   const fromSchema = jsonSchema ? jsonSchemaRequiredKeys(jsonSchema) : undefined;
   const resolved = resolveAppConfig(program, existing, hostEnv);
-  const next: Record<string, unknown> = { ...existing };
+  let next: Record<string, unknown> = { ...existing };
   let changed = false;
 
   if (opts.showHeading !== false && shouldShowConfigureSetupHeading(program)) {
@@ -275,35 +270,51 @@ export function runConfigure(
   }
 
   for (const [key, entry] of Object.entries(program.appConfig.entries)) {
+    const bindings = readBindings(existing);
+    if (bindings[key] === "env" && !isPresent(resolved[key])) {
+      // Re-prompt when env binding is broken.
+    } else if (isKeyAddressed(key, existing, entry)) {
+      continue;
+    }
+
     const before = next[key];
+    const bindingsBefore = readBindings(next);
     const current = resolved[key];
-    const { value, userTyped } = promptConfigKey(
-      key,
-      entry,
-      current,
-      true,
-      fromSchema,
-      hostEnv,
-      jsonSchema,
-    );
-    if (value !== undefined && String(value).length > 0) {
+    const required = configEntryRequired(key, entry, fromSchema);
+    const { value, userTyped } = promptConfigKey(key, entry, current, true, fromSchema, hostEnv, jsonSchema);
+
+    if (userTyped && value !== undefined && String(value).length > 0) {
+      if (JSON.stringify(value) !== JSON.stringify(before) || bindingsBefore[key] !== "file") {
+        changed = true;
+      }
+      next = setBinding({ ...next, [key]: value }, key, "file");
+      continue;
+    }
+
+    if (!userTyped && isPresent(current) && resolvedFromEnv(entry, hostEnv)) {
       const storedInFile =
-        key in existing &&
-        existing[key] !== undefined &&
-        existing[key] !== null &&
-        String(existing[key]).length > 0;
-      if (!userTyped && !storedInFile) {
-        continue;
+        key in existing && existing[key] !== undefined && existing[key] !== null && String(existing[key]).length > 0;
+      if (!storedInFile) {
+        const withBinding = setBinding(clearFileValue(next, key), key, "env");
+        if (bindingsDiffer(next, withBinding) || key in next) {
+          changed = true;
+        }
+        next = withBinding;
       }
-      if (JSON.stringify(value) !== JSON.stringify(before)) {
+      continue;
+    }
+
+    if (!userTyped && !required && !isPresent(current) && inputWasSkipped(value, userTyped)) {
+      const withBinding = setBinding(next, key, "skip");
+      if (bindingsDiffer(next, withBinding)) {
         changed = true;
       }
-      next[key] = value;
+      next = withBinding;
     }
   }
 
   if (changed) {
-    writeAppConfigFile(program, next);
+    writeAppConfigFile(program, next, { partial: true });
     const updated = resolveAppConfig(program, next, hostEnv);
     exportConfigToEnv(program, updated, hostEnv);
     return { path, changed: true };
@@ -311,12 +322,16 @@ export function runConfigure(
   return { path, changed: false };
 }
 
+function inputWasSkipped(value: unknown, userTyped: boolean): boolean {
+  return !userTyped && (value === undefined || String(value).length === 0);
+}
+
 /** Summary for `configure --status`: config path, whether the file exists, and which required settings are set (never their values). */
 export function appConfigStatus(program: CliProgram):
   | {
       path: string;
       exists: boolean;
-      required: Array<{ key: string; set: boolean }>;
+      required: Array<{ key: string; set: boolean; binding?: "env" | "file" | "skip" | "missing" }>;
     }
   | undefined {
   if (!program.appConfig) {
@@ -336,19 +351,19 @@ export function appConfigStatus(program: CliProgram):
   const fromSchema = jsonSchema ? jsonSchemaRequiredKeys(jsonSchema) : undefined;
   const required = Object.entries(program.appConfig.entries)
     .filter(([key, entry]) => configEntryRequired(key, entry, fromSchema))
-    .map(([key]) => ({
-      key,
-      set:
-        resolved[key] !== undefined && resolved[key] !== null && String(resolved[key]).length > 0,
-    }));
-  return { path, exists: appConfigInstalled(program), required };
+    .map(([key]) => {
+      const set = resolved[key] !== undefined && resolved[key] !== null && String(resolved[key]).length > 0;
+      return {
+        key,
+        set,
+        binding: bindingForKey(key, fileData, set),
+      };
+    });
+  return { path, exists: appConfigFileExists(program), required };
 }
 
 /** Load config at startup, optionally prompt the user, and fail if required settings are still missing. */
-export function ensureAppConfig(
-  program: CliProgram,
-  opts: EnsureAppConfigOpts,
-): ConfigBootstrapResult | undefined {
+export function ensureAppConfig(program: CliProgram, opts: EnsureAppConfigOpts): ConfigBootstrapResult | undefined {
   if (!program.appConfig) {
     return undefined;
   }
@@ -377,7 +392,7 @@ export function ensureAppConfig(
     const updates = promptMissingRequired(program);
     if (Object.keys(updates).length > 0) {
       const merged = { ...fileData, ...updates };
-      writeAppConfigFile(program, merged);
+      writeAppConfigFile(program, merged, { partial: true });
       fileData = merged;
       resolved = resolveAppConfig(program, fileData, hostEnv);
       exportConfigToEnv(program, resolved, hostEnv);