saasaloy 0.1.2 → 0.3.0

package/dist/index.js

@@ -30,6 +30,7 @@ import { dirname as dirname3, posix as posix2 } from "path";
 var EXIT_OK = 0;
 var EXIT_FAILURE = 1;
 var EXIT_REFUSED = 2;
+var EXIT_MERGE_PENDING = 3;
 var RefusalError = class extends Error {
   name = "RefusalError";
 };
@@ -489,7 +490,7 @@ function insertChainedRoute(source, patch) {
     return source;
   }
   if (!(patch.import.name in mod.imports)) {
-    mod.imports.$add({
+    mod.imports.$prepend({
       from: patch.import.from,
       imported: patch.import.name,
       local: patch.import.name
@@ -863,6 +864,193 @@ function toDiff(before, after, filename) {
   return patch;
 }
 
+// src/lib/patch/drizzle-column.ts
+import { generateCode as generateCode2, parseModule as parseModule3 } from "magicast";
+var COLUMNS_ARG = 1;
+function insertDrizzleColumn(source, patch) {
+  const mod = parseModule3(source);
+  const columns = columnsObject(mod, patch);
+  if (!columns) {
+    return source;
+  }
+  if (indexOfColumn(columns, patch.column) !== -1) {
+    return source;
+  }
+  parseExpressionNode(patch.value);
+  if (patch.import && foreignBinding(mod.imports, patch.import)) {
+    return source;
+  }
+  const withColumn = spliceColumn(source, columns, patch);
+  if (!withColumn) {
+    return source;
+  }
+  return addImport(withColumn, patch);
+}
+function removeDrizzleColumn(source, patch) {
+  const mod = parseModule3(source);
+  const columns = columnsObject(mod, patch);
+  const at = columns ? indexOfColumn(columns, patch.column) : -1;
+  if (!columns || at === -1) {
+    return source;
+  }
+  if (valueDrift(columns, at, patch)) {
+    return source;
+  }
+  if (patch.import && removeBindingConflict2(mod.imports, patch.import)) {
+    return source;
+  }
+  const withoutColumn = cutColumn(source, columns, at);
+  if (!withoutColumn) {
+    return source;
+  }
+  return dropImport(withoutColumn, patch);
+}
+function spliceColumn(source, columns, patch) {
+  const last = columns.properties.at(-1);
+  const end = offset(last, "end");
+  if (end === void 0) {
+    return void 0;
+  }
+  const indent = indentOf(source, offset(last, "start") ?? end);
+  const comma = source.slice(end).trimStart().startsWith(",");
+  const at = comma ? end + source.slice(end).indexOf(",") + 1 : end;
+  const line = `${indent}${patch.column}: ${patch.value}`;
+  return comma ? `${source.slice(0, at)}
+${line},${source.slice(at)}` : `${source.slice(0, at)},
+${line}${source.slice(at)}`;
+}
+function cutColumn(source, columns, at) {
+  const property = columns.properties[at];
+  const start = offset(property, "start");
+  const end = offset(property, "end");
+  if (start === void 0 || end === void 0) {
+    return void 0;
+  }
+  const from = source.lastIndexOf("\n", start) + 1;
+  const after = source.indexOf("\n", end);
+  const to = after === -1 ? source.length : after + 1;
+  const head = source.slice(from, start);
+  const tail = source.slice(end, to);
+  if (head.trim() !== "" || tail.replace(/^,/u, "").trim() !== "") {
+    return void 0;
+  }
+  return source.slice(0, from) + source.slice(to);
+}
+function indentOf(source, at) {
+  const from = source.lastIndexOf("\n", at) + 1;
+  return /^[\t ]*/u.exec(source.slice(from, at))?.[0] ?? "";
+}
+function offset(node, end) {
+  const value = node?.[end];
+  return typeof value === "number" ? value : void 0;
+}
+function addImport(source, patch) {
+  if (!patch.import) {
+    return source;
+  }
+  const mod = parseModule3(source);
+  if (patch.import.name in mod.imports) {
+    return source;
+  }
+  mod.imports.$prepend({
+    from: patch.import.from,
+    imported: patch.import.name,
+    local: patch.import.name
+  });
+  return print(source, mod);
+}
+function dropImport(source, patch) {
+  if (!patch.import) {
+    return source;
+  }
+  const mod = parseModule3(source);
+  const program = mod.$ast;
+  if (!(patch.import.name in mod.imports) || isReferenced(program, patch.import.name)) {
+    return source;
+  }
+  delete mod.imports[patch.import.name];
+  return print(source, mod);
+}
+function drizzleColumnInsertRefusal(source, patch) {
+  const mod = parseModule3(source);
+  if (!mod.exports[patch.exportName]) {
+    return `drizzle-column could not find an export named ${JSON.stringify(patch.exportName)}`;
+  }
+  const columns = columnsObject(mod, patch);
+  if (!columns) {
+    return `${JSON.stringify(patch.exportName)} is not a Drizzle table call with a columns object as its second argument`;
+  }
+  const at = indexOfColumn(columns, patch.column);
+  if (at !== -1 && valueDrift(columns, at, patch)) {
+    return `${JSON.stringify(patch.column)} on ${JSON.stringify(patch.exportName)} holds ${printed(columns, at)}, not the ${patch.value} this patch adds`;
+  }
+  if (at === -1 && patch.import) {
+    return insertBindingConflict2(mod.imports, patch);
+  }
+  return void 0;
+}
+function drizzleColumnRemoveRefusal(source, patch) {
+  const mod = parseModule3(source);
+  const columns = columnsObject(mod, patch);
+  const at = columns ? indexOfColumn(columns, patch.column) : -1;
+  if (!columns || at === -1) {
+    return void 0;
+  }
+  return valueDrift(columns, at, patch) ?? (patch.import ? removeBindingConflict2(mod.imports, patch.import) : void 0);
+}
+function columnsObject(mod, patch) {
+  const { exports } = mod;
+  const node = exports[patch.exportName]?.$args?.[COLUMNS_ARG]?.$ast;
+  return node?.type === "ObjectExpression" ? node : void 0;
+}
+function indexOfColumn(columns, column) {
+  return columns.properties.findIndex(
+    (property) => property.key?.name === column || property.key?.value === column
+  );
+}
+function parseExpressionNode(code) {
+  const declaration = parseModule3(`const __drizzleColumn = ${code};`).$ast;
+  const init = declaration.body.length === 1 ? declaration.body[0]?.declarations?.[0]?.init : void 0;
+  if (!init) {
+    throw new TypeError(
+      `drizzle-column value is not a single expression: ${JSON.stringify(code)}`
+    );
+  }
+  return init;
+}
+function printed(columns, at) {
+  return generateCode2(columns.properties[at]?.value).code;
+}
+function valueDrift(columns, at, patch) {
+  if (collapse(printed(columns, at)) === collapse(patch.value)) {
+    return void 0;
+  }
+  return `${JSON.stringify(patch.column)} on ${JSON.stringify(patch.exportName)} reads ${printed(columns, at)} now, not the ${patch.value} that was applied`;
+}
+function collapse(code) {
+  return code.replaceAll(/\s+/gu, "");
+}
+function insertBindingConflict2(imports, patch) {
+  const held = patch.import ? foreignBinding(imports, patch.import) : void 0;
+  if (!held || !patch.import) {
+    return void 0;
+  }
+  return `${describeBinding(patch.import.name, held)}, so ${JSON.stringify(patch.column)} would read the wrong builder`;
+}
+function removeBindingConflict2(imports, want) {
+  const held = foreignBinding(imports, want);
+  if (!held) {
+    return void 0;
+  }
+  return `${describeBinding(want.name, held)} now, not from ${JSON.stringify(want.from)}, so the column and its import are not the ones that were applied`;
+}
+function print(source, mod) {
+  return keepTerminator(
+    source,
+    generateCode2(mod, { format: { objectCurlySpacing: true } }).code
+  );
+}
+
 // src/lib/patch/jsonc.ts
 import {
   applyEdits,
@@ -1137,9 +1325,9 @@ function upsertPackageJsonScript(source, patch) {
 }
 
 // src/lib/patch/ts-module.ts
-import { builders as builders2, generateCode as generateCode2, parseModule as parseModule3 } from "magicast";
+import { builders as builders2, generateCode as generateCode3, parseModule as parseModule4 } from "magicast";
 function insertIntoPluginArray(source, patch) {
-  const mod = parseModule3(source);
+  const mod = parseModule4(source);
   const exported = mod.exports[patch.exportName];
   const callArg = exported?.$args?.[0];
   if (!callArg) {
@@ -1150,7 +1338,7 @@ function insertIntoPluginArray(source, patch) {
     return source;
   }
   if (!(patch.import.name in mod.imports)) {
-    mod.imports.$add({
+    mod.imports.$prepend({
       from: patch.import.from,
       imported: patch.import.name,
       local: patch.import.name
@@ -1162,10 +1350,10 @@ function insertIntoPluginArray(source, patch) {
   } else {
     callArg[patch.arrayProp] = [newCall];
   }
-  return print(source, mod);
+  return print2(source, mod);
 }
 function removeFromPluginArray(source, patch) {
-  const mod = parseModule3(source);
+  const mod = parseModule4(source);
   const exported = mod.exports[patch.exportName];
   const callArg = exported?.$args?.[0];
   if (!callArg) {
@@ -1182,7 +1370,7 @@ function removeFromPluginArray(source, patch) {
   if (argumentDrift(array[index], patch)) {
     return source;
   }
-  if (removeBindingConflict2(mod.imports, patch)) {
+  if (removeBindingConflict3(mod.imports, patch)) {
     return source;
   }
   array.splice(index, 1);
@@ -1190,10 +1378,10 @@ function removeFromPluginArray(source, patch) {
   if (patch.import.name in mod.imports && !isReferenced(program, patch.import.name)) {
     delete mod.imports[patch.import.name];
   }
-  return print(source, mod);
+  return print2(source, mod);
 }
 function pluginArrayRemoveRefusal(source, patch) {
-  const mod = parseModule3(source);
+  const mod = parseModule4(source);
   const callArg = mod.exports[patch.exportName]?.$args?.[0];
   if (!callArg) {
     return void 0;
@@ -1206,12 +1394,12 @@ function pluginArrayRemoveRefusal(source, patch) {
   if (index === -1) {
     return void 0;
   }
-  return argumentDrift(array[index], patch) ?? removeBindingConflict2(mod.imports, patch);
+  return argumentDrift(array[index], patch) ?? removeBindingConflict3(mod.imports, patch);
 }
-function print(source, mod) {
+function print2(source, mod) {
   return keepTerminator(
     source,
-    generateCode2(mod, { format: { objectCurlySpacing: true } }).code
+    generateCode3(mod, { format: { objectCurlySpacing: true } }).code
   );
 }
 function findCallIndex(array, call) {
@@ -1229,7 +1417,7 @@ function argumentDrift(element, patch) {
   }
   return `${patch.call}() in ${JSON.stringify(patch.arrayProp)} takes arguments now, not the bare call that was applied`;
 }
-function removeBindingConflict2(imports, patch) {
+function removeBindingConflict3(imports, patch) {
   const held = foreignBinding(imports, patch.import);
   if (!held) {
     return void 0;
@@ -1244,6 +1432,7 @@ function isFunctionCall(value) {
 var PATCH_KIND_KEYS = {
   "chained-route": true,
   "const-array": true,
+  "drizzle-column": true,
   "package-json-dependency": true,
   "package-json-script": true,
   "plugin-array": true,
@@ -1280,6 +1469,9 @@ function applyCodemod(source, patch) {
     case "const-array": {
       return insertIntoConstArray(source, patch);
     }
+    case "drizzle-column": {
+      return insertDrizzleColumn(source, patch);
+    }
     case "wrangler-binding": {
       return upsertWranglerBinding(source, patch);
     }
@@ -1304,6 +1496,7 @@ function applyCodemod(source, patch) {
 var INVERSES = {
   "chained-route": removeChainedRoute,
   "const-array": removeFromConstArray,
+  "drizzle-column": removeDrizzleColumn,
   "plugin-array": removeFromPluginArray,
   "wrangler-binding": removeWranglerBinding
 };
@@ -1327,10 +1520,12 @@ function reversePatch(source, patch, filename) {
 var REFUSALS = {
   "chained-route": chainedRouteInsertRefusal,
   "const-array": constArrayInsertRefusal,
+  "drizzle-column": drizzleColumnInsertRefusal,
   "package-json-script": packageJsonScriptRefusal
 };
 var REVERSAL_REFUSALS = {
   "chained-route": chainedRouteRemoveRefusal,
+  "drizzle-column": drizzleColumnRemoveRefusal,
   "plugin-array": pluginArrayRemoveRefusal,
   "wrangler-binding": wranglerBindingRemoveRefusal
 };
@@ -3676,7 +3871,7 @@ import pc3 from "picocolors";
 import { createHash as createHash2 } from "crypto";
 import { mkdtemp as mkdtemp2, readdir as readdir3, readFile as readFile12, rm as rm2 } from "fs/promises";
 import { tmpdir as tmpdir2 } from "os";
-import { basename, join as join10, posix as posix6 } from "path";
+import { join as join10, posix as posix6 } from "path";
 
 // src/lib/scaffold.ts
 import { mkdir as mkdir5, readdir as readdir2, readFile as readFile11, writeFile as writeFile7 } from "fs/promises";
@@ -3686,7 +3881,7 @@ import { fileURLToPath as fileURLToPath3 } from "url";
 // package.json
 var package_default = {
   name: "saasaloy",
-  version: "0.1.2",
+  version: "0.3.0",
   description: "Composable SaaS accelerator kit.",
   keywords: [
     "saas",
@@ -3737,19 +3932,19 @@ var package_default = {
   },
   devDependencies: {
     "@release-it/conventional-changelog": "12.0.0",
-    "@types/node": "26.1.1",
-    "@vitest/coverage-v8": "4.1.10",
+    "@types/node": "26.4.1",
+    "@vitest/coverage-v8": "5.0.0",
     "release-it": "21.0.2",
     tsup: "8.5.1",
-    vitest: "4.1.10"
+    vitest: "5.0.0"
   },
   dependencies: {
     "@clack/prompts": "1.7.0",
-    ajv: "8.17.1",
+    ajv: "8.20.0",
     diff: "9.0.0",
-    giget: "3.3.0",
+    giget: "3.3.1",
     "jsonc-parser": "3.3.1",
-    magicast: "0.5.3",
+    magicast: "0.5.4",
     picocolors: "1.1.1"
   }
 };
@@ -3826,10 +4021,20 @@ var BASE_MODULE = "base";
 var DEFAULT_BASE_NAME = "web";
 var BASE_NO_MERGE_BASE = "the template ships with the CLI; the previous version isn't on disk";
 var BASE_INTENT = "the base template changed; keep local edits, take the upstream change";
+function compileGlob(pattern) {
+  const source = pattern.split("/").map(
+    (segment) => segment === "**" ? "[^\0]*" : segment.replaceAll(/[.+^${}()|[\]\\]/g, String.raw`\$&`).replaceAll("*", "[^/]*")
+  ).join("/").replaceAll("[^\0]*/", "(?:[^\0]*/)?");
+  return new RegExp(`^${source}$`);
+}
+function ownedMatcher(declaration) {
+  const patterns = declaration.ownedFiles.map(compileGlob);
+  return (target) => patterns.some((re) => re.test(target));
+}
 async function readBaseDeclaration(templateDir) {
   const raw = await readIfPresent(join10(templateDir, BASE_DECLARATION));
   if (raw === void 0) {
-    return { seedFiles: [] };
+    return { seedFiles: [], ownedFiles: [] };
   }
   const parsed = JSON.parse(raw);
   const seedFiles = parsed.seedFiles;
@@ -3838,7 +4043,16 @@ async function readBaseDeclaration(templateDir) {
       `${BASE_DECLARATION} must declare "seedFiles" as a list of project-relative paths.`
     );
   }
-  return { seedFiles };
+  const ownedFiles = parsed.ownedFiles ?? [];
+  if (!Array.isArray(ownedFiles) || !ownedFiles.every((entry) => typeof entry === "string" && entry !== "")) {
+    throw new Error(
+      `${BASE_DECLARATION} must declare "ownedFiles" as a list of project-relative globs.`
+    );
+  }
+  return {
+    seedFiles,
+    ownedFiles
+  };
 }
 async function listTemplateFiles(templateDir) {
   const out = [];
@@ -3900,6 +4114,7 @@ function recordBaseFiles(manifest, files) {
     manifest.managed[file.target] = {
       module: BASE_MODULE,
       hash: file.hash,
+      ...file.adopted ? { adopted: true } : {},
       from: file.from
     };
   }
@@ -3920,13 +4135,15 @@ async function missingBaseTargets(root, manifest, templateDir) {
   }
   return missing.toSorted((a, b) => a < b ? -1 : 1);
 }
-async function renderTemplate(root, templateDir) {
+async function renderTemplate(root, templateDir, projectName) {
   const dir = await mkdtemp2(join10(tmpdir2(), "saasaloy-base-render-"));
   const files = await copyTemplate(
     templateDir,
     dir,
-    templateVars(basename(root)),
-    { keepNames: true }
+    templateVars(projectName),
+    {
+      keepNames: true
+    }
   );
   return {
     dir,
@@ -3935,9 +4152,16 @@ async function renderTemplate(root, templateDir) {
   };
 }
 async function adoptBase(args) {
-  const { root, cliVersion, manifest, lock, dryRun = false } = args;
+  const {
+    root,
+    cliVersion,
+    projectName,
+    manifest,
+    lock,
+    dryRun = false
+  } = args;
   const templateDir = args.templateDir ?? await baseTemplateDir();
-  const render = await renderTemplate(root, templateDir);
+  const render = await renderTemplate(root, templateDir, projectName);
   try {
     const files = [];
     const adopted = [];
@@ -3952,7 +4176,8 @@ async function adoptBase(args) {
         files.push({
           target: file.target,
           from: file.from,
-          hash: hashContent(mine)
+          hash: hashContent(mine),
+          adopted: true
         });
       }
     }
@@ -3973,9 +4198,18 @@ async function adoptBase(args) {
   }
 }
 async function baseUpdateInput(args) {
-  const { root, manifest, lock, templateDir, cliVersion, comparison } = args;
-  const render = await renderTemplate(root, templateDir);
-  const seed = new Set((await readBaseDeclaration(templateDir)).seedFiles);
+  const {
+    root,
+    manifest,
+    lock,
+    templateDir,
+    cliVersion,
+    projectName,
+    comparison
+  } = args;
+  const render = await renderTemplate(root, templateDir, projectName);
+  const declaration = await readBaseDeclaration(templateDir);
+  const seed = new Set(declaration.seedFiles);
   const shipped = render.files.filter((file) => !seed.has(file.target));
   const targets = new Set(shipped.map((file) => file.target));
   return {
@@ -4000,6 +4234,7 @@ async function baseUpdateInput(args) {
       noMergeBase: BASE_NO_MERGE_BASE,
       intent: [],
       ignoreTargets: seed,
+      isOwned: ownedMatcher(declaration),
       reapplyPatches: manifest.patches.filter(
         (patch) => targets.has(patch.file)
       ),
@@ -4014,8 +4249,10 @@ async function baseUpdateInput(args) {
 }
 
 // src/lib/doctor.ts
+import { findNodeAtLocation as findNodeAtLocation4, getNodeValue as getNodeValue4, parseTree as parseTree4 } from "jsonc-parser";
+import { parseModule as parseModule5 } from "magicast";
 import { readFile as readFile13 } from "fs/promises";
-import { basename as basename2, dirname as dirname6, join as join11, posix as posix7, resolve as resolve3 } from "path";
+import { basename, dirname as dirname6, join as join11, posix as posix7, resolve as resolve3 } from "path";
 var SKILL_PREFIX = "saasaloy-";
 var PINNED_DEP = /^(@[^/@]+\/)?[^/@]+@\d+\.\d+\.\d+(-[\w.-]+)?(\+[\w.-]+)?$/;
 function finding(module, where, message) {
@@ -4069,7 +4306,7 @@ async function readDescriptor(dir) {
 }
 async function checkModule(input) {
   const { aliases, dir, siblings } = input;
-  const module = basename2(dir);
+  const module = basename(dir);
   const findings = [];
   const report = () => ({ dir, findings, module });
   const file = join11(dir, "registry-item.json");
@@ -4270,10 +4507,204 @@ function checkProject(args) {
     )
   );
 }
+var KV_INDEX_FILE = "packages/kv/src/index.ts";
+var WRANGLER_FILE = "apps/api/wrangler.jsonc";
+var CLOUDFLARE_KV_MODULE = "kv-cloudflare";
+function checkPolicyBindings(args) {
+  const bound = new Set(rateLimitBindingNames(args.wrangler));
+  const findings = [];
+  for (const entry of registeredPolicies(args)) {
+    if (entry.name === void 0) {
+      findings.push(
+        finding(
+          "ratelimit",
+          `/policies/${String(entry.index)}`,
+          `the policy at index ${String(entry.index)} of the \`policies\` array in ${KV_INDEX_FILE} has no name this check can read, so its RL_<NAME> binding in ${WRANGLER_FILE} was not checked. Write it as \`definePolicy({ name: "..." })\`, or as a factory exported from a file under packages/kv/src/policies/.`
+        )
+      );
+      continue;
+    }
+    if (!bound.has(bindingFor(entry.name))) {
+      findings.push(
+        finding(
+          "ratelimit",
+          `/policies/${entry.name}`,
+          `policy "${entry.name}" has no ${bindingFor(entry.name)} entry in ${WRANGLER_FILE} \u2014 consume({ policy: "${entry.name}" }) throws not_supported on the first request. Add the binding, or drop the policy from ${KV_INDEX_FILE}.`
+        )
+      );
+    }
+  }
+  return findings;
+}
+function bindingFor(policy) {
+  return `RL_${policy.toUpperCase()}`;
+}
+function rateLimitBindingNames(wrangler) {
+  const root = parseTree4(wrangler);
+  if (!root) {
+    return [];
+  }
+  const node = findNodeAtLocation4(root, ["ratelimits"]);
+  if (node?.type !== "array") {
+    return [];
+  }
+  const names = [];
+  for (const child of node.children ?? []) {
+    const value = getNodeValue4(child);
+    const name = asRecord(value).name;
+    if (typeof name === "string") {
+      names.push(name);
+    }
+  }
+  return names;
+}
+function registeredPolicies(args) {
+  let mod;
+  try {
+    mod = parseModule5(args.index);
+  } catch {
+    return [];
+  }
+  const callArg = mod.exports.kv?.$args?.[0];
+  const array = callArg?.policies;
+  if (!Array.isArray(array)) {
+    return [];
+  }
+  const imports = mod.imports;
+  const policies = [];
+  for (let i = 0; i < array.length; i++) {
+    const element = array[i];
+    policies.push({ index: i, name: policyNameOf(element, args, imports) });
+  }
+  return policies;
+}
+function policyNameOf(element, args, imports) {
+  const callee = calleeName(element);
+  if (callee === void 0) {
+    return void 0;
+  }
+  const inline = inlineNameArgument(element);
+  if (inline !== void 0) {
+    return inline;
+  }
+  const from = imports[callee]?.from;
+  const source = typeof from === "string" ? args.policySources[from] : void 0;
+  return source === void 0 ? void 0 : policyNameIn(source, callee);
+}
+function inlineNameArgument(element) {
+  const args = element.$args;
+  if (!Array.isArray(args)) {
+    return void 0;
+  }
+  const name = asRecord(args[0]).name;
+  return typeof name === "string" ? name : void 0;
+}
+function calleeName(element) {
+  if (typeof element !== "object" || element === null) {
+    return void 0;
+  }
+  const record = element;
+  return record.$type === "function-call" && typeof record.$callee === "string" ? record.$callee : void 0;
+}
+function policyNameIn(source, callee) {
+  let program;
+  try {
+    program = parseModule5(source).$ast;
+  } catch {
+    return void 0;
+  }
+  const factory = findNode(
+    program,
+    (node) => (node.type === "FunctionDeclaration" || node.type === "VariableDeclarator") && asRecord(node.id).name === callee
+  );
+  if (!factory) {
+    return void 0;
+  }
+  const call = findNode(
+    factory,
+    (node) => node.type === "CallExpression" && asRecord(node.callee).name === "definePolicy"
+  );
+  const argument = asArray(call?.arguments)[0];
+  const property = asArray(asRecord(argument).properties).find(
+    (entry) => asRecord(asRecord(entry).key).name === "name"
+  );
+  const value = asRecord(asRecord(property).value).value;
+  return typeof value === "string" ? value : void 0;
+}
+function findNode(root, accept) {
+  if (Array.isArray(root)) {
+    for (const child of root) {
+      const found = findNode(child, accept);
+      if (found) {
+        return found;
+      }
+    }
+    return void 0;
+  }
+  if (typeof root !== "object" || root === null) {
+    return void 0;
+  }
+  const node = root;
+  if (typeof node.type === "string") {
+    const typed = node;
+    if (accept(typed)) {
+      return typed;
+    }
+  }
+  for (const [key, value] of Object.entries(node)) {
+    if (key === "loc" || key === "comments" || key === "original") {
+      continue;
+    }
+    const found = findNode(value, accept);
+    if (found) {
+      return found;
+    }
+  }
+  return void 0;
+}
+async function readPolicyState(root, installed) {
+  if (!installed.includes(CLOUDFLARE_KV_MODULE)) {
+    return void 0;
+  }
+  const index = await readIfPresent(resolveWithinRoot(root, KV_INDEX_FILE));
+  const wrangler = await readIfPresent(resolveWithinRoot(root, WRANGLER_FILE));
+  if (index === void 0 || wrangler === void 0) {
+    return void 0;
+  }
+  const policySources = {};
+  for (const specifier of relativeImportsIn(index)) {
+    const source = await readIfPresent(
+      resolveWithinRoot(
+        root,
+        posix7.join(posix7.dirname(KV_INDEX_FILE), `${specifier}.ts`)
+      )
+    );
+    if (source !== void 0) {
+      policySources[specifier] = source;
+    }
+  }
+  return { index, policySources, wrangler };
+}
+function relativeImportsIn(index) {
+  let mod;
+  try {
+    mod = parseModule5(index);
+  } catch {
+    return [];
+  }
+  const imports = mod.imports;
+  const specifiers = /* @__PURE__ */ new Set();
+  for (const held of Object.values(imports)) {
+    if (typeof held?.from === "string" && held.from.startsWith(".")) {
+      specifiers.add(held.from);
+    }
+  }
+  return [...specifiers];
+}
 async function resolveDoctorTarget(path) {
   const dir = resolve3(path);
   if (await pathExists(join11(dir, "registry-item.json"))) {
-    return { names: [basename2(dir)], registryDir: dirname6(dir) };
+    return { names: [basename(dir)], registryDir: dirname6(dir) };
   }
   return { names: await registryModuleNames(dir), registryDir: dir };
 }
@@ -4415,9 +4846,11 @@ async function reportProject(path) {
     seedFiles: (await readBaseDeclaration(await baseTemplateDir())).seedFiles
   });
   note2(wrapForNote(renderBase(base)), "Base");
+  const policyState = await readPolicyState(path, config.installed);
   const findings = [
     ...checkProject({ config, manifest }),
-    ...checkPartialInstalls({ installed: config.installed, manifest })
+    ...checkPartialInstalls({ installed: config.installed, manifest }),
+    ...policyState ? checkPolicyBindings(policyState) : []
   ];
   if (findings.length === 0) {
     const count = config.installed.length;
@@ -5122,8 +5555,8 @@ ${entry.declaration.description}`,
 
 // src/commands/init.ts
 import { spawn } from "child_process";
-import { readdir as readdir4 } from "fs/promises";
-import { basename as basename3, join as join14, resolve as resolve6 } from "path";
+import { readdir as readdir4, readFile as readFile16 } from "fs/promises";
+import { basename as basename2, join as join14, resolve as resolve6 } from "path";
 import {
   cancel as cancel4,
   intro as intro4,
@@ -5315,7 +5748,7 @@ async function runInit(argv) {
         if (!trimmed) {
           return "Enter a project name (or `.` for the current directory).";
         }
-        const name = basename3(resolve6(process.cwd(), trimmed));
+        const name = basename2(resolve6(process.cwd(), trimmed));
         if (!NAME_PATTERN.test(name)) {
           return "Use lowercase letters, digits, and hyphens (e.g. my-app).";
         }
@@ -5329,7 +5762,7 @@ async function runInit(argv) {
     nameArg = answer.trim();
   }
   const target = resolve6(process.cwd(), nameArg);
-  const projectName = basename3(target);
+  const projectName = basename2(target);
   if (!NAME_PATTERN.test(projectName)) {
     cancel4(
       `Invalid project name "${projectName}". Use lowercase letters, digits, and hyphens (e.g. my-app).`
@@ -5356,6 +5789,17 @@ async function runInit(argv) {
   s.stop(
     `Scaffolded ${pc6.cyan(projectName)} ${pc6.dim("(apps/web \xB7 packages/ui \xB7 packages/tsconfig)")}`
   );
+  try {
+    const config = await loadConfig(target);
+    await saveConfig(target, { ...config, name: projectName });
+    const entry = written.find((file) => file.target === CONFIG_FILE);
+    if (entry) {
+      entry.hash = hashContent(await readFile16(entry.path, "utf-8"));
+    }
+  } catch (error) {
+    cancel4(`Couldn't record the project name: ${errorMessage(error)}`);
+    return EXIT_FAILURE;
+  }
   try {
     const manifest = await loadManifest(target);
     const lock = await loadLock(target);
@@ -5919,11 +6363,11 @@ import { cancel as cancel7, intro as intro7, log as log5, note as note7, outro a
 import pc9 from "picocolors";
 
 // src/lib/updater.ts
-import { mkdir as mkdir8, readFile as readFile17, rm as rmPath2, writeFile as writeFile11 } from "fs/promises";
+import { mkdir as mkdir8, readFile as readFile18, rm as rmPath2, writeFile as writeFile11 } from "fs/promises";
 import { dirname as dirname11, posix as posix9 } from "path";
 
 // src/lib/remover.ts
-import { readdir as readdir5, readFile as readFile16, rm as rmPath, writeFile as writeFile10 } from "fs/promises";
+import { readdir as readdir5, readFile as readFile17, rm as rmPath, writeFile as writeFile10 } from "fs/promises";
 import { dirname as dirname10, join as join18, relative as relative5, sep as sep3 } from "path";
 function classifyTrackedFile(content, manifestHash) {
   if (content === void 0) {
@@ -5948,7 +6392,7 @@ async function buildRemovePlan(args) {
       continue;
     }
     const targetAbs = resolveWithinRoot(root, target);
-    const oldContent = await pathExists(targetAbs) ? await readFile16(targetAbs, "utf-8") : void 0;
+    const oldContent = await pathExists(targetAbs) ? await readFile17(targetAbs, "utf-8") : void 0;
     files.push({
       module: name,
       target,
@@ -6015,7 +6459,7 @@ async function previewPatchRemoval(root, entry) {
     return { entry, action: "gone", diff: "" };
   }
   await assertNoSymlinkPath(root, fileAbs);
-  const source = await readFile16(fileAbs, "utf-8");
+  const source = await readFile17(fileAbs, "utf-8");
   const attempt = tryReversePatch(source, entry);
   if (!attempt.ok) {
     return { entry, action: "refused", diff: "", reason: attempt.reason };
@@ -6083,7 +6527,7 @@ async function recheckFile(file) {
   if (file.oldContent === void 0) {
     return "changed";
   }
-  const current = await readFile16(file.targetAbs, "utf-8");
+  const current = await readFile17(file.targetAbs, "utf-8");
   return hashContent(current) === hashContent(file.oldContent) ? "unchanged" : "changed";
 }
 async function executeRemovePlan(plan, args) {
@@ -6135,7 +6579,7 @@ async function executeRemovePlan(plan, args) {
     let reversed = false;
     if (await pathExists(fileAbs)) {
       await assertNoSymlinkPath(root, fileAbs);
-      const source = await readFile16(fileAbs, "utf-8");
+      const source = await readFile17(fileAbs, "utf-8");
       const attempt = tryReversePatch(source, entry);
       if (!attempt.ok) {
         patchRefusals.push({ patch: entry, reason: attempt.reason });
@@ -6418,18 +6862,21 @@ async function planOneModule(args) {
   const baseFiles = base ? await listModuleFiles(base, aliasView, installedSet) : void 0;
   const files = [];
   for (const ref of theirsFiles.values()) {
-    const theirsContent = await readFile17(ref.abs, "utf-8");
+    const theirsContent = await readFile18(ref.abs, "utf-8");
     const baseRef = baseFiles?.get(ref.target);
-    const baseContent = baseRef ? await readFile17(baseRef.abs, "utf-8") : void 0;
+    const baseContent = baseRef ? await readFile18(baseRef.abs, "utf-8") : void 0;
     const targetAbs = resolveWithinRoot(root, ref.target);
     const managed = manifest.managed[ref.target];
     const owned = managed?.module === name ? managed : void 0;
     const mine = await readIfPresent(targetAbs);
+    const projectOwned = input.isOwned?.(ref.target) ?? false;
     const action = classifyUpdate(
       baseContent,
       theirsContent,
       mine,
-      owned?.hash
+      owned?.hash,
+      owned?.adopted ?? false,
+      projectOwned
     );
     const patchedBy = patchersOf(manifest, ref.target);
     files.push({
@@ -6438,6 +6885,8 @@ async function planOneModule(args) {
       target: ref.target,
       targetAbs,
       action,
+      ...projectOwned ? { projectOwned: true } : {},
+      ...owned?.adopted ? { adopted: true } : {},
       base: baseContent,
       theirs: theirsContent,
       mine,
@@ -6453,13 +6902,14 @@ async function planOneModule(args) {
     const targetAbs = resolveWithinRoot(root, target);
     const mine = await readIfPresent(targetAbs);
     const baseRef = baseFiles?.get(target);
+    const keep = mine !== void 0 && ((entry.adopted ?? false) || (input.isOwned?.(target) ?? false));
     removals.push({
       module: name,
       from: entry.from ?? baseRef?.from ?? target,
       target,
       targetAbs,
-      action: DELETE_ACTION[classifyTrackedFile(mine, entry.hash)],
-      base: baseRef ? await readFile17(baseRef.abs, "utf-8") : void 0,
+      action: keep ? "delete-drift" : DELETE_ACTION[classifyTrackedFile(mine, entry.hash)],
+      base: baseRef ? await readFile18(baseRef.abs, "utf-8") : void 0,
       mine
     });
   }
@@ -6580,7 +7030,7 @@ function newEnvVars(base, theirs) {
   }
   return out;
 }
-function classifyUpdate(base, theirs, mine, managedHash) {
+function classifyUpdate(base, theirs, mine, managedHash, adopted, projectOwned) {
   if (base !== void 0 && base === theirs) {
     return "skip";
   }
@@ -6593,6 +7043,9 @@ function classifyUpdate(base, theirs, mine, managedHash) {
   if (managedHash === void 0) {
     return "conflict";
   }
+  if (adopted || projectOwned) {
+    return "drift";
+  }
   return hashContent(mine) === managedHash ? "overwrite" : "drift";
 }
 async function planLinks(root, theirs) {
@@ -6748,7 +7201,7 @@ async function executeUpdatePlan(plan, args) {
         clean = false;
         continue;
       }
-      const source = await readFile17(p.fileAbs, "utf-8");
+      const source = await readFile18(p.fileAbs, "utf-8");
       const { content, changed } = applyPatch(source, p.patch, p.file);
       if (!changed) {
         continue;
@@ -7372,8 +7825,8 @@ ${pc10.dim("Hand-edited since \u2014 left on disk, now untracked.")}`
 }
 
 // src/commands/update.ts
-import { mkdir as mkdir9, realpath, writeFile as writeFile12 } from "fs/promises";
-import { basename as basename4, dirname as dirname12, isAbsolute as isAbsolute4, join as join19, resolve as resolve8 } from "path";
+import { mkdir as mkdir10, realpath, writeFile as writeFile13 } from "fs/promises";
+import { basename as basename4, dirname as dirname13, isAbsolute as isAbsolute4, join as join20, resolve as resolve8 } from "path";
 import {
   cancel as cancel9,
   confirm as confirm3,
@@ -7385,6 +7838,145 @@ import {
 } from "@clack/prompts";
 import pc11 from "picocolors";
 
+// src/lib/backup.ts
+import {
+  copyFile,
+  mkdir as mkdir9,
+  readdir as readdir6,
+  readFile as readFile19,
+  rm as rmPath3,
+  writeFile as writeFile12
+} from "fs/promises";
+import { dirname as dirname12, join as join19 } from "path";
+var BACKUP_DIR = join19(".saasaloy", "backups");
+var RECORD_FILE = "backup.json";
+var STATE_FILES = [
+  "saasaloy.json",
+  "saasaloy-lock.json",
+  "package.json",
+  join19(".saasaloy", "manifest.json")
+];
+function stampName(now) {
+  return now.toISOString().replaceAll(/[:.]/g, "-");
+}
+async function writeBackup(args) {
+  const { root, targets, cliVersion } = args;
+  const createdAt = (args.now ?? /* @__PURE__ */ new Date()).toISOString();
+  const rel = join19(BACKUP_DIR, stampName(args.now ?? new Date(createdAt)));
+  const dir = join19(root, rel);
+  const files = [];
+  const absent = [];
+  for (const target of /* @__PURE__ */ new Set([...targets, ...STATE_FILES])) {
+    const source = resolveWithinRoot(root, target);
+    if (!await pathExists(source)) {
+      absent.push(target);
+      continue;
+    }
+    const destination = join19(dir, target);
+    await mkdir9(dirname12(destination), { recursive: true });
+    await copyFile(source, destination);
+    files.push(target);
+  }
+  const record = {
+    createdAt,
+    cliVersion,
+    files: files.toSorted(),
+    absent: absent.toSorted()
+  };
+  await mkdir9(dir, { recursive: true });
+  await writeFile12(
+    join19(dir, RECORD_FILE),
+    `${JSON.stringify(record, null, 2)}
+`,
+    "utf-8"
+  );
+  return rel;
+}
+async function listBackups(root) {
+  const dir = join19(root, BACKUP_DIR);
+  if (!await pathExists(dir)) {
+    return [];
+  }
+  const entries = await readdir6(dir, { withFileTypes: true });
+  return entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name).toSorted();
+}
+async function restoreLatestBackup(root) {
+  const backups = await listBackups(root);
+  const newest = backups.at(-1);
+  if (!newest) {
+    throw new RefusalError(
+      `No backup to restore \u2014 nothing under ${BACKUP_DIR}. \`saasaloy update\` writes one before it applies a plan.`
+    );
+  }
+  const rel = join19(BACKUP_DIR, newest);
+  const dir = join19(root, rel);
+  const raw = await readIfPresent(join19(dir, RECORD_FILE));
+  if (raw === void 0) {
+    throw new RefusalError(
+      `${join19(rel, RECORD_FILE)} is missing \u2014 that backup can't be restored safely.`
+    );
+  }
+  let record;
+  try {
+    record = JSON.parse(raw);
+  } catch (error) {
+    throw new RefusalError(`${join19(rel, RECORD_FILE)} is invalid.`, {
+      cause: error
+    });
+  }
+  const restored = [];
+  for (const target of record.files) {
+    const source = join19(dir, target);
+    const destination = resolveWithinRoot(root, target);
+    if (!await pathExists(source)) {
+      continue;
+    }
+    await mkdir9(dirname12(destination), { recursive: true });
+    await copyFile(source, destination);
+    restored.push(target);
+  }
+  const removed = [];
+  for (const target of record.absent) {
+    const destination = resolveWithinRoot(root, target);
+    if (await pathExists(destination)) {
+      await rmPath3(destination, { force: true });
+      removed.push(target);
+    }
+  }
+  return { from: rel, restored, removed };
+}
+
+// src/lib/git-state.ts
+import { execFile } from "child_process";
+async function workingTreeState(root) {
+  return new Promise((resolve9) => {
+    execFile(
+      "git",
+      // `-- .` scopes the answer to the project. Without it a project nested inside a
+      // larger repository reports every unrelated change in that repository as its own.
+      ["status", "--porcelain", "--untracked-files=no", "--", "."],
+      { cwd: root },
+      (error, stdout) => {
+        resolve9(error ? "unknown" : stdout.trim() === "" ? "clean" : "dirty");
+      }
+    );
+  });
+}
+
+// src/lib/project-name.ts
+import { basename as basename3 } from "path";
+async function resolveProjectName(root, config) {
+  if (config.name) {
+    return { name: config.name, source: "config" };
+  }
+  const pkg = await readRootPackageJson(root);
+  const pkgName = typeof pkg?.name === "string" ? pkg.name : void 0;
+  if (pkgName) {
+    return { name: pkgName, source: "package.json" };
+  }
+  return { name: basename3(root), source: "directory" };
+}
+
 // src/lib/merge-plan.ts
 function renderMergePlan(plan) {
   const modules = plan.modules.filter((m) => m.needsMerge);
@@ -7499,6 +8091,17 @@ function renderFile(file) {
       ""
     );
   }
+  if (file.projectOwned) {
+    out.push(
+      "This file is yours: the template ships it once and never writes it again. The template's copy moved, so the change is shown below for you to take what you want from it. Nothing here was written.",
+      ""
+    );
+  } else if (file.adopted) {
+    out.push(
+      "Saasaloy adopted this file rather than writing it, so the hash it records came off your disk and proves nothing about who wrote these bytes. It is treated as edited and was left alone.",
+      ""
+    );
+  }
   if (file.patchedBy && file.patchedBy.length > 0) {
     out.push(
       `Note: \`${file.patchedBy.join("`, `")}\` also applied a config patch to this file. Part of the difference below is that patch rather than an edit anyone made by hand \u2014 keep those lines when you merge.`,
@@ -7611,11 +8214,13 @@ var KNOWN_FLAGS9 = /* @__PURE__ */ new Set([
   "--diff",
   "--yes",
   "-y",
+  "--force",
+  "--abort",
   "--help",
   "-h"
 ]);
 var VALUE_FLAGS2 = /* @__PURE__ */ new Set(["--ref", "--out"]);
-var USAGE9 = "saasaloy update [<module>|base] [--ref <ref>] [--out <path>] [--dry-run] [--diff] [--yes]";
+var USAGE9 = "saasaloy update [<module>|base] [--ref <ref>] [--out <path>] [--dry-run] [--diff] [--force] [--yes] | saasaloy update --abort";
 var HELP9 = {
   name: "update",
   describe: DESCRIPTIONS.update,
@@ -7625,6 +8230,8 @@ var HELP9 = {
     "--out <path>": "write the merge plan to a file instead of stdout",
     "--dry-run": "show the plan and write nothing",
     "--diff": "show a per-file diff and write nothing",
+    "--force": "apply even with uncommitted changes in the working tree",
+    "--abort": "restore the files the last update replaced, then stop",
     "-y, --yes": "skip the confirmation prompt"
   }
 };
@@ -7664,6 +8271,8 @@ function parseArgs9(argv) {
     dryRun: argv.includes("--dry-run"),
     diff: argv.includes("--diff"),
     yes: argv.includes("--yes") || argv.includes("-y"),
+    force: argv.includes("--force"),
+    abort: argv.includes("--abort"),
     unknown
   };
 }
@@ -7824,13 +8433,13 @@ function skipReason(comparison, preview = false) {
     }
   }
 }
-var STATE_FILES = [CONFIG_FILE, LOCK_FILE, MANIFEST_FILE];
+var STATE_FILES2 = [CONFIG_FILE, LOCK_FILE, MANIFEST_FILE];
 async function stateFileRefusal(root, out) {
   if (!out) {
     return void 0;
   }
   const target = await canonicalPath(resolvePlanOut(out));
-  for (const file of STATE_FILES) {
+  for (const file of STATE_FILES2) {
     if (await canonicalPath(resolve8(root, file)) === target) {
       return `Refusing to write the merge plan to ${pc11.cyan(out)} \u2014 that is Saasaloy's own ${pc11.cyan(file)}. Pick another path.`;
     }
@@ -7842,7 +8451,7 @@ async function canonicalPath(path) {
     return await realpath(path);
   } catch {
     try {
-      return join19(await realpath(dirname12(path)), basename4(path));
+      return join20(await realpath(dirname13(path)), basename4(path));
     } catch {
       return path;
     }
@@ -7857,10 +8466,24 @@ async function emitMergePlan(document, out) {
     return;
   }
   const target = resolvePlanOut(out);
-  await mkdir9(dirname12(target), { recursive: true });
-  await writeFile12(target, document, "utf-8");
+  await mkdir10(dirname13(target), { recursive: true });
+  await writeFile13(target, document, "utf-8");
   log7.success(`Merge plan written to ${pc11.cyan(out)}`, TUI_ON_STDERR);
 }
+function backupTargets(plan) {
+  const targets = /* @__PURE__ */ new Set();
+  for (const mod of plan.modules) {
+    for (const file of [...mod.files, ...mod.removals]) {
+      if (!QUIET.has(file.action) && file.action !== "skip") {
+        targets.add(file.target);
+      }
+    }
+    for (const patch of mod.patches) {
+      targets.add(patch.file);
+    }
+  }
+  return [...targets].toSorted();
+}
 function splitSlug2(slug) {
   const [owner, repo, ...rest] = slug.split("/");
   if (!owner || !repo || rest.length > 0) {
@@ -7898,12 +8521,43 @@ async function runUpdate(argv) {
     cancel9(formatFailure(error), TUI_ON_STDERR);
     return exitCodeFor(error);
   }
+  if (opts.abort) {
+    try {
+      const restored = await restoreLatestBackup(root);
+      for (const target of restored.restored) {
+        log7.step(`${pc11.green("restore")}  ${target}`, TUI_ON_STDERR);
+      }
+      for (const target of restored.removed) {
+        log7.step(
+          `${pc11.red("remove")}  ${target} ${pc11.dim("(the update created it)")}`,
+          TUI_ON_STDERR
+        );
+      }
+      outro9(
+        pc11.green(
+          `Restored ${restored.restored.length} file${restored.restored.length === 1 ? "" : "s"} from ${restored.from}.`
+        ),
+        TUI_ON_STDERR
+      );
+      return EXIT_OK;
+    } catch (error) {
+      cancel9(formatFailure(error), TUI_ON_STDERR);
+      return exitCodeFor(error);
+    }
+  }
   const outRefusal = await stateFileRefusal(root, opts.out);
   if (outRefusal) {
     cancel9(outRefusal, TUI_ON_STDERR);
     return EXIT_REFUSED;
   }
   const preview = opts.dryRun || opts.diff;
+  if (!preview && !opts.force && await workingTreeState(root) === "dirty") {
+    cancel9(
+      "The working tree has uncommitted changes. Commit or stash them first, so `git diff` shows what this update did \u2014 or re-run with `--force`. Nothing was written.",
+      TUI_ON_STDERR
+    );
+    return EXIT_REFUSED;
+  }
   if (!opts.yes && !preview && !process.stdin.isTTY) {
     cancel9(
       "No terminal to confirm in \u2014 re-run with `--yes` to apply, or `--dry-run` to preview.",
@@ -7937,12 +8591,20 @@ async function runUpdate(argv) {
     const cliVersion = await readVersion();
     let baseComparison;
     let templateDir;
+    const project = await resolveProjectName(root, config);
     if (wantsBase) {
       templateDir = await baseTemplateDir();
+      if (project.source === "directory") {
+        log7.warn(
+          `No \`name\` in ${CONFIG_FILE} and no root package.json name \u2014 falling back to the directory name ${pc11.cyan(project.name)}. Set \`name\` in ${CONFIG_FILE} if that isn't this project's name.`,
+          TUI_ON_STDERR
+        );
+      }
       if (!isBaseTracked(lock, manifest)) {
         const adoption = await adoptBase({
           root,
           cliVersion,
+          projectName: project.name,
           manifest,
           lock,
           templateDir,
@@ -7950,7 +8612,7 @@ async function runUpdate(argv) {
         });
         const count = adoption.adopted.length;
         const lines = [
-          `${preview ? "Would adopt" : "Adopted"} ${count} base file${count === 1 ? "" : "s"} at CLI ${pc11.cyan(cliVersion)}, each at the hash it has on disk \u2014 your edits are the baseline, not drift.`
+          `${preview ? "Would adopt" : "Adopted"} ${count} base file${count === 1 ? "" : "s"} at CLI ${pc11.cyan(cliVersion)}, each at the hash it has on disk. Those bytes may be yours, so the next update treats every one of them as edited and offers a merge rather than a write.`
         ];
         if (adoption.absent.length > 0) {
           lines.push(
@@ -8066,6 +8728,7 @@ async function runUpdate(argv) {
         lock,
         templateDir,
         cliVersion,
+        projectName: project.name,
         comparison: baseComparison
       });
       cleanups.push(handle.cleanup);
@@ -8250,6 +8913,15 @@ async function runUpdate(argv) {
         return EXIT_OK;
       }
     }
+    const backupDir = await writeBackup({
+      root,
+      targets: backupTargets(plan),
+      cliVersion
+    });
+    log7.info(
+      `Pre-update copies in ${pc11.cyan(backupDir)} ${pc11.dim("\u2014 `saasaloy update --abort` restores them")}`,
+      TUI_ON_STDERR
+    );
     const outcome = await executeUpdatePlan(plan, {
       root,
       config,
@@ -8288,7 +8960,7 @@ async function runUpdate(argv) {
       );
     }
     outro9(summarizeOutcome(plan, result), TUI_ON_STDERR);
-    return EXIT_OK;
+    return plan.needsMerge ? EXIT_MERGE_PENDING : EXIT_OK;
   } catch (error) {
     cancel9(formatFailure(error), TUI_ON_STDERR);
     return exitCodeFor(error);