@neocompose/cli 0.25.0 → 0.25.2

package/CHANGELOG.md

@@ -1,5 +1,53 @@
 # Changelog
 
+## [0.25.2] - 2026-08-09
+
+### Added
+
+- `neo doctor` now audits the pulled document itself, not just this working
+  copy's authoring contracts. A project can be perfectly clean to push and
+  still hold malformed records, and the first audit catches value rows whose
+  storage partition disagrees with their placement parent. `--json` carries a
+  `repair` entry per finding, which is what lets the matching repair touch only
+  the affected records instead of scanning a project to rediscover them.
+
+## [0.25.1] - 2026-08-09
+
+### Changed
+
+- Stop `First`, `FirstOrDefault`, and collection `Contains` scans as soon as their result is known. Terminal scans now resolve and charge only visited entries, preserve list/dictionary order and value-reference identity, and avoid intermediate entry arrays (P55).
+
+### Fixed
+
+- Seed the owned rows for a field a newly declared member adds to a
+  row-backed class default, instead of refusing the push with "no existing
+  owned value row". Adding an entry to a row-backed _list_ default has always
+  minted its rows; a class field now takes the same path, so replacing a class
+  member (`Name = "Blue"` → `Kind = .Blue` across every default that sets it)
+  pushes without editing each default in the web editor first. An `@id` on the
+  new field is honoured when it names an existing row and, when it does not,
+  held to the same UUID v4 identity rule list entries follow.
+- Carry only the new rows and the ancestors that reach them in a member value
+  seed. Naming every row the pass touched made the seed depend on which
+  constructions the materialization cache preserved that run — so a push and
+  its own trusted re-lowering disagreed — and handed back rows stripped of the
+  `constructorArgs` a seed row cannot carry, which then failed to project back
+  to source. Pushing a new row anywhere under `root.Assets` previously failed
+  with "Authored value row … is missing memberId".
+- Drop a stored class body key whose member the push deletes, instead of
+  carrying it into a schema that no longer has it while the same push
+  tombstones the row it names.
+- Treat a member value seed as pushable work on its own. Adding a row to an
+  unordered list moves no stored record — membership is the new row's
+  `containerId` — so `neo status` and `neo push` reported a clean working copy
+  and silently dropped it. `neo status` now reports pending seeds too.
+- Accept a stored row that spells "no class" as an explicit `null`, and adopt
+  the declared storage partition for an unstamped row reached through its
+  owning slot, in constructed static value graph validation. Rows materialized
+  before their partition was stamped (object-tree `Enabled`, P41 §4.3) sit in
+  main under a partitioned parent and failed a push over data it never wrote. A
+  row already stamped for a different partition is still rejected.
+
 ## [0.25.0] - 2026-08-07
 
 ### Added

package/dist/neo.mjs

@@ -61613,11 +61613,16 @@ function evalFunction(fn, scope, ctx) {
         }
         return c.includes(target);
       }
-      if (Array.isArray(c) && typeof target === "string" && c.includes(target)) {
-        return true;
-      }
-      const entries = collectionEntries(c, ctx);
-      return entries.some((e) => jsEqual(e, target));
+      const targetReferenceId = typeof target === "string" ? target : findKnownRowIdByValueReference(target, ctx);
+      let containsResolvedEntry = false;
+      iterateCollection(c, ctx, (entry, _key, valueId) => {
+        if (valueId !== null && valueId === targetReferenceId || jsEqual(entry, target)) {
+          containsResolvedEntry = true;
+          return 1 /* Break */;
+        }
+        return 0 /* Continue */;
+      });
+      return containsResolvedEntry;
     }
     case "decimalOp" /* decimalOp */: {
       const info = fn.info;
@@ -61772,6 +61777,7 @@ function evalFunction(fn, scope, ctx) {
             out[String(key)] = valueId ?? entry;
           }
         }
+        return 0 /* Continue */;
       });
       return out;
     }
@@ -61783,10 +61789,9 @@ function evalFunction(fn, scope, ctx) {
       const sentinel = /* @__PURE__ */ Symbol("not-found");
       let found = sentinel;
       iterateCollection(c, ctx, (entry, key) => {
-        if (found !== sentinel) return;
         if (!innerFn) {
           found = entry;
-          return;
+          return 1 /* Break */;
         }
         consumeBudget(ctx, "workUnits", 1, "work unit");
         const innerScope = pushParams(
@@ -61803,7 +61808,9 @@ function evalFunction(fn, scope, ctx) {
         );
         if (result.kind === "return" && result.value === true) {
           found = entry;
+          return 1 /* Break */;
         }
+        return 0 /* Continue */;
       });
       if (found !== sentinel) return found;
       if (fn.type === "first" /* first */) {
@@ -61841,6 +61848,7 @@ function evalFunction(fn, scope, ctx) {
           );
           out.push(result.value);
         }
+        return 0 /* Continue */;
       });
       return out;
     }
@@ -64304,6 +64312,7 @@ function snapshotCollectionMembership(collection, ctx) {
   const valid = forEachRawCollectionEntry(collection, ({ raw }) => {
     consumeBudget(ctx, "collectionVisits", 1, "collection visit");
     membership.push(raw);
+    return 0 /* Continue */;
   });
   if (valid) return membership;
   throw new NSGetterRuntimeError(
@@ -64314,21 +64323,23 @@ function forEachRawCollectionEntry(c, callback) {
   if (Array.isArray(c)) {
     for (let key = 0; key < c.length; key += 1) {
       const raw = c[key];
-      callback({
+      const control = callback({
         raw,
         key,
         valueId: typeof raw === "string" ? raw : null
       });
+      if (control === 1 /* Break */) break;
     }
     return true;
   }
   if (typeof c === "object" && c !== null) {
     for (const [key, raw] of Object.entries(c)) {
-      callback({
+      const control = callback({
         raw,
         key,
         valueId: typeof raw === "string" ? raw : null
       });
+      if (control === 1 /* Break */) break;
     }
     return true;
   }
@@ -64339,6 +64350,7 @@ function collectionEntries(c, ctx) {
   forEachRawCollectionEntry(c, ({ raw }) => {
     consumeBudget(ctx, "collectionVisits", 1, "collection visit");
     entries.push(resolveValueIfId(raw, ctx));
+    return 0 /* Continue */;
   });
   return entries;
 }
@@ -64346,7 +64358,7 @@ function iterateCollection(c, ctx, callback) {
   forEachRawCollectionEntry(c, ({ raw, key, valueId }) => {
     consumeBudget(ctx, "collectionVisits", 1, "collection visit");
     const entry = resolveValueIfId(raw, ctx);
-    callback(entry, key, valueId);
+    return callback(entry, key, valueId);
   });
 }
 function pushParams(parent, parameters, positional, isList) {
@@ -78101,13 +78113,16 @@ var init_project_version_static_value_writes = __esm({
           );
         }
         const normalizedExpected = normalizeMapKey(args.expectedMapKey);
+        const normalizedStored = normalizeMapKey(value.mapKey);
         if (this.createdValueIds.has(value.id)) {
           this.visitedCreatedValueIds.add(value.id);
           if (normalizedExpected === null) delete value.mapKey;
           else value.mapKey = normalizedExpected;
-        } else if (normalizeMapKey(value.mapKey) !== normalizedExpected) {
+        } else if (normalizedStored === null && normalizedExpected !== null) {
+          value.mapKey = normalizedExpected;
+        } else if (normalizedStored !== normalizedExpected) {
           throw new Error(
-            `${args.path} cannot bind value "${value.id}" from storage partition ${JSON.stringify(normalizeMapKey(value.mapKey) ?? "main")}; expected ${JSON.stringify(normalizedExpected ?? "main")}.`
+            `${args.path} cannot bind value "${value.id}" from storage partition ${JSON.stringify(normalizedStored ?? "main")}; expected ${JSON.stringify(normalizedExpected ?? "main")}.`
           );
         }
         if (args.graphValueIds.has(value.id)) {
@@ -78144,7 +78159,7 @@ var init_project_version_static_value_writes = __esm({
           }
           return;
         }
-        if (member.kind !== 7 /* Class */ && value.classId !== void 0) {
+        if (member.kind !== 7 /* Class */ && value.classId !== void 0 && value.classId !== null) {
           throw new Error(
             `${path} value "${value.id}" has classId but the member is not Class.`
           );
@@ -86434,6 +86449,7 @@ function buildValueLowerContext(state, manifest, options = {}) {
     pendingValues: registry.pendingValues,
     pendingLocalizedTexts: registry.pendingLocalizedTexts,
     loweredMemberIdByValueId: /* @__PURE__ */ new Map(),
+    storedClassSchemaMemberIds: /* @__PURE__ */ new Map(),
     pendingBindingMembersByClassId: registry.pendingBindingMembersByClassId,
     declaredConstructors: declaredConstructorIndex,
     initAuthoredRowIds: seedInitAuthoredRowIds(
@@ -86657,14 +86673,12 @@ function lowerMemberDefaultSourcesV4(state, analysis, manifest, options = {}) {
           (row) => !existingPendingValueIds.has(row.id)
         );
         if (pendingRows.length > 0) {
-          const existingRows = [...context.reconstructed].filter(
-            ([key, record3]) => !existingReconstructedKeys.has(key) && record3.recordKind === "value"
-          ).map(
-            ([, record3]) => staticValueSeedRow(
-              record3.fileFields,
-              context.loweredMemberIdByValueId.get(record3.recordId)
-            )
-          );
+          const existingRows = pendingSeedGraphRows({
+            context,
+            reconstructedBefore: existingReconstructedKeys,
+            pendingRows,
+            rootBody: lowered.value
+          });
           const bindingMembers = [
             ...context.pendingBindingMembersByClassId.values()
           ].filter(
@@ -87247,21 +87261,49 @@ function lowerRowBackedDefault(context, member, backed, baseData3, binding) {
           `Default value ${binding.label}.${assignment.name} is constructor-projected and must be set through its named constructor argument.`
         );
       }
+      const childValueMember = recursivePartialMember(member, childMember);
+      const childSlice = assignmentSlices.get(assignment.name);
       const existingId = isObjectRecord2(baseBody) ? baseBody[assignment.name] : void 0;
-      const childId = typeof existingId === "string" ? existingId : annotatedValue(assignment.value).id;
-      if (childId === null || childId === void 0) {
+      const annotatedId = annotatedValue(assignment.value).id;
+      const storedId = typeof existingId === "string" ? existingId : annotatedId;
+      if (storedId !== null && storedId !== void 0) {
+        if (typeof existingId === "string" || context.state[`value:${storedId}`] !== void 0) {
+          body[assignment.name] = lowerValueRow(
+            context,
+            childValueMember,
+            assignment.value,
+            storedId,
+            binding,
+            environment,
+            childSlice
+          );
+          continue;
+        }
+        if (!isPendingId(storedId) && !isUuidV4Id(storedId)) {
+          context.loweringFailures.push({
+            message: `Default value ${binding.label}.${assignment.name} is annotated @id("${storedId}"), which names no existing row, and a new row's durable identity must be a UUID v4. Fix the id if it meant an existing row, or drop the @id to mint a fresh identity.`,
+            site: referenceSite(binding, assignment.value)
+          });
+        }
+      }
+      const placedId = sourceValueSymbol(context, assignment.value);
+      if (placedId !== null) {
         throw new Error(
-          `Default value ${binding.label}.${assignment.name} has no existing owned value row. Creating new default rows from source is not implemented by this slice.`
+          `Default value ${binding.label}.${assignment.name} cannot place existing value ${placedId} into a new structural slot. Create the nested value inline so the atomic construction transaction can own it.`
         );
       }
-      body[assignment.name] = lowerValueRow(
+      body[assignment.name] = lowerSeedChild(
         context,
-        recursivePartialMember(member, childMember),
+        childValueMember,
         assignment.value,
-        childId,
         binding,
+        `${binding.label}.${assignment.name}`,
+        /* @__PURE__ */ new Map(),
+        /* @__PURE__ */ new Map(),
+        void 0,
         environment,
-        assignmentSlices.get(assignment.name)
+        void 0,
+        childSlice
       );
     }
     return {
@@ -87402,14 +87444,13 @@ function lowerStoredBinding(context, binding, memberValueIds, seeds) {
     );
     if (pendingRows.length > 0) {
       const root = reconstructedOrStateValue(context, valueId);
-      const existingRows = [...context.reconstructed].filter(
-        ([key, record3]) => key !== `value:${valueId}` && !existingReconstructedKeys.has(key) && record3.recordKind === "value"
-      ).map(
-        ([, record3]) => staticValueSeedRow(
-          record3.fileFields,
-          context.loweredMemberIdByValueId.get(record3.recordId)
-        )
-      );
+      const existingRows = pendingSeedGraphRows({
+        context,
+        reconstructedBefore: existingReconstructedKeys,
+        pendingRows,
+        rootBody: root.value,
+        rootValueId: valueId
+      });
       const bindingMembers = [
         ...context.pendingBindingMembersByClassId.values()
       ].filter((pending) => !existingPendingBindingMemberIds.has(pending.id));
@@ -87444,6 +87485,105 @@ function memberValueId(memberId) {
 function reconstructedOrStateValue(context, valueId) {
   return context.reconstructed.get(`value:${valueId}`)?.fileFields ?? valueBase(context, valueId);
 }
+function pendingSeedGraphRows(args) {
+  const candidates = /* @__PURE__ */ new Map();
+  for (const [key, record3] of args.context.reconstructed) {
+    if (args.reconstructedBefore.has(key)) continue;
+    if (record3.recordKind !== "value") continue;
+    if (record3.recordId === args.rootValueId) continue;
+    candidates.set(record3.recordId, record3.fileFields);
+  }
+  const pendingIds = new Set(args.pendingRows.map((row) => row.id));
+  const bodies = /* @__PURE__ */ new Map();
+  for (const [id2, fields] of candidates) bodies.set(id2, fields.value);
+  for (const row of args.pendingRows) bodies.set(row.id, row.value);
+  const containedIds = /* @__PURE__ */ new Map();
+  const addContained = (containerId, id2) => {
+    if (typeof containerId !== "string") return;
+    const siblings = containedIds.get(containerId);
+    if (siblings === void 0) containedIds.set(containerId, [id2]);
+    else siblings.push(id2);
+  };
+  for (const [id2, fields] of candidates) addContained(fields.containerId, id2);
+  for (const row of args.pendingRows) addContained(row.containerId, row.id);
+  const collectReferenced = (body, into) => {
+    if (typeof body === "string") {
+      if (bodies.has(body)) into.add(body);
+      return;
+    }
+    if (Array.isArray(body)) {
+      for (const entry of body) collectReferenced(entry, into);
+      return;
+    }
+    if (!isObjectRecord2(body)) return;
+    for (const entry of Object.values(body)) collectReferenced(entry, into);
+  };
+  const childIds = (id2) => {
+    const children = new Set(containedIds.get(id2) ?? []);
+    collectReferenced(bodies.get(id2), children);
+    children.delete(id2);
+    return children;
+  };
+  const reachesPending = /* @__PURE__ */ new Map();
+  const visit = (id2) => {
+    const settled = reachesPending.get(id2);
+    if (settled !== void 0) return settled;
+    reachesPending.set(id2, false);
+    let reaches = pendingIds.has(id2);
+    for (const childId of childIds(id2)) {
+      if (visit(childId)) reaches = true;
+    }
+    reachesPending.set(id2, reaches);
+    return reaches;
+  };
+  const roots = new Set(
+    args.rootValueId === void 0 ? [] : containedIds.get(args.rootValueId) ?? []
+  );
+  collectReferenced(args.rootBody, roots);
+  for (const id2 of roots) visit(id2);
+  const rows = [];
+  for (const [id2, fields] of candidates) {
+    if (reachesPending.get(id2) !== true) continue;
+    rows.push(
+      staticValueSeedRow(fields, args.context.loweredMemberIdByValueId.get(id2))
+    );
+  }
+  return rows;
+}
+function retainedStoredClassBody(context, storedClassId, baseBody) {
+  const storedMemberIds = storedClassSchemaMemberIds(context, storedClassId);
+  const body = {};
+  for (const [key, childId] of Object.entries(baseBody)) {
+    const storedMemberId = storedMemberIds.get(key);
+    if (storedMemberId !== void 0 && !context.members.has(storedMemberId)) {
+      continue;
+    }
+    body[key] = childId;
+  }
+  return body;
+}
+function storedClassSchemaMemberIds(context, classId) {
+  const cached = context.storedClassSchemaMemberIds.get(classId);
+  if (cached !== void 0) return cached;
+  const memberIds = /* @__PURE__ */ new Map();
+  let current = classId;
+  const visited = /* @__PURE__ */ new Set();
+  while (current !== null && !visited.has(current)) {
+    visited.add(current);
+    const data = stateData(context, "class", current);
+    if (data === null) break;
+    if (isObjectRecord2(data.schema)) {
+      for (const [key, memberId] of Object.entries(data.schema)) {
+        if (typeof memberId === "string" && !memberIds.has(key)) {
+          memberIds.set(key, memberId);
+        }
+      }
+    }
+    current = stringOrNull(data.extendsClassId);
+  }
+  context.storedClassSchemaMemberIds.set(classId, memberIds);
+  return memberIds;
+}
 function staticValueSeedRow(value, loweredMemberId) {
   const id2 = stringOrNull(value.id);
   if (id2 === null) throw new Error("Authored value row is missing id.");
@@ -88195,7 +88335,11 @@ function lowerClassValue(context, member, expression, base, source, outerEnviron
     String(base.id ?? member.name)
   );
   const baseBody = isObjectRecord2(base.value) ? base.value : {};
-  const body = { ...baseBody };
+  const body = retainedStoredClassBody(
+    context,
+    currentClassId,
+    baseBody
+  );
   const assignmentSlices = objectInitializerSlices(authoredSlice);
   if (materializedConstruction !== "preserve") {
     lowerConstructorProjections(
@@ -96237,6 +96381,181 @@ var init_scaffold = __esm({
   }
 });
 
+// src/project-source/project-integrity.ts
+function auditProjectIntegrity(workspace) {
+  const records2 = workspace.state.records;
+  const values = collectValueRows(records2);
+  const placements = collectPlacements(values);
+  const memberIdBySchemaKey = collectClassSchemas(records2);
+  const storageKeyByMemberId = collectMemberStorageKeys(records2);
+  const findings = [];
+  for (const value of values.values()) {
+    const placement = placements.get(value.id);
+    if (placement === void 0) continue;
+    const declaration = childStorageKeyDeclaration({
+      placement,
+      memberIdBySchemaKey,
+      storageKeyByMemberId
+    });
+    if (declaration === null) continue;
+    const expected = resolveMapKeyForCreatedValue({
+      declaration,
+      parentMapKey: placement.parent.mapKey,
+      parentClassId: placement.parent.classId ?? void 0
+    });
+    const normalizedExpected = normalizePartition(expected);
+    const normalizedActual = normalizePartition(value.mapKey);
+    if (normalizedExpected === normalizedActual) continue;
+    findings.push({
+      kind: "value-storage-partition",
+      recordKind: "value",
+      recordId: value.id,
+      message: `Value "${value.id}" is stored in partition ${describePartition(normalizedActual)} but its placement parent "${placement.parent.id}" puts it in ${describePartition(normalizedExpected)}.`,
+      repair: {
+        valueId: value.id,
+        parentValueId: placement.parent.id,
+        schemaKey: placement.schemaKey,
+        actualMapKey: normalizedActual,
+        expectedMapKey: normalizedExpected
+      }
+    });
+  }
+  return findings.sort(
+    (left, right) => left.recordId.localeCompare(right.recordId)
+  );
+}
+function childStorageKeyDeclaration(args) {
+  const { placement } = args;
+  if (placement.schemaKey === UNORDERED_MEMBERSHIP_KEY) {
+    return normalizeStorageKeyDeclaration(void 0);
+  }
+  const parentClassId = placement.parent.classId;
+  if (parentClassId === null) return null;
+  const memberId = args.memberIdBySchemaKey.get(parentClassId)?.get(placement.schemaKey);
+  if (memberId === void 0) return null;
+  const declaration = args.storageKeyByMemberId.get(memberId);
+  if (declaration === void 0) return null;
+  return declaration;
+}
+function collectValueRows(records2) {
+  const values = /* @__PURE__ */ new Map();
+  for (const record3 of Object.values(records2)) {
+    if (record3.recordKind !== "value") continue;
+    const data = record3.data;
+    if (!isObjectRecord2(data)) continue;
+    values.set(record3.recordId, {
+      id: record3.recordId,
+      classId: typeof data.classId === "string" ? data.classId : null,
+      mapKey: typeof data.mapKey === "string" ? data.mapKey : null,
+      containerId: typeof data.containerId === "string" ? data.containerId : null,
+      value: data.value
+    });
+  }
+  return values;
+}
+function collectPlacements(values) {
+  const placements = /* @__PURE__ */ new Map();
+  const claim = (childId, placement) => {
+    if (values.has(childId) && !placements.has(childId)) {
+      placements.set(childId, placement);
+    }
+  };
+  for (const parent of values.values()) {
+    const body = parent.value;
+    if (isObjectRecord2(body)) {
+      for (const [schemaKey, childId] of Object.entries(body)) {
+        if (typeof childId === "string") claim(childId, { parent, schemaKey });
+      }
+      continue;
+    }
+    if (!Array.isArray(body)) continue;
+    for (const childId of body) {
+      if (typeof childId === "string") {
+        claim(childId, { parent, schemaKey: UNORDERED_MEMBERSHIP_KEY });
+      }
+    }
+  }
+  for (const value of values.values()) {
+    if (value.containerId === null) continue;
+    const container = values.get(value.containerId);
+    if (container === void 0) continue;
+    claim(value.id, { parent: container, schemaKey: UNORDERED_MEMBERSHIP_KEY });
+  }
+  return placements;
+}
+function collectClassSchemas(records2) {
+  const schemas = /* @__PURE__ */ new Map();
+  for (const record3 of Object.values(records2)) {
+    if (record3.recordKind !== "class") continue;
+    const data = record3.data;
+    if (!isObjectRecord2(data) || !isObjectRecord2(data.schema)) continue;
+    const schema = /* @__PURE__ */ new Map();
+    for (const [schemaKey, memberId] of Object.entries(data.schema)) {
+      if (typeof memberId === "string") schema.set(schemaKey, memberId);
+    }
+    schemas.set(record3.recordId, schema);
+  }
+  for (const record3 of Object.values(records2)) {
+    if (record3.recordKind !== "class") continue;
+    const own = schemas.get(record3.recordId);
+    if (own === void 0) continue;
+    const seen = /* @__PURE__ */ new Set([record3.recordId]);
+    let data = record3.data;
+    while (isObjectRecord2(data) && typeof data.extendsClassId === "string") {
+      const parentId = data.extendsClassId;
+      if (seen.has(parentId)) break;
+      seen.add(parentId);
+      for (const [schemaKey, memberId] of schemas.get(parentId) ?? []) {
+        if (!own.has(schemaKey)) own.set(schemaKey, memberId);
+      }
+      const parentRecord = records2[`class:${parentId}`];
+      data = parentRecord?.data;
+    }
+  }
+  return schemas;
+}
+function collectMemberStorageKeys(records2) {
+  const declarations = /* @__PURE__ */ new Map();
+  for (const record3 of Object.values(records2)) {
+    if (record3.recordKind !== "member") continue;
+    let data = record3.data;
+    const seen = /* @__PURE__ */ new Set([record3.recordId]);
+    let declaration;
+    while (isObjectRecord2(data)) {
+      if (typeof data.storageKey === "string" && data.storageKey.length > 0) {
+        declaration = data.storageKey;
+        break;
+      }
+      if (typeof data.extendsMemberId !== "string") break;
+      const parentId = data.extendsMemberId;
+      if (seen.has(parentId)) break;
+      seen.add(parentId);
+      data = records2[`member:${parentId}`]?.data;
+    }
+    declarations.set(
+      record3.recordId,
+      normalizeStorageKeyDeclaration(declaration)
+    );
+  }
+  return declarations;
+}
+function normalizePartition(mapKey) {
+  if (mapKey === null || mapKey.length === 0) return null;
+  return mapKey === MAIN_STORAGE_PARTITION ? null : mapKey;
+}
+function describePartition(mapKey) {
+  return mapKey === null ? `"${MAIN_STORAGE_PARTITION}"` : `"${mapKey}"`;
+}
+var UNORDERED_MEMBERSHIP_KEY;
+var init_project_integrity = __esm({
+  "src/project-source/project-integrity.ts"() {
+    "use strict";
+    init_member_storage_key();
+    init_projection();
+    UNORDERED_MEMBERSHIP_KEY = "(container)";
+  }
+});
+
 // src/neoscript-language-adapter.ts
 function createCliNeoScriptContext(options) {
   const members = [...options.documents.members];
@@ -100954,7 +101273,9 @@ ${blockingErrors.map((error) => `  ${error.message}`).join("\n")}`
     changes: status.changes,
     binaryChanges: status.binaryChanges ?? []
   });
-  if (status.changes.length === 0) return status;
+  if (status.changes.length === 0 && status.authoredValueSeeds.size === 0) {
+    return status;
+  }
   const initConversions = status.initConversions ?? [];
   if (initConversions.length > 0 && options.json !== true) {
     for (const line of describeInitConversions(initConversions)) warn(line);
@@ -101059,7 +101380,7 @@ async function runPush(workspace, options, preparationOverride) {
   const status = candidate.status;
   const local = candidate.preparedLocal;
   preparation?.stop();
-  if (status.changes.length === 0) {
+  if (status.changes.length === 0 && status.authoredValueSeeds.size === 0) {
     if (options.json === true) {
       console.log(
         JSON.stringify({
@@ -101575,7 +101896,7 @@ async function prepareLocalCandidateV4(workspace, options = {}) {
   let sourceHash;
   let preparedLocal = null;
   let documentStatus = status;
-  if (status.changes.length > 0) {
+  if (status.changes.length > 0 || status.authoredValueSeeds.size > 0) {
     try {
       documentStatus = pushOptions.dryRun ? cloneStatusForDryRun(status) : status;
       preparedLocal = await prepareLocalPushArtifactsV4(
@@ -103116,7 +103437,7 @@ var init_registry2 = __esm({
     PROJECT_SCHEMA_CONTRACT = Object.freeze({
       formatVersion: 3,
       contractVersion: "3.9",
-      cliVersion: "0.25.0",
+      cliVersion: "0.25.2",
       projectFileUploadBatchSize: 32,
       documentRecords: {
         member: {
@@ -105898,8 +106219,10 @@ function inspectNeoDoctor(workspace) {
     errors: [],
     compatible: true
   };
+  const findings = auditProjectIntegrity(workspace);
   return {
     ok: formatCompatible && compiler.compatible && extension.compatible && source.compatible && files.compatible,
+    document: { findings, consistent: findings.length === 0 },
     format: {
       current: workspace.config.formatVersion,
       expected: CURRENT_FORMAT_VERSION,
@@ -106158,6 +106481,12 @@ async function runDoctor(workspace, json) {
   console.log(
     `  Files: contract v${String(report.files.contractVersion)}, SHA-256, ${String(report.files.trackedBinaryCount)} tracked binar${report.files.trackedBinaryCount === 1 ? "y" : "ies"}, workspace ${report.files.workspaceReadable ? "readable" : "not readable"}/${report.files.workspaceWritable ? "writable" : "not writable"}`
   );
+  console.log(
+    `  Document: ${report.document.consistent ? "no malformed records" : `${String(report.document.findings.length)} malformed record${report.document.findings.length === 1 ? "" : "s"} (from the last pull)`}`
+  );
+  for (const finding of report.document.findings) {
+    console.log(`  Document defect (${finding.kind}): ${finding.message}`);
+  }
   if (report.compiler.error)
     console.log(`  Compiler error: ${report.compiler.error}`);
   if (report.extension.error)
@@ -106169,6 +106498,11 @@ async function runDoctor(workspace, json) {
   console.log(
     report.ok ? "Project authoring contracts are compatible." : "Project authoring contracts need attention."
   );
+  if (!report.document.consistent) {
+    console.log(
+      `${String(report.document.findings.length)} malformed record${report.document.findings.length === 1 ? "" : "s"} in the pulled document \u2014 see \`--json\` for the repair entries.`
+    );
+  }
   if (!report.ok) process.exitCode = 1;
 }
 var NEO_COMPILER_CONTRACT, NEO_VSCODE_EXTENSION_ID, NEO_VSCODE_EXTENSION_CONTRACT_VERSION, NEO_SOURCE_CONTRACT_VERSION, NEO_FILE_CONTRACT_VERSION, SOURCE_EXTENSIONS, FILE_CAPABILITIES;
@@ -106180,6 +106514,7 @@ var init_doctor = __esm({
     init_workspace_status();
     init_source_diagnostics();
     init_project_documents();
+    init_project_integrity();
     NEO_COMPILER_CONTRACT = "ProjectSourceAnalysisV4";
     NEO_VSCODE_EXTENSION_ID = "neocompose.neo-compose-neoscript";
     NEO_VSCODE_EXTENSION_CONTRACT_VERSION = "0.3.0";
@@ -109156,7 +109491,7 @@ ${h("Working copy")}
   test      ${d("[file-or-dir ...] [-t <pattern>] [--reporter=json] [--outputFile <path>]")}
   status    ${d("[--json]")}                  diff    ${d("[--json]")}
   dev       ${d("[--push]")}                  resolve ${d("[--mine|--theirs]")}
-  doctor    ${d("[--json]")}                  ${d("validate format/compiler/editor/source/file contracts")}
+  doctor    ${d("[--json]")}                  ${d("validate contracts and audit the pulled document")}
 
 ${h("Pending source scaffolds")}
   class     ${d("new <Name> [--abstract]")}
@@ -109811,7 +110146,12 @@ async function main() {
           `${paintChangeKind(binary.action === "create" ? "create" : "update")} project-file bytes ${binary.symbol} (${binary.path}) \u2014 ${binary.action}`
         );
       }
-      if (status.conflictedFiles.length === 0 && status.parseErrors.length === 0 && status.changes.length === 0 && (status.binaryChanges?.length ?? 0) === 0) {
+      if (status.authoredValueSeeds.size > 0) {
+        console.log(
+          `  ${paintChangeKind("create")} ${status.authoredValueSeeds.size} member value seed(s)`
+        );
+      }
+      if (status.conflictedFiles.length === 0 && status.parseErrors.length === 0 && status.changes.length === 0 && status.authoredValueSeeds.size === 0 && (status.binaryChanges?.length ?? 0) === 0) {
         console.log(`${sym.ok} Working copy is clean.`);
       }
       return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neocompose/cli",
-  "version": "0.25.0",
+  "version": "0.25.2",
   "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.25.0 -->
+<!-- reviewed-through-cli: 0.25.2 -->
 
 # Neo Compose CLI
 

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

@@ -41,11 +41,12 @@ Read the relevant specs in full:
 - [P50 loops](https://github.com/ryanbliss/neo-compose-specs/blob/main/new-features/p50-neoscript-for-and-foreach-loops.md)
 - [P51 switch](https://github.com/ryanbliss/neo-compose-specs/blob/main/new-features/p51-neoscript-switch-statements.md)
 - [P52 try/catch](https://github.com/ryanbliss/neo-compose-specs/blob/main/new-features/p52-neoscript-try-catch-blocks.md)
+- [P55 breakable collection iteration](https://github.com/ryanbliss/neo-compose-specs/blob/main/neoscript/p55-breakable-collection-iteration.md)
 - [P60 delegate parameters and selector targeting](https://github.com/ryanbliss/neo-compose-specs/blob/main/new-features/p60-closure-parameters-and-selector-targeting.md)
 - [P61 initializer materialization](https://github.com/ryanbliss/neo-compose-specs/blob/main/new-features/complete/p61-initializer-materialization.md)
 - [P64 NeoScript unit testing and push hooks](https://github.com/ryanbliss/neo-compose-specs/blob/main/new-features/p64-neoscript-unit-testing-and-push-hooks.md)
 
-P38–P44, P47–P52, P60–P61, and the initial P64 test/push-hook vertical slice
+P38–P44, P47–P52, P55, P60–P61, and the initial P64 test/push-hook vertical slice
 are implemented. P45 remains deliberately deferred; do not
 build or teach runtime-child provenance. P46 is a hardening proposal, not an
 authoring capability. P52's document header still says proposed, but try/catch
@@ -82,7 +83,7 @@ wrappers.
 The marker near the top of `SKILL.md` must exactly match the package version:
 
 ```html
-<!-- reviewed-through-cli: 0.25.0 -->
+<!-- reviewed-through-cli: 0.25.2 -->
 ```
 
 The quoted version above is checked too, so this instruction cannot go stale

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

@@ -146,6 +146,13 @@ neo login [--api <url>] [--profile editor|release] [--save-project <id>]
 neo doctor
 ```
 
+`neo doctor` reports two different things. The authoring contracts (format,
+compiler, extension cache, source, files) decide its exit code; the document
+audit below them reports malformed records in the last pull and deliberately
+does not, so a project with records still to repair does not fail the command.
+`neo doctor --json` carries a `repair` entry per finding, which is what a
+targeted repair is handed instead of scanning a project to rediscover them.
+
 The Node CLI talks directly to authenticated Convex APIs through the
 session-gated CAS boundary. Tokens use the OS credential store when available
 and a protected file only as fallback. Use `NEO_COMPOSE_TOKEN` or