@neocompose/cli 0.67.2 → 0.67.3

package/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## [0.67.3] - 2026-10-04
+
+- `neo pull --force` and `neo pull --reset` keep the dialogue source names the server stores. Previously both regenerated names, so a force pull renamed bindings like `npc` to `AdoringFan` without rewriting the code that used them, left dozens of unrequested changes in `neo status`, and failed `neo push --dry-run` with "Unknown identifier".
+- `neo pull --regenerate-source-names` only replaces generated defaults such as `Value_1a2b3c4d5e6f`, `NeoFunction_…`, and `Conditions1`. Names you chose are kept. When it renames a binding, it rewrites references to it in dialogue functions, conditions, actions, and text variables. A node that re-links a dialogue value now uses the dialogue's name for it, so a function shared by several nodes reads the same in each.
+
 ## [0.67.2] - 2026-10-04
 
 - `neo pull --force` reads the workspace layout against the server's records instead of the baseline it is about to replace. Previously a baseline pulled before 0.67.0 failed with "Cannot recover local initializer placement before reset" in any workspace with local values, so the `--force` remedy 0.67.1 suggests could not run.

package/README.md

@@ -479,7 +479,7 @@ authorization boundary.
 | `logout [--api <url>]`                                | Delete the stored credential for one API origin and revoke its session.   |
 | `init --project <id> [--version <id>]`                | Create a format-4 working copy and perform its first reset pull.          |
 | `doctor`                                              | Validate format/compiler/editor/source/file contracts; no .NET discovery. |
-| `pull [--force\|--reset] [--regenerate-source-names]` | Merge remote changes or regenerate canonical source, names, and binaries. |
+| `pull [--force\|--reset] [--regenerate-source-names]` | Merge remote changes or regenerate canonical source and binaries.         |
 | `status [--json]`                                     | Compile source and summarize semantic records and upload intent.          |
 | `diff [--json]`                                       | Show semantic records, spans, digests, and upload intent.                 |
 | `push [--dry-run] [--accept-bump] [--no-verify]`      | Validate or commit one atomic compare-and-swap transaction.               |
@@ -514,9 +514,9 @@ security boundary.
 
 ## Regenerating dialogue source names
 
-Normal pull preserves source filenames and symbols by stable record ID. Force
-and reset pulls always derive readable dialogue names from authoritative
-records. To deliberately refresh those names during a normal merge, run:
+Every pull, including `--force` and `--reset`, keeps the dialogue source names
+the server stores. To replace generated defaults such as `Value_1a2b3c4d5e6f`,
+`NeoFunction_…`, or `Conditions1` with names derived from the editor, run:
 
 ```sh
 neo pull --regenerate-source-names
@@ -524,11 +524,12 @@ neo status
 neo push --dry-run
 ```
 
-Custom linked values prefer a non-empty string member named `Name`, using
-PascalCase at dialogue scope and camelCase inside nodes.
+Names you chose are kept. When a binding is renamed, code that refers to it is
+rewritten to match. Custom linked values prefer a non-empty string member named
+`Name`, using PascalCase at dialogue scope and camelCase inside nodes.
 
-The reset leaves the regenerated names as local changes. IDs are unchanged,
-and nothing is written to the server until `neo push` succeeds.
+The pull leaves the regenerated names as local changes. IDs are unchanged, and
+nothing is written to the server until `neo push` succeeds.
 
 ## Packaging
 

package/dist/neo.mjs

@@ -30114,7 +30114,7 @@ var init_registry = __esm({
   "../packages/manifest/schema-contract/registry.mjs"() {
     "use strict";
     PROJECT_SCHEMA_CONTRACT = Object.freeze({
-      cliVersion: "0.67.2",
+      cliVersion: "0.67.3",
       projectFileUploadBatchSize: 32,
       documentRecords: {
         member: {
@@ -59691,6 +59691,23 @@ function rewriteNeoScriptThisReceiver(source, alias) {
   }
   return result + source.slice(cursor);
 }
+function renameNeoScriptIdentifiers(source, renames) {
+  if (renames.size === 0) return source;
+  let result = "";
+  let cursor = 0;
+  let previous;
+  for (const token of lex(source).tokens) {
+    if (token.kind === "comment") continue;
+    const isMemberName = previous?.text === "." || previous?.text === "?.";
+    previous = token;
+    if (token.kind !== "identifier" || isMemberName) continue;
+    const renamed = renames.get(token.text);
+    if (renamed === void 0) continue;
+    result += source.slice(cursor, token.start) + renamed;
+    cursor = token.end;
+  }
+  return result + source.slice(cursor);
+}
 var init_neoscript_source_rewrite = __esm({
   "src/project-source/neoscript-source-rewrite.ts"() {
     "use strict";
@@ -59718,58 +59735,116 @@ function regenerateDialogueSourceNamesV4(records2) {
     live.filter((record6) => record6.recordKind === "dialogue-node").map((record6) => ({ record: record6, data: recordData2(record6) })),
     ({ data }) => stringField(data, "dialogueId")
   );
+  const keptClassNames = claimKeptNames(
+    typeNames,
+    dialogues.map((record6) => [record6.recordId, recordData2(record6).sourceName])
+  );
   dialogues.forEach((dialogueRecord, dialogueIndex) => {
     const dialogue = recordData2(dialogueRecord);
     const dialogueId = dialogueRecord.recordId;
-    const className = typeNames.claim(
+    const className = keptClassNames.get(dialogueId) ?? typeNames.claim(
       dialogueSourceNameFromDisplayName(
         optionalString2(dialogue.name),
         `Dialogue${dialogueIndex + 1}`
       )
     );
-    const nodeEntries = nodesByDialogue.get(dialogueId) ?? [];
+    const nodeEntries = (nodesByDialogue.get(dialogueId) ?? []).map(
+      ({ record: record6, data }) => ({
+        record: record6,
+        data,
+        links: linkedValueRecords(data.linkedValues, "Dialogue-node")
+      })
+    );
     const nodes = nodeEntries.map(({ data }) => data);
-    const triggerId = optionalString2(dialogue.triggerNodeId);
+    const bodyNodes = orderedBodyNodes(
+      nodes,
+      optionalString2(dialogue.triggerNodeId)
+    );
+    const links = linkedValueRecords(dialogue.linkedValues, "Dialogue");
+    const functions = sourceFunctionUses(nodes);
     const classMembers = new DialogueSourceNameAllocator(["Trigger"]);
-    const nodeNames = regeneratedNodeNames(nodes, triggerId, classMembers);
-    const dialogueLinks = regenerateBindingSourceNames(
-      dialogue.linkedValues,
+    const keptMembers = claimKeptNames(classMembers, [
+      ...bodyNodes.map(
+        (node) => [`node:${stringField(node, "id")}`, node.sourceName]
+      ),
+      ...links.map(
+        (link) => [`value:${stringField(link, "valueId")}`, link.sourceName]
+      ),
+      ...[...functions].map(
+        ([id2, fn]) => [`function:${id2}`, fn.existingName]
+      )
+    ]);
+    const valueIdsByOldName = /* @__PURE__ */ new Map();
+    const ambiguousOldNames = /* @__PURE__ */ new Set();
+    for (const { links: nodeLinks } of nodeEntries) {
+      for (const link of nodeLinks) {
+        const kept = keptSourceName(link.sourceName);
+        if (kept !== null) classMembers.reserve(kept);
+        const oldName = optionalString2(link.sourceName);
+        if (oldName === null) continue;
+        const valueId = stringField(link, "valueId");
+        const seen = valueIdsByOldName.get(oldName);
+        if (seen === void 0) valueIdsByOldName.set(oldName, valueId);
+        else if (seen !== valueId) ambiguousOldNames.add(oldName);
+      }
+    }
+    const nodeNames = regeneratedNodeNames(
+      bodyNodes,
       classMembers,
-      placements,
-      "pascal"
+      keptMembers
     );
-    const dialogueBindingNames = new Map(
-      dialogueLinks.map((link) => [
-        stringField(link, "valueId"),
-        stringField(link, "sourceName")
-      ])
+    const dialogueLinks = regenerateBindingSourceNames(
+      links,
+      classMembers,
+      keptMembers,
+      placements
     );
-    const functionNames = regeneratedSourceFunctionNames(nodes, classMembers);
-    const nextDialogue = rewriteFunctionSourceNames(
-      { ...dialogue, sourceName: className, linkedValues: dialogueLinks },
-      functionNames
+    const functionNames = allocateSourceFunctionNames(
+      functions,
+      classMembers,
+      keptMembers
     );
-    result.set(recordKey(dialogueRecord), {
-      ...dialogueRecord,
-      data: nextDialogue
+    const namesByOldName = /* @__PURE__ */ new Map();
+    const dialogueNamesByValueId = /* @__PURE__ */ new Map();
+    links.forEach((link, index) => {
+      const name = stringField(dialogueLinks[index], "sourceName");
+      dialogueNamesByValueId.set(stringField(link, "valueId"), name);
+      const oldName = optionalString2(link.sourceName);
+      if (oldName !== null) namesByOldName.set(oldName, name);
     });
-    for (const { record: record6, data } of nodeEntries) {
-      const nodeId = stringField(data, "id");
-      const nodeName = nodeNames.get(nodeId) ?? "Trigger";
-      const nodeLinks = regenerateNodeBindingSourceNames(
-        data.linkedValues,
-        placements,
-        dialogueBindingNames
-      );
+    const nextNodes = nodeEntries.map(({ record: record6, data, links: nodeLinks }) => {
       let nextNode = {
         ...data,
-        sourceName: nodeName,
-        linkedValues: nodeLinks
+        sourceName: nodeNames.get(stringField(data, "id")) ?? "Trigger",
+        linkedValues: regenerateNodeBindingSourceNames(
+          nodeLinks,
+          classMembers,
+          placements,
+          dialogueNamesByValueId,
+          ambiguousOldNames,
+          namesByOldName
+        )
       };
       if (data.type === 1) nextNode = regenerateTextChildren(nextNode);
       if (data.type === 3) nextNode = regenerateConditionOutcomes(nextNode);
-      nextNode = rewriteFunctionSourceNames(nextNode, functionNames);
-      result.set(recordKey(record6), { ...record6, data: nextNode });
+      return { record: record6, data: nextNode };
+    });
+    const renames = new Map(
+      [...namesByOldName].filter(([oldName, name]) => oldName !== name)
+    );
+    result.set(recordKey(dialogueRecord), {
+      ...dialogueRecord,
+      data: rewriteSourceReferences(
+        { ...dialogue, sourceName: className, linkedValues: dialogueLinks },
+        functionNames,
+        renames
+      )
+    });
+    for (const { record: record6, data } of nextNodes) {
+      result.set(recordKey(record6), {
+        ...record6,
+        data: rewriteSourceReferences(data, functionNames, renames)
+      });
     }
   });
   for (const record6 of live.filter(
@@ -59780,23 +59855,54 @@ function regenerateDialogueSourceNamesV4(records2) {
     if (functionNames.size === 0) continue;
     result.set(recordKey(record6), {
       ...record6,
-      data: rewriteFunctionSourceNames(data, functionNames)
+      data: rewriteSourceReferences(data, functionNames, /* @__PURE__ */ new Map())
     });
   }
   return result;
 }
-function regeneratedNodeNames(nodes, triggerId, allocator) {
+function claimKeptNames(allocator, entries) {
+  const result = /* @__PURE__ */ new Map();
+  for (const [key, name] of entries) {
+    if (result.has(key)) continue;
+    const kept = keptSourceName(name);
+    if (kept !== null) result.set(key, allocator.claim(kept));
+  }
+  return result;
+}
+function keptSourceName(value) {
+  if (!isDialogueSourceIdentifier(value)) return null;
+  return isDefaultDialogueSourceName(value) ? null : value;
+}
+function isDefaultDialogueSourceName(value) {
+  return /^(?:Dialogue|Node|Option|Outcome|Value)_[0-9a-f_]{8,}$/iu.test(value) || /^NeoFunction_[0-9a-f]{16,}$/iu.test(value) || /^(?:Actions?|Conditions?|Dialogue|Node|Option|Outcome|Text|TextValue|Value)[0-9]+(?:_[0-9]+)?$/iu.test(
+    value
+  );
+}
+function linkedValueRecords(rawLinks, owner) {
+  if (!Array.isArray(rawLinks)) return [];
+  return rawLinks.map((rawLink, index) => {
+    if (!isObjectRecord2(rawLink)) {
+      throw new Error(`${owner} linked value ${index} is not an object.`);
+    }
+    if (typeof rawLink.valueId !== "string") {
+      throw new Error(`${owner} linked value ${index} has no valueId.`);
+    }
+    return rawLink;
+  });
+}
+function regeneratedNodeNames(bodyNodes, allocator, kept) {
   const result = /* @__PURE__ */ new Map();
-  if (triggerId !== null) result.set(triggerId, "Trigger");
-  const bodyNodes = orderedBodyNodes(nodes, triggerId);
   const descriptors = bodyNodes.map((node) => ({
-    node,
     id: stringField(node, "id"),
     displayName: optionalMeaningfulString(node.name),
     kind: dialogueNodeKindName(node.type)
   }));
   for (const descriptor of descriptors) {
-    if (descriptor.displayName === null) continue;
+    const keptName = kept.get(`node:${descriptor.id}`);
+    if (keptName !== void 0) result.set(descriptor.id, keptName);
+  }
+  for (const descriptor of descriptors) {
+    if (result.has(descriptor.id) || descriptor.displayName === null) continue;
     result.set(
       descriptor.id,
       allocator.claim(
@@ -59816,111 +59922,79 @@ function regeneratedNodeNames(nodes, triggerId, allocator) {
   }
   return result;
 }
-function regenerateBindingSourceNames(rawLinks, allocator, placements, casing) {
-  if (!Array.isArray(rawLinks)) return [];
-  return rawLinks.map((rawLink, index) => {
-    if (!isObjectRecord2(rawLink) || typeof rawLink.valueId !== "string") {
-      throw new Error(`Dialogue linked value ${index} is malformed.`);
-    }
-    const preferred = placements.preferredBindingName(
-      rawLink.valueId,
-      optionalString2(rawLink.declaredTypeName) ?? `value${index + 1}`,
-      casing
+function regenerateBindingSourceNames(links, allocator, kept, placements) {
+  return links.map((link, index) => {
+    const valueId = stringField(link, "valueId");
+    const sourceName = kept.get(`value:${valueId}`) ?? allocator.claim(
+      placements.preferredBindingName(
+        valueId,
+        optionalString2(link.declaredTypeName) ?? `value${index + 1}`,
+        "pascal"
+      )
     );
-    return { ...rawLink, sourceName: allocator.claim(preferred) };
+    return { ...link, sourceName };
   });
 }
-function regenerateNodeBindingSourceNames(rawLinks, placements, dialogueNamesByValueId) {
-  if (!Array.isArray(rawLinks)) return [];
-  const links = rawLinks.map((rawLink, index) => {
-    if (!isObjectRecord2(rawLink) || typeof rawLink.valueId !== "string") {
-      throw new Error(`Dialogue-node linked value ${index} is malformed.`);
-    }
-    return rawLink;
-  });
-  const inheritedValueIds = new Set(
-    links.flatMap((link) => {
-      const valueId = stringField(link, "valueId");
-      return dialogueNamesByValueId.has(valueId) ? [valueId] : [];
-    })
-  );
-  const allocator = new DialogueSourceNameAllocator(
-    [...dialogueNamesByValueId].filter(([valueId]) => !inheritedValueIds.has(valueId)).map(([, name]) => name)
-  );
-  const namesByValueId = /* @__PURE__ */ new Map();
-  const allocate = (link, index) => {
+function regenerateNodeBindingSourceNames(links, allocator, placements, dialogueNamesByValueId, ambiguousOldNames, namesByOldName) {
+  return links.map((link, index) => {
+    if (keptSourceName(link.sourceName) !== null) return link;
     const valueId = stringField(link, "valueId");
-    namesByValueId.set(
-      valueId,
-      allocator.claim(
-        placements.preferredBindingName(
-          valueId,
-          optionalString2(link.declaredTypeName) ?? `value${index + 1}`,
-          "camel"
-        )
+    const oldName = optionalString2(link.sourceName);
+    const mapped = oldName === null ? void 0 : namesByOldName.get(oldName);
+    const inherited = oldName !== null && ambiguousOldNames.has(oldName) ? void 0 : dialogueNamesByValueId.get(valueId);
+    const sourceName = mapped ?? inherited ?? allocator.claim(
+      placements.preferredBindingName(
+        valueId,
+        optionalString2(link.declaredTypeName) ?? `value${index + 1}`,
+        "camel"
       )
     );
-  };
-  links.forEach((link, index) => {
-    if (dialogueNamesByValueId.has(stringField(link, "valueId"))) {
-      allocate(link, index);
-    }
+    if (oldName !== null) namesByOldName.set(oldName, sourceName);
+    return { ...link, sourceName };
   });
-  links.forEach((link, index) => {
-    if (!dialogueNamesByValueId.has(stringField(link, "valueId"))) {
-      allocate(link, index);
-    }
-  });
-  return links.map((link) => ({
-    ...link,
-    sourceName: requiredMap(
-      namesByValueId,
-      stringField(link, "valueId"),
-      "dialogue-node linked value"
-    )
-  }));
 }
 function regenerateTextChildren(node) {
   if (!isObjectRecord2(node.optionSettings)) return node;
   if (!Array.isArray(node.optionSettings.options)) return node;
-  const allocator = new DialogueSourceNameAllocator();
-  const options = node.optionSettings.options.map((rawOption, index) => {
-    if (!isObjectRecord2(rawOption)) return rawOption;
-    return {
-      ...rawOption,
-      sourceName: allocator.claim(
-        dialogueSourceNameFromDisplayName(
-          optionalMeaningfulString(rawOption.name),
-          `Option${index + 1}`
-        )
-      )
-    };
-  });
   return {
     ...node,
-    optionSettings: { ...node.optionSettings, options }
+    optionSettings: {
+      ...node.optionSettings,
+      options: regenerateEntrySourceNames(
+        node.optionSettings.options,
+        "Option"
+      )
+    }
   };
 }
 function regenerateConditionOutcomes(node) {
   if (!Array.isArray(node.outcomes)) return node;
-  const allocator = new DialogueSourceNameAllocator();
   return {
     ...node,
-    outcomes: node.outcomes.map((rawOutcome, index) => {
-      if (!isObjectRecord2(rawOutcome)) return rawOutcome;
-      return {
-        ...rawOutcome,
-        sourceName: allocator.claim(
-          dialogueSourceNameFromDisplayName(
-            optionalMeaningfulString(rawOutcome.name),
-            `Outcome${index + 1}`
-          )
-        )
-      };
-    })
+    outcomes: regenerateEntrySourceNames(node.outcomes, "Outcome")
   };
 }
-function regeneratedSourceFunctionNames(nodes, allocator) {
+function regenerateEntrySourceNames(entries, fallback) {
+  const allocator = new DialogueSourceNameAllocator();
+  const kept = claimKeptNames(
+    allocator,
+    entries.map((entry, index) => [
+      String(index),
+      isObjectRecord2(entry) ? entry.sourceName : null
+    ])
+  );
+  return entries.map((entry, index) => {
+    if (!isObjectRecord2(entry)) return entry;
+    const sourceName = kept.get(String(index)) ?? allocator.claim(
+      dialogueSourceNameFromDisplayName(
+        optionalMeaningfulString(entry.name),
+        `${fallback}${index + 1}`
+      )
+    );
+    return { ...entry, sourceName };
+  });
+}
+function sourceFunctionUses(nodes) {
   const functions = /* @__PURE__ */ new Map();
   const register = (raw, role) => {
     if (!isObjectRecord2(raw)) return;
@@ -59962,7 +60036,7 @@ function regeneratedSourceFunctionNames(nodes, allocator) {
       registerConditions(option.settings.selectableConditions);
     }
   }
-  return allocateSourceFunctionNames(functions, allocator);
+  return functions;
 }
 function regeneratedGroupFunctionNames(rawConditions) {
   const functions = /* @__PURE__ */ new Map();
@@ -59977,40 +60051,50 @@ function regeneratedGroupFunctionNames(rawConditions) {
       });
     }
   }
-  return allocateSourceFunctionNames(
-    functions,
-    new DialogueSourceNameAllocator()
+  const allocator = new DialogueSourceNameAllocator();
+  const kept = claimKeptNames(
+    allocator,
+    [...functions].map(([id2, fn]) => [`function:${id2}`, fn.existingName])
   );
+  return allocateSourceFunctionNames(functions, allocator, kept);
 }
-function allocateSourceFunctionNames(functions, allocator) {
+function allocateSourceFunctionNames(functions, allocator, kept) {
   const result = /* @__PURE__ */ new Map();
   const roleCounts = /* @__PURE__ */ new Map();
   for (const [id2, fn] of functions) {
-    const keepExisting = fn.existingName !== null && isDialogueSourceIdentifier(fn.existingName) && !isMachineGeneratedDialogueSourceName(fn.existingName);
     const ordinal = (roleCounts.get(fn.role) ?? 0) + 1;
     roleCounts.set(fn.role, ordinal);
-    const preferred = keepExisting ? fn.existingName : `${fn.role}${ordinal}`;
-    result.set(id2, allocator.claim(preferred));
+    result.set(
+      id2,
+      kept.get(`function:${id2}`) ?? allocator.claim(`${fn.role}${ordinal}`)
+    );
   }
   return result;
 }
-function rewriteFunctionSourceNames(value, names) {
+function rewriteSourceReferences(value, functionNames, bindingRenames) {
   if (Array.isArray(value)) {
-    return value.map((entry) => rewriteFunctionSourceNames(entry, names));
+    return value.map(
+      (entry) => rewriteSourceReferences(entry, functionNames, bindingRenames)
+    );
   }
   if (!isObjectRecord2(value)) return value;
   const result = Object.fromEntries(
     Object.entries(value).map(([key, entry]) => [
       key,
-      rewriteFunctionSourceNames(entry, names)
+      renamedBindingReference(key, entry, bindingRenames) ?? rewriteSourceReferences(entry, functionNames, bindingRenames)
     ])
   );
   const id2 = optionalString2(value.sourceFunctionId);
-  const name = id2 === null ? null : names.get(id2);
+  const name = id2 === null ? null : functionNames.get(id2);
   return name === void 0 || name === null ? result : { ...result, sourceFunctionName: name };
 }
-function isMachineGeneratedDialogueSourceName(value) {
-  return /^(?:Dialogue|Node|Option|Outcome|Value)_[0-9a-f_]{8,}$/iu.test(value) || /^NeoFunction_[0-9a-f]{16,}$/iu.test(value) || /^(?:Action|Condition|TextValue)[0-9]+$/u.test(value);
+function renamedBindingReference(key, value, renames) {
+  if (typeof value !== "string") return null;
+  if (key === "code") return renameNeoScriptIdentifiers(value, renames);
+  if (key !== "sourcePath" || PERSISTED_VARIABLE_PATH.test(value)) return null;
+  const head = value.split(".", 1)[0];
+  const renamed = renames.get(head);
+  return renamed === void 0 ? value : renamed + value.slice(head.length);
 }
 function dialogueNodeKindName(value) {
   if (value === 1) return "Text";
@@ -60568,7 +60652,7 @@ function recoverableProse(context, textId, rawVariables, owner, nodeBindings, pr
   }
 }
 function authoredVariablePath(sourcePath, nodeBindings, dialogueBindings, memberNames) {
-  const persisted = /^(?:ref|linked):([^.]+)(\..+)?$/u.exec(sourcePath);
+  const persisted = PERSISTED_VARIABLE_PATH.exec(sourcePath);
   const lexicalPath = persisted ? (() => {
     const valueId = persisted[1];
     const binding = nodeBindings.get(valueId) ?? dialogueBindings.get(valueId);
@@ -60950,7 +61034,7 @@ function requiredMap(map, id2, label) {
 function quote3(value) {
   return quoteNeoString(value);
 }
-var DIALOGUE_SYSTEM_TYPE_NAMES, ValuePlacementIndex, UniqueNames;
+var PERSISTED_VARIABLE_PATH, DIALOGUE_SYSTEM_TYPE_NAMES, ValuePlacementIndex, UniqueNames;
 var init_dialogue_sources = __esm({
   "src/project-source/dialogue-sources.ts"() {
     "use strict";
@@ -60963,6 +61047,7 @@ var init_dialogue_sources = __esm({
     init_neoscript_source_rewrite();
     init_source_format();
     init_ui_action_source();
+    PERSISTED_VARIABLE_PATH = /^(?:ref|linked):([^.]+)(\..+)?$/u;
     DIALOGUE_SYSTEM_TYPE_NAMES = [
       "Dialogue",
       "Trigger",
@@ -138010,7 +138095,7 @@ import {
 import { dirname as dirname9 } from "node:path";
 async function runPull(workspace, options, progress = spinner("Checking local workspace\u2026")) {
   if (options.reset) {
-    await runResetPull(workspace, progress);
+    await runResetPull(workspace, options.regenerateSourceNames, progress);
     return;
   }
   try {
@@ -138252,18 +138337,18 @@ ${blockingErrors.map((error) => `  ${error.message}`).join("\n")}`
     conflictKeys,
     localStatus,
     destructive,
-    regenerateSourceNames: destructive || options.regenerateSourceNames,
+    regenerateSourceNames: options.regenerateSourceNames,
     changedRecordKeys,
     nextCursor,
     progress
   });
 }
-async function runResetPull(workspace, progress) {
+async function runResetPull(workspace, regenerateSourceNames, progress) {
   progress.update("Pulling project snapshot\u2026");
   try {
     const document = await fetchProjectDocument(workspace);
     const preparation = prepareWorkspaceResetV4(workspace, document, {
-      regenerateSourceNames: true
+      regenerateSourceNames
     });
     progress.update("Downloading project files\u2026");
     const previousRecords = workspace.state.records;
@@ -138277,7 +138362,7 @@ async function runResetPull(workspace, progress) {
     });
     progress.update("Regenerating Neo sources\u2026");
     const reset = resetWorkspaceToProjectSourcesV4(workspace, document, {
-      regenerateSourceNames: true,
+      regenerateSourceNames,
       preparation
     });
     for (const recovery of reset.staticMemberOwnershipRecoveries ?? []) {
@@ -156725,9 +156810,9 @@ ${h("Usage")}
   neo pull ${d("[--force|--reset] [--regenerate-source-names]")}
 
 ${h("Flags")}
-  --force  ${d("Discard local edits, take the current server schema, and regenerate readable dialogue symbols.")}
-  --reset  ${d("Destructively regenerate the entire working copy, binaries, and readable dialogue symbols, even when the sync head is unchanged.")}
-  --regenerate-source-names  ${d("Regenerate readable dialogue symbols during an otherwise normal pull.")}
+  --force  ${d("Discard local edits and take the current server schema.")}
+  --reset  ${d("Destructively regenerate the entire working copy and binaries, even when the sync head is unchanged.")}
+  --regenerate-source-names  ${d("Replace generated default dialogue symbols with readable names.")}
 
 Use ${h("--reset")} to reconstruct every managed ${h(".neo")}/${h(".neoflow")} source file
 and tracked project binary from the authoritative server records.
@@ -156852,7 +156937,7 @@ There is no --keep-current: preserving current semantic state defines flatten.
 async function main() {
   const args = parseArgs(process.argv.slice(2));
   if (args.command === "--version") {
-    console.log("0.67.2");
+    console.log("0.67.3");
     return;
   }
   if (args.command === null || args.command === "help" || args.command === "--help" || args.command === "-h") {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neocompose/cli",
-  "version": "0.67.2",
+  "version": "0.67.3",
   "description": "Neo Compose native project-source CLI with bidirectional sync.",
   "license": "MIT",
   "type": "module",

package/skills/neocompose-cli/SKILL.md

@@ -9,7 +9,7 @@ description: >-
   `@neocompose/cli` or `node cli/bin/neo.mjs` in the neo-compose repository.
 ---
 
-<!-- reviewed-through-cli: 0.67.2 -->
+<!-- reviewed-through-cli: 0.67.3 -->
 
 # Neo Compose CLI
 
@@ -91,10 +91,10 @@ upgrader. Reconstruct an authoritative format-4 checkout with `neo init`.
 
 For an existing checkout:
 
-- `neo pull --reset` regenerates canonical source, names, and managed binaries.
+- `neo pull --reset` regenerates canonical source and managed binaries.
 - `neo pull --force` discards local edits in favor of the server.
-- `neo pull --regenerate-source-names` refreshes readable source names while
-  retaining normal merge behavior.
+- `neo pull --regenerate-source-names` replaces generated default dialogue
+  names with readable ones, keeps chosen names, and rewrites references.
 
 Use reset and force only when their destructive effect is intended.
 

package/skills/neocompose-cli/references/cli-development.md

@@ -110,7 +110,7 @@ wrappers.
 The marker near the top of `SKILL.md` must exactly match the package version:
 
 ```html
-<!-- reviewed-through-cli: 0.67.2 -->
+<!-- reviewed-through-cli: 0.67.3 -->
 ```
 
 The quoted version above is checked too, so this instruction cannot go stale

package/skills/neocompose-cli/references/commands-and-sync.md

@@ -29,11 +29,11 @@ neo push
 neo push --dry-run --force-recompile
 ```
 
-Use `neo pull --regenerate-source-names` to refresh readable naming while
-retaining normal merge behavior. Use `--reset` to regenerate canonical source
-and managed binaries. Reset retains declaration file grouping already recorded
-by the workspace, while declarations with no prior placement use the canonical
-per-declaration layout. Use `--force` only to discard local edits for the server
+Use `neo pull --regenerate-source-names` to replace generated default dialogue
+names with readable ones. It keeps chosen names and rewrites references. Use
+`--reset` to regenerate canonical source and managed binaries. Reset retains
+declaration file grouping already recorded by the workspace, while
+declarations with no prior placement use the canonical per-declaration layout. Use `--force` only to discard local edits for the server
 version. Normal pulls persist a transaction cursor and fetch only changed
 records. If the remote head is unchanged, pull preserves the local source
 without compiling it; use `neo status` to inspect local edits and diagnostics.