@neocompose/cli 0.67.1 → 0.67.3

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # 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.
+- Pull writes `float` setting bounds as the shortest decimal that reads back as the stored float, so `@settings(max: 23.99)` stays `23.99`. Previously it wrote `23.989999771118164`.
+
 ## [0.67.1] - 2026-10-04
 
 - Pull adopts records the server only recompiled into `.neo/state.json` before it reads local sources, even when the same pull also merges authored changes. Previously one authored change anywhere in the pull sent every recompiled record through the merge, which read the stale baseline and failed.

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.1",
+      cliVersion: "0.67.3",
       projectFileUploadBatchSize: 32,
       documentRecords: {
         member: {
@@ -52644,14 +52644,17 @@ function renderExtendsGenericBindings(context, schemaClass2, base) {
   });
   return `<${argumentsValue.join(", ")}>`;
 }
+function settingsBound(value) {
+  return typeof value === "number" ? formatNeoNumber(value) : value;
+}
 function memberSettings(context, member) {
   const settings = [];
   if (member.kind === "string") {
     if (!member.localizable) settings.push("format: .Plain");
     if (member.searchKey) settings.push("searchBy: .MemberKey");
   } else if (member.kind === "int" || member.kind === "float" || member.kind === "decimal") {
-    if (member.min !== null) settings.push(`min: ${member.min}`);
-    if (member.max !== null) settings.push(`max: ${member.max}`);
+    if (member.min !== null) settings.push(`min: ${settingsBound(member.min)}`);
+    if (member.max !== null) settings.push(`max: ${settingsBound(member.max)}`);
     if (member.kind !== "int" && member.decimalPoints !== null) {
       settings.push(`decimalPoints: ${member.decimalPoints}`);
     }
@@ -59688,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";
@@ -59715,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(
@@ -59777,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(
@@ -59813,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);
-    }
-  });
-  links.forEach((link, index) => {
-    if (!dialogueNamesByValueId.has(stringField(link, "valueId"))) {
-      allocate(link, index);
-    }
+    if (oldName !== null) namesByOldName.set(oldName, sourceName);
+    return { ...link, sourceName };
   });
-  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;
@@ -59959,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();
@@ -59974,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";
@@ -60565,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);
@@ -60947,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";
@@ -60960,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",
@@ -131368,9 +131456,25 @@ function workspaceBinaryPathsV4(workspace, local) {
   for (const file of local ?? []) paths.set(file.fileId, file.path);
   return paths;
 }
-function readWorkspaceLayoutStatusV4(workspace) {
+function readWorkspaceLayoutStatusV4(workspace, document) {
+  const records2 = {};
+  for (const [key, server] of document.records) {
+    if (server.deleted) continue;
+    const previous = workspace.state.records[key];
+    records2[key] = {
+      recordKind: server.recordKind,
+      recordId: server.recordId,
+      contentHash: server.contentHash,
+      data: server.data,
+      ...previous?.file === void 0 ? {} : { file: previous.file },
+      ...previous?.projectBinary === void 0 ? {} : { projectBinary: previous.projectBinary }
+    };
+  }
   try {
-    const status = computeWorkspaceStatus2(workspace);
+    const status = computeWorkspaceStatus2({
+      ...workspace,
+      state: { ...workspace.state, records: records2 }
+    });
     const failure = status.parseErrors.find(isBlockingSchemaSourceError);
     if (failure !== void 0) throw failure;
     return status;
@@ -131382,8 +131486,8 @@ function readWorkspaceLayoutStatusV4(workspace) {
     for (const path of listProjectSourceFilesV4(workspace.root)) {
       const content = readFileSync9(path, "utf8");
       if (neoProjectSourceKind(path, content) !== "definition") continue;
-      const document = parseNeoProjectSource(content, "definition", path);
-      if (document.declarations.some(
+      const document2 = parseNeoProjectSource(content, "definition", path);
+      if (document2.declarations.some(
         (declaration) => declaration.kind === "global" && isLocalValueGlobal(declaration)
       )) {
         throw new Error(
@@ -137771,7 +137875,7 @@ import { dirname as dirname8, join as join13, relative as relative7, sep as sep7
 function prepareWorkspaceResetV4(workspace, document, options = {}) {
   const emissionRecords = options.regenerateSourceNames ? regenerateDialogueSourceNamesV4(document.records) : document.records;
   const layoutWorkspace = workspaceForSourceLayoutV4(workspace, document);
-  const status = listProjectSourceFilesV4(workspace.root).length === 0 ? null : readWorkspaceLayoutStatusV4(layoutWorkspace);
+  const status = listProjectSourceFilesV4(workspace.root).length === 0 ? null : readWorkspaceLayoutStatusV4(layoutWorkspace, document);
   const localValues = status?.localValues ?? workspace.state.localValues;
   const emitted = emitProjectDocumentFilesV4(emissionRecords, {
     localValues,
@@ -137991,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 {
@@ -138233,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;
@@ -138258,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 ?? []) {
@@ -138343,7 +138447,7 @@ async function finishFormat4Pull(args) {
   for (const [key, record6] of localStatus?.reconstructed ?? []) {
     if (record6.file != null) recordFiles.set(key, record6.file);
   }
-  const layoutStatus = localStatus ?? (destructive ? readWorkspaceLayoutStatusV4(layoutWorkspace) : null);
+  const layoutStatus = localStatus ?? (destructive ? readWorkspaceLayoutStatusV4(layoutWorkspace, document) : null);
   const localValues = layoutStatus?.localValues ?? workspace.state.localValues;
   const binaryPaths = workspaceBinaryPathsV4(
     workspace,
@@ -156706,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.
@@ -156833,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.1");
+    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.1",
+  "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.1 -->
+<!-- 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.1 -->
+<!-- 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.