@neocompose/cli 0.43.1 → 0.44.0

package/CHANGELOG.md

@@ -1,5 +1,34 @@
 # Changelog
 
+## [0.44.0] - 2026-09-03
+
+### Added
+
+- `neo doctor --fix` deletes the rows the document audit's
+  `unprojected-value-row` findings name: base value rows no emitted file
+  projects and no other record names, which `neo status` reads as CLI-managed
+  loose state and never reports. It lists every orphan root with the number of
+  rows it owns, confirms, then deletes them under two staleness guards: the CAS
+  base the last pull recorded for each row, and the version head each
+  transaction expects from the one before it, starting from the head that pull
+  left. A project that moved on since the pull therefore fails the commit
+  instead of deleting a row that has since gained an owner, and a workspace
+  with no recorded head is refused rather than written blind. Sweeps larger
+  than one transaction go up in batches sized from the shared cost model.
+  `--yes` answers the confirmation for scripted runs; `--fix` has no `--json`
+  form.
+
+### Fixed
+
+- `neo pull` marked a conflicted record in only the one file the emission
+  attributes it to, so a conflict on a member declared by more than one class
+  (system world-layer members such as `Name`) left the sibling declarations
+  unmarked. Resolving the marked file alone then left the declarations
+  disagreeing and the next command refused the workspace. Markers now go in
+  every file that declares the record, and `neo resolve` treats those files as
+  one conflict: it settles them together and refuses a record whose
+  declarations are only partly resolved.
+
 ## [0.43.1] - 2026-09-03
 
 ### Changed

package/dist/neo.mjs

@@ -1043,7 +1043,9 @@ var init_args = __esm({
       "generate-ids",
       "help",
       "passWithNoTests",
-      "no-verify"
+      "no-verify",
+      "fix",
+      "yes"
     ]);
     KNOWN_FLAGS = /* @__PURE__ */ new Set([
       "accept-bump",
@@ -1055,6 +1057,7 @@ var init_args = __esm({
       "dir",
       "dry-run",
       "file",
+      "fix",
       "force",
       "force-recompile",
       "function",
@@ -1087,6 +1090,7 @@ var init_args = __esm({
       "this-value",
       "token-stdin",
       "version",
+      "yes",
       "reporter",
       "outputFile",
       "output-file",
@@ -87879,6 +87883,12 @@ var init_variant_value_graph = __esm({
 });
 
 // ../src/database/project-version-intents.ts
+var project_version_intents_exports = {};
+__export(project_version_intents_exports, {
+  ProjectVersionIntentType: () => ProjectVersionIntentType,
+  createProjectVersionIntent: () => createProjectVersionIntent,
+  isKnownProjectVersionIntentType: () => isKnownProjectVersionIntentType
+});
 function createProjectVersionIntent(type, details) {
   if (details === void 0) {
     return {
@@ -96153,6 +96163,151 @@ function variantRootValueId2(data) {
   if (typeof valueId !== "string" || valueId.length === 0) return null;
   return valueId;
 }
+function planProjectVersionTransaction(changes, atomicGroups) {
+  if (changes.length === 0) {
+    throw new Error("A project-version transaction plan requires changes.");
+  }
+  const changeCosts = changes.map(estimateProjectVersionChangeCost);
+  const groups = normalizeAtomicGroups(changes.length, atomicGroups);
+  let totalEstimatedCost = changeCosts.reduce(
+    addProjectVersionTransactionBudgets,
+    IMMEDIATE_FIXED_COST
+  );
+  if (changes.some(projectVersionChangeCanTriggerWholeGraphValidation)) {
+    totalEstimatedCost = addProjectVersionTransactionBudgets(
+      totalEstimatedCost,
+      WHOLE_GRAPH_VALIDATION_SURCHARGE
+    );
+  }
+  const limitingResource = firstExceededResource(
+    totalEstimatedCost,
+    PROJECT_TRANSACTION_IMMEDIATE_BUDGET
+  );
+  if (limitingResource === null) {
+    return {
+      path: "immediate",
+      limitingResource: null,
+      totalEstimatedCost,
+      chunks: [
+        {
+          firstChangeIndex: 0,
+          changeCount: changes.length,
+          estimatedCost: totalEstimatedCost
+        }
+      ]
+    };
+  }
+  const chunks = [];
+  let firstChangeIndex = 0;
+  let chunkCost = CHUNK_FIXED_COST;
+  let changeCount = 0;
+  for (const group of groups) {
+    const groupCost = changeCosts.slice(group.firstChangeIndex, group.firstChangeIndex + group.changeCount).reduce(addProjectVersionTransactionBudgets, EMPTY_BUDGET);
+    const nativeExceeded = firstExceededResource(
+      addProjectVersionTransactionBudgets(CHUNK_FIXED_COST, groupCost),
+      PROJECT_TRANSACTION_SINGLE_CHANGE_NATIVE_BUDGET
+    );
+    if (nativeExceeded !== null) {
+      throw new Error(
+        `Project-version atomic group starting at change ${group.firstChangeIndex} (${group.changeCount} changes) exceeds the native worker budget for ${nativeExceeded}.`
+      );
+    }
+    const nextCost = addProjectVersionTransactionBudgets(chunkCost, groupCost);
+    const exceeded = firstExceededResource(
+      nextCost,
+      PROJECT_TRANSACTION_WORKER_BUDGET
+    );
+    if (exceeded !== null && changeCount > 0) {
+      chunks.push({ firstChangeIndex, changeCount, estimatedCost: chunkCost });
+      firstChangeIndex = group.firstChangeIndex;
+      changeCount = 0;
+      chunkCost = CHUNK_FIXED_COST;
+    }
+    chunkCost = addProjectVersionTransactionBudgets(chunkCost, groupCost);
+    changeCount += group.changeCount;
+  }
+  if (changeCount > 0) {
+    chunks.push({ firstChangeIndex, changeCount, estimatedCost: chunkCost });
+  }
+  return {
+    path: "asynchronous",
+    limitingResource,
+    totalEstimatedCost,
+    chunks
+  };
+}
+function projectVersionChangeCanTriggerWholeGraphValidation(change) {
+  if (change.recordKind === "enum" || change.recordKind === "member" || change.recordKind === "project" || change.recordKind === "internal-record-relation") {
+    return true;
+  }
+  if (change.recordKind === "class") return change.operation !== "create";
+  if (change.recordKind !== "value") return false;
+  if (change.operation === "delete") return true;
+  return valueChangeCarriesWorldLayerOverride(change);
+}
+function valueChangeCarriesWorldLayerOverride(change) {
+  const nextData = change.nextData;
+  if (nextData === null || typeof nextData !== "object") return false;
+  if (Array.isArray(nextData)) return false;
+  const value = nextData.value;
+  if (value === null || typeof value !== "object") return false;
+  if (Array.isArray(value)) return false;
+  return typeof value.layerOverrideValueId === "string";
+}
+function normalizeAtomicGroups(changeCount, groups) {
+  if (groups === void 0) {
+    return Array.from({ length: changeCount }, (_, firstChangeIndex) => ({
+      firstChangeIndex,
+      changeCount: 1
+    }));
+  }
+  let nextChangeIndex = 0;
+  for (const group of groups) {
+    if (!Number.isSafeInteger(group.firstChangeIndex) || !Number.isSafeInteger(group.changeCount) || group.firstChangeIndex !== nextChangeIndex || group.changeCount < 1) {
+      throw new Error(
+        "Project-version atomic groups must be positive, ordered, and contiguous."
+      );
+    }
+    nextChangeIndex += group.changeCount;
+  }
+  if (nextChangeIndex !== changeCount) {
+    throw new Error(
+      `Project-version atomic groups cover ${nextChangeIndex}/${changeCount} changes.`
+    );
+  }
+  return [...groups];
+}
+function estimateProjectVersionChangeCost(change) {
+  const encoded = canonicalJsonStringify(change);
+  const payloadBytes = new TextEncoder().encode(encoded).byteLength;
+  const hasBase = change.operation !== "create";
+  const counts = changeCountCost(change);
+  return {
+    argumentBytes: payloadBytes + 128,
+    bytesRead: payloadBytes * (hasBase ? 3 : 1) + CHANGE_BYTES_READ_OVERHEAD,
+    bytesWritten: payloadBytes * 2 + CHANGE_BYTES_WRITTEN_OVERHEAD,
+    documentsRead: counts.documentsRead,
+    documentsWritten: counts.documentsWritten,
+    databaseQueries: counts.databaseQueries,
+    // Not metered by Convex: `TransactionMetrics` reports seven dimensions and
+    // this is not one of them, so it cannot be measured the way the others
+    // were. Every index range a change opens is also a database query, so the
+    // measured query count is a strict upper bound on it. Charging exactly
+    // that keeps the dimension a true bound instead of an invented number,
+    // and keeps it dominated by `databaseQueries` rather than silently
+    // becoming the binding constraint on a well-measured plan.
+    indexRanges: counts.databaseQueries,
+    functionsScheduled: 0,
+    scheduledFunctionArgsBytes: 0,
+    returnBytes: payloadBytes + 512
+  };
+}
+function changeCountCost(change) {
+  if (change.recordKind === "value") {
+    return VALUE_CHANGE_COUNT_COSTS[change.operation];
+  }
+  return SCHEMA_CHANGE_COUNT_COSTS[change.operation];
+}
 function addProjectVersionTransactionBudgets(left, right) {
   return {
     argumentBytes: left.argumentBytes + right.argumentBytes,
@@ -96167,7 +96322,15 @@ function addProjectVersionTransactionBudgets(left, right) {
     returnBytes: left.returnBytes + right.returnBytes
   };
 }
-var KIB, MIB, PROJECT_TRANSACTION_CHUNK_PAYLOAD_TARGET_BYTES, PROJECT_TRANSACTION_IMMEDIATE_BUDGET, PROJECT_TRANSACTION_WORKER_BUDGET, PROJECT_TRANSACTION_SINGLE_CHANGE_NATIVE_BUDGET, EMPTY_BUDGET, CHUNK_GRAPH_VALIDATION_RESERVE, CHUNK_FIXED_COST, IMMEDIATE_FIXED_COST, WHOLE_GRAPH_VALIDATION_SURCHARGE, CHANGE_BYTES_READ_OVERHEAD, CHANGE_BYTES_WRITTEN_OVERHEAD;
+function firstExceededResource(cost, target) {
+  for (const resource of Object.keys(
+    EMPTY_BUDGET
+  )) {
+    if (cost[resource] > target[resource]) return resource;
+  }
+  return null;
+}
+var KIB, MIB, PROJECT_TRANSACTION_CHUNK_PAYLOAD_TARGET_BYTES, PROJECT_TRANSACTION_IMMEDIATE_BUDGET, PROJECT_TRANSACTION_WORKER_BUDGET, PROJECT_TRANSACTION_SINGLE_CHANGE_NATIVE_BUDGET, EMPTY_BUDGET, CHUNK_GRAPH_VALIDATION_RESERVE, CHUNK_FIXED_COST, IMMEDIATE_FIXED_COST, WHOLE_GRAPH_VALIDATION_SURCHARGE, VALUE_CHANGE_COUNT_COSTS, SCHEMA_CHANGE_COUNT_COSTS, CHANGE_BYTES_READ_OVERHEAD, CHANGE_BYTES_WRITTEN_OVERHEAD;
 var init_project_version_transaction_planning = __esm({
   "../src/database/project-version-transaction-planning.ts"() {
     "use strict";
@@ -96256,6 +96419,16 @@ var init_project_version_transaction_planning = __esm({
       databaseQueries: 410,
       indexRanges: 410
     };
+    VALUE_CHANGE_COUNT_COSTS = {
+      create: { documentsRead: 3, documentsWritten: 3, databaseQueries: 8 },
+      update: { documentsRead: 6, documentsWritten: 3, databaseQueries: 9 },
+      delete: { documentsRead: 6, documentsWritten: 3, databaseQueries: 14 }
+    };
+    SCHEMA_CHANGE_COUNT_COSTS = {
+      create: { documentsRead: 3, documentsWritten: 5, databaseQueries: 12 },
+      update: { documentsRead: 6, documentsWritten: 5, databaseQueries: 22 },
+      delete: { documentsRead: 6, documentsWritten: 5, databaseQueries: 22 }
+    };
     CHANGE_BYTES_READ_OVERHEAD = 4 * KIB;
     CHANGE_BYTES_WRITTEN_OVERHEAD = 4 * KIB;
   }
@@ -116774,6 +116947,14 @@ var init_api = __esm({
 });
 
 // src/convex.ts
+var convex_exports = {};
+__export(convex_exports, {
+  api: () => api2,
+  createConvexClient: () => createConvexClient,
+  createConvexClientForApi: () => createConvexClientForApi,
+  mintConvexJwt: () => mintConvexJwt,
+  resolveConvexUrl: () => resolveConvexUrl
+});
 import { ConvexHttpClient } from "convex/browser";
 import { Buffer as Buffer2 } from "node:buffer";
 async function mintConvexJwt(apiBaseUrl) {
@@ -117560,6 +117741,7 @@ function acceptSourceEquivalentConflictBases(workspace, mainLocale = workspaceMa
     };
     delete next.conflictServerHash;
     delete next.conflictServerData;
+    delete next.conflictFiles;
     workspace.state.records[key] = next;
     accepted += 1;
   }
@@ -118577,34 +118759,39 @@ async function finishFormat4Pull(args) {
   const serverByPath = new Map(
     (serverResult?.files ?? []).map((file) => [file.path, file])
   );
+  const localRecordFiles = declaringSourcePathsV4(localResult);
+  const serverRecordFiles = serverResult === null ? /* @__PURE__ */ new Map() : declaringSourcePathsV4(serverResult);
   const conflictPaths = /* @__PURE__ */ new Set();
+  const conflictPathsByKey = /* @__PURE__ */ new Map();
   const authoredLocalConflictKeysByPath = /* @__PURE__ */ new Map();
   for (const key of conflictKeys) {
-    const localPath = localResult.recordFiles.get(key);
-    const serverPath = serverResult?.recordFiles.get(key);
-    const path = localPath ?? serverPath ?? workspace.state.records[key]?.file;
-    if (path) conflictPaths.add(path);
-    if (path === void 0 || localPath !== void 0 || serverPath !== void 0) {
-      continue;
+    const paths = [...localRecordFiles.get(key) ?? []];
+    for (const path of serverRecordFiles.get(key) ?? []) {
+      if (!paths.includes(path)) paths.push(path);
+    }
+    if (paths.length === 0) {
+      const previousPath = workspace.state.records[key]?.file;
+      if (previousPath === void 0) continue;
+      paths.push(previousPath);
+      const keys = authoredLocalConflictKeysByPath.get(previousPath) ?? [];
+      keys.push(key);
+      authoredLocalConflictKeysByPath.set(previousPath, keys);
     }
-    const keys = authoredLocalConflictKeysByPath.get(path) ?? [];
-    keys.push(key);
-    authoredLocalConflictKeysByPath.set(path, keys);
+    for (const path of paths) conflictPaths.add(path);
+    conflictPathsByKey.set(key, paths);
   }
   const emittedPaths = /* @__PURE__ */ new Set([
     ...localByPath.keys(),
     ...[...conflictPaths].filter((path) => serverByPath.has(path)),
     ...authoredLocalConflictKeysByPath.keys()
   ]);
-  const localRecordFiles = declaringSourcePathsV4(localResult);
   const rewritePaths = projectSourcePathsRequiringRewriteV4({
     destructive,
     localStatus,
     plans,
     localRecordFiles,
-    serverRecordFiles: serverResult === null ? /* @__PURE__ */ new Map() : declaringSourcePathsV4(serverResult),
+    serverRecordFiles,
     previousRecords: workspace.state.records,
-    conflictPaths,
     emittedPaths,
     mainLocale: workspaceMainLocale(workspace.state.records)
   });
@@ -118612,6 +118799,7 @@ async function finishFormat4Pull(args) {
     for (const path of localRecordFiles.get(key) ?? []) rewritePaths.add(path);
   }
   const resolveSourcePath = createWorkspaceSourcePathResolver(workspace.root);
+  const markedPaths = /* @__PURE__ */ new Set();
   let written = 0;
   for (const path of emittedPaths) {
     const absolute = resolveSourcePath(path);
@@ -118632,8 +118820,10 @@ async function finishFormat4Pull(args) {
       versionId: workspace.config.versionId
     }) : local;
     if (content === void 0) continue;
+    const marked = conflictPaths.has(path) && detectConflictMarkers(content) !== null;
+    if (marked) markedPaths.add(path);
     mkdirSync8(dirname8(absolute), { recursive: true });
-    if (existing !== null && !rewritePaths.has(path)) continue;
+    if (existing !== null && !marked && !rewritePaths.has(path)) continue;
     if (existing !== content) {
       writeFileSync8(absolute, content, "utf8");
       written += 1;
@@ -118666,12 +118856,16 @@ async function finishFormat4Pull(args) {
       continue;
     }
     const file = localResult.recordFiles.get(key) ?? serverResult?.recordFiles.get(key) ?? baseState?.file;
+    const conflictFiles = (conflictPathsByKey.get(key) ?? []).filter(
+      (conflictPath) => markedPaths.has(conflictPath)
+    );
     records2[key] = plan.conflicted ? {
       recordKind,
       recordId,
       contentHash: baseState?.contentHash ?? "",
       data: baseState?.data,
       ...file ? { file } : {},
+      ...conflictFiles.length === 0 ? {} : { conflictFiles },
       conflictServerHash: serverRecord?.contentHash ?? null,
       conflictServerData: plan.serverData
     } : {
@@ -118758,9 +118952,9 @@ async function finishFormat4Pull(args) {
     );
     for (const key of conflictKeys) console.log(`  ${sym.fail} ${key}`);
     for (const tear of staleConflictTears) {
-      const rowLabel = tear.unanchoredValueCount === 1 ? "row" : "rows";
+      const rowLabel2 = tear.unanchoredValueCount === 1 ? "row" : "rows";
       warn(
-        `Conflict ${tear.recordKind} "${tear.recordId}" retained a local base that does not anchor ${tear.unanchoredValueCount} newly pulled descendant value ${rowLabel}. Resolve it with "neo resolve --mine" or "neo resolve --theirs" before pushing.`
+        `Conflict ${tear.recordKind} "${tear.recordId}" retained a local base that does not anchor ${tear.unanchoredValueCount} newly pulled descendant value ${rowLabel2}. Resolve it with "neo resolve --mine" or "neo resolve --theirs" before pushing.`
       );
     }
   }
@@ -118934,7 +119128,7 @@ function projectSourcePathsRequiringRewriteV4(args) {
   if (args.destructive || args.localStatus === null) {
     return new Set(args.emittedPaths);
   }
-  const result = new Set(args.conflictPaths);
+  const result = /* @__PURE__ */ new Set();
   for (const [key, plan] of args.plans) {
     const paths = args.localRecordFiles.get(key) ?? args.serverRecordFiles.get(key);
     if (paths === void 0) continue;
@@ -126300,7 +126494,7 @@ var init_registry2 = __esm({
     PROJECT_SCHEMA_CONTRACT = Object.freeze({
       formatVersion: 4,
       contractVersion: "4.1",
-      cliVersion: "0.43.1",
+      cliVersion: "0.44.0",
       projectFileUploadBatchSize: 32,
       documentRecords: {
         member: {
@@ -129434,6 +129628,7 @@ var init_test = __esm({
 var doctor_exports = {};
 __export(doctor_exports, {
   inspectNeoDoctor: () => inspectNeoDoctor,
+  planUnprojectedValueRowRepair: () => planUnprojectedValueRowRepair,
   runDoctor: () => runDoctor
 });
 import {
@@ -129666,7 +129861,7 @@ function workspacePath(root, path) {
 function errorMessage3(error) {
   return error instanceof Error ? error.message : String(error);
 }
-async function runDoctor(workspace, json) {
+async function runDoctor(workspace, options) {
   const inspected = inspectNeoDoctor(workspace);
   let errors = [];
   try {
@@ -129685,7 +129880,7 @@ async function runDoctor(workspace, json) {
       compatible: errors.length === 0
     }
   };
-  if (json) {
+  if (options.json) {
     console.log(JSON.stringify(report, null, 2));
     if (!report.ok) process.exitCode = 1;
     return;
@@ -129732,23 +129927,213 @@ async function runDoctor(workspace, json) {
   console.log(
     report.ok ? "Project authoring contracts are compatible." : "Project authoring contracts need attention."
   );
-  if (!report.document.consistent) {
+  if (!report.document.consistent && !options.fix) {
     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;
+  if (options.fix) {
+    await repairUnprojectedValueRows(
+      workspace,
+      report.document.findings,
+      options.yes
+    );
+  }
+}
+function planUnprojectedValueRowRepair(workspace, findings) {
+  const roots = [];
+  const claimed = /* @__PURE__ */ new Set();
+  const unrepairableKinds = /* @__PURE__ */ new Set();
+  for (const finding of findings) {
+    if (finding.kind !== "unprojected-value-row") {
+      unrepairableKinds.add(finding.kind);
+      continue;
+    }
+    const owned = [];
+    for (const valueId of finding.repair.orphanedValueIds) {
+      if (claimed.has(valueId)) continue;
+      claimed.add(valueId);
+      const record3 = workspace.state.records[recordStateKey("value", valueId)];
+      if (record3 === void 0) {
+        throw new Error(
+          `Doctor repair planned value row "${valueId}", which the pulled state does not hold. Run \`neo pull\` and rerun \`neo doctor --fix\`.`
+        );
+      }
+      owned.push(record3);
+    }
+    if (owned.length === 0) continue;
+    roots.push({ valueId: finding.repair.valueId, rows: owned });
+  }
+  return { roots, unrepairableKinds: [...unrepairableKinds].sort() };
+}
+function rowLabel(count) {
+  return `${String(count)} value row${count === 1 ? "" : "s"}`;
 }
-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;
+async function repairUnprojectedValueRows(workspace, findings, yes) {
+  const plan = planUnprojectedValueRowRepair(workspace, findings);
+  if (plan.unrepairableKinds.length > 0) {
+    warn(
+      `No automatic repair exists for ${plan.unrepairableKinds.join(", ")}; repairing unprojected value rows only.`
+    );
+  }
+  if (plan.roots.length === 0) {
+    console.log("Nothing to repair.");
+    return;
+  }
+  const rows = plan.roots.flatMap((root) => root.rows);
+  const pulledHeadTransactionHash = workspace.state.headTransactionHash;
+  if (typeof pulledHeadTransactionHash !== "string") {
+    throw new Error(
+      'This workspace has no recorded project head, so `neo doctor --fix` cannot prove its deletions land on the state the audit read. Run "neo pull", then rerun.'
+    );
+  }
+  const rootLabel = `${String(plan.roots.length)} orphan root${plan.roots.length === 1 ? "" : "s"}`;
+  console.log(
+    `${sym.info} ${rowLabel(rows.length)} across ${rootLabel} will be deleted:`
+  );
+  for (const root of plan.roots.slice(0, REPAIR_ROOT_PREVIEW_LIMIT)) {
+    console.log(
+      `  ${sym.arrow} ${root.valueId} \u2014 ${rowLabel(root.rows.length)}`
+    );
+  }
+  const hidden = plan.roots.length - REPAIR_ROOT_PREVIEW_LIMIT;
+  if (hidden > 0) {
+    note(
+      `  \u2026and ${String(hidden)} more orphan root${hidden === 1 ? "" : "s"}.`
+    );
+  }
+  if (!yes && !isInteractive()) {
+    throw new Error(
+      "neo doctor --fix needs a terminal to confirm the deletion. Re-run with --yes to delete without confirming."
+    );
+  }
+  const confirmed = yes || await promptConfirm({
+    message: `Delete ${rowLabel(rows.length)}?`,
+    fallback: false,
+    defaultValue: false
+  });
+  if (!confirmed) {
+    console.log("Cancelled. No records were deleted.");
+    return;
+  }
+  const { api: api3, createConvexClient: createConvexClient2 } = await Promise.resolve().then(() => (init_convex(), convex_exports));
+  const { createProjectVersionIntent: createProjectVersionIntent2 } = await Promise.resolve().then(() => (init_project_version_intents(), project_version_intents_exports));
+  const changes = rows.map((row) => ({
+    recordKind: "value",
+    recordId: row.recordId,
+    operation: "delete",
+    deleted: true,
+    expectedBaseContentHash: row.contentHash,
+    intent: createProjectVersionIntent2("value.delete", {
+      source: "neo-cli-doctor"
+    })
+  }));
+  const batchSize = immediateCommitBatchSize(changes);
+  const convex = await createConvexClient2(workspace);
+  const progress = spinner(`Deleting ${rowLabel(rows.length)}\u2026`);
+  let deleted = 0;
+  let expectedHeadTransactionHash = pulledHeadTransactionHash;
+  for (let index = 0; index < changes.length; index += batchSize) {
+    const batch = changes.slice(index, index + batchSize);
+    let transactionHash;
+    try {
+      const result = await convex.mutation(
+        api3.serverProjectRecordOperations.commitFromSession,
+        {
+          projectId: workspace.config.projectId,
+          versionId: workspace.config.versionId,
+          operation: "delete",
+          changes: batch,
+          summary: `neo doctor --fix (${rowLabel(batch.length)})`,
+          expectedHeadTransactionHash
+        }
+      );
+      transactionHash = committedTransactionHash(result);
+    } catch (error) {
+      progress.fail(
+        deleted === 0 ? `Failed to delete ${rowLabel(batch.length)}.` : `Failed after deleting ${rowLabel(deleted)}.`
+      );
+      throw repairFailure(error, deleted);
+    }
+    if (transactionHash === null) continue;
+    expectedHeadTransactionHash = transactionHash;
+    deleted += batch.length;
+    progress.update(
+      `Deleting ${rowLabel(rows.length)}\u2026 ${String(deleted)} done`
+    );
+  }
+  progress.succeed(`Deleted ${rowLabel(deleted)} across ${rootLabel}.`);
+  console.log('Run "neo pull" to refresh the working copy.');
+}
+function immediateCommitBatchSize(changes) {
+  let fits = 0;
+  let low = 1;
+  let high = changes.length;
+  while (low <= high) {
+    const size = Math.floor((low + high) / 2);
+    if (planProjectVersionTransaction(changes.slice(0, size)).path === "immediate") {
+      fits = size;
+      low = size + 1;
+    } else {
+      high = size - 1;
+    }
+  }
+  if (fits === 0) {
+    throw new Error(
+      "Deleting a single value row exceeds the immediate transaction budget, so `neo doctor --fix` cannot commit anything. The transaction cost model needs to change before this repair can run."
+    );
+  }
+  return fits;
+}
+function committedTransactionHash(result) {
+  if (!isObjectRecord2(result)) {
+    throw new Error(
+      "Doctor repair committed a deletion but the server returned no transaction envelope."
+    );
+  }
+  if (result.transaction === null) return null;
+  const transactionHash = isObjectRecord2(result.transaction) ? result.transaction.transactionHash : void 0;
+  if (typeof transactionHash !== "string") {
+    throw new Error(
+      "Doctor repair committed a transaction that carries no hash, so the remaining deletions have no fast-forward base."
+    );
+  }
+  return transactionHash;
+}
+function repairFailure(error, deleted) {
+  const applied = deleted === 0 ? "" : ` ${rowLabel(deleted)} were already deleted.`;
+  const code = convexErrorCode(error);
+  if (code === "non-fast-forward" || code === "base-hash-conflict") {
+    return new Error(
+      `neo doctor --fix was refused: the project moved on since this workspace pulled, so the audit is stale.${applied} Run \`neo pull\` to re-derive it, then rerun.`,
+      { cause: error }
+    );
+  }
+  return new Error(
+    `neo doctor --fix could not delete the audited rows: ${errorMessage3(error)}${applied}`,
+    { cause: error }
+  );
+}
+function convexErrorCode(error) {
+  if (!isObjectRecord2(error)) return null;
+  const data = error.data;
+  if (!isObjectRecord2(data)) return null;
+  return typeof data.error === "string" ? data.error : null;
+}
+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, REPAIR_ROOT_PREVIEW_LIMIT;
 var init_doctor = __esm({
   "src/commands/doctor.ts"() {
     "use strict";
     init_src();
     init_workspace();
+    init_ui();
     init_workspace_status();
     init_source_diagnostics();
     init_project_documents();
     init_project_integrity();
+    init_project_version_transaction_planning();
+    init_projection();
     NEO_COMPILER_CONTRACT = "ProjectSourceAnalysisV4";
     NEO_VSCODE_EXTENSION_ID = "neocompose.neo-compose-neoscript";
     NEO_VSCODE_EXTENSION_CONTRACT_VERSION = "0.3.0";
@@ -129764,6 +130149,7 @@ var init_doctor = __esm({
       { extension: ".mp3", kind: "audio", mimeType: "audio/mpeg" },
       { extension: ".ogg", kind: "audio", mimeType: "audio/ogg" }
     ];
+    REPAIR_ROOT_PREVIEW_LIMIT = 20;
   }
 });
 
@@ -132781,15 +133167,17 @@ __export(resolve_exports, {
   runResolve: () => runResolve
 });
 import { readFileSync as readFileSync19, rmSync as rmSync8, writeFileSync as writeFileSync14 } from "node:fs";
-import { join as join20 } from "node:path";
+import { join as join20, relative as relative8 } from "node:path";
 function runResolve(workspace, side) {
+  const marked = readMarkedProjectSourcesV4(workspace.root);
+  assertRecordConflictsResolveTogetherV4(
+    workspace,
+    new Set(marked.map((file) => file.path))
+  );
   const resolvedRecords = adoptServerConflictBases(workspace);
   let resolvedFiles = 0;
-  for (const filePath of listProjectSourceFilesV4(workspace.root)) {
-    const source = readFileSync19(filePath, "utf8");
-    if (detectConflictMarkers(source) === null) continue;
-    const resolved = resolveMarkers(source, side);
-    writeFileSync14(filePath, resolved, "utf8");
+  for (const file of marked) {
+    writeFileSync14(file.absolutePath, resolveMarkers(file.source, side), "utf8");
     resolvedFiles += 1;
   }
   let resolvedBinaries = 0;
@@ -132828,6 +133216,37 @@ function runResolve(workspace, side) {
     `Resolved ${resolvedFiles} source file(s), ${resolvedRecords} record conflict(s), and ${resolvedBinaries} binary file(s) keeping the "${side}" side. Review with "neo diff", then "neo push".`
   );
 }
+function readMarkedProjectSourcesV4(root) {
+  const files = [];
+  for (const absolutePath of listProjectSourceFilesV4(root)) {
+    const source = readFileSync19(absolutePath, "utf8");
+    if (detectConflictMarkers(source) === null) continue;
+    files.push({
+      path: normalizeWorkspaceSourcePath(relative8(root, absolutePath)),
+      absolutePath,
+      source
+    });
+  }
+  return files;
+}
+function assertRecordConflictsResolveTogetherV4(workspace, markedPaths) {
+  for (const [key, record3] of Object.entries(workspace.state.records)) {
+    const declaringPaths = record3.conflictFiles;
+    if (declaringPaths === void 0) continue;
+    const stillMarked = [];
+    const alreadyResolved = [];
+    for (const declaringPath of declaringPaths) {
+      const path = normalizeWorkspaceSourcePath(declaringPath);
+      if (markedPaths.has(path)) stillMarked.push(path);
+      else alreadyResolved.push(path);
+    }
+    if (stillMarked.length === 0) continue;
+    if (alreadyResolved.length === 0) continue;
+    throw new Error(
+      `The files declaring conflicted record ${key} disagree: ${stillMarked.join(", ")} still holds conflict markers while ${alreadyResolved.join(", ")} does not. Every file that declares one record resolves together \u2014 finish resolving the marked file(s) to the side you already kept, then run "neo resolve".`
+    );
+  }
+}
 function adoptServerConflictBases(workspace) {
   let adopted = 0;
   for (const [key, record3] of Object.entries(workspace.state.records)) {
@@ -132839,6 +133258,7 @@ function adoptServerConflictBases(workspace) {
     };
     delete next.conflictServerHash;
     delete next.conflictServerData;
+    delete next.conflictFiles;
     workspace.state.records[key] = next;
     adopted += 1;
   }
@@ -132886,6 +133306,7 @@ var init_resolve = __esm({
     init_workspace();
     init_workspace_status();
     init_source_diagnostics();
+    init_workspace_source_path();
     init_project_files();
   }
 });
@@ -132936,7 +133357,7 @@ ${h("Working copy")}
   diff      ${d("[--json]")}
   dev       ${d("[--push]")}
   resolve   ${d("[--mine|--theirs]")}
-  doctor    ${d("[--json]  validate contracts and audit the pulled document")}
+  doctor    ${d("[--json] [--fix [--yes]]  validate contracts and audit the pulled document")}
 
 ${h("Branches & releases")}
   branch    ${d("list | create <name> | switch [ref] | delete <ref> | refresh")}
@@ -133022,11 +133443,14 @@ ${h("NSFunction preview")}
     return `${h("neo doctor")} \u2014 validate project authoring contracts
 
 ${h("Usage")}
-  neo doctor ${d("[--json]")}
+  neo doctor ${d("[--json] [--fix [--yes]]")}
 
 Neo validates the format-4 browser compiler, VS Code extension cache envelope,
 tracked source, local .spec.neo compilation, and managed project-file
 capabilities. It does not discover or require .NET.
+
+${h("Repair")}
+  ${d("--fix deletes the value rows the pulled document's unprojected-value-row findings name, after listing them and confirming. --yes skips the prompt. --fix cannot be combined with --json.")}
 `;
   }
   if (command === "dialogue") {
@@ -133083,7 +133507,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.43.1");
+    console.log("0.44.0");
     return;
   }
   if (args.command === null || args.command === "help" || args.command === "--help" || args.command === "-h") {
@@ -133168,9 +133592,23 @@ async function main() {
       return;
     }
     case "doctor": {
+      assertAllowedFlags(args, /* @__PURE__ */ new Set(["api", "json", "fix", "yes"]));
+      const json = boolFlag(args, "json");
+      const fix = boolFlag(args, "fix");
+      if (fix && json) {
+        throw new NeoCliUsageError(
+          "neo doctor --fix reports and confirms interactively; it has no --json form. Drop --json, or run `neo doctor --json` to read the findings."
+        );
+      }
+      const yes = boolFlag(args, "yes");
+      if (yes && !fix) {
+        throw new NeoCliUsageError(
+          "neo doctor --yes only answers the --fix confirmation. Add --fix, or drop --yes."
+        );
+      }
       const workspace = loadWorkspaceForCommand(args);
       const { runDoctor: runDoctor2 } = await Promise.resolve().then(() => (init_doctor(), doctor_exports));
-      await runDoctor2(workspace, boolFlag(args, "json"));
+      await runDoctor2(workspace, { json, fix, yes });
       return;
     }
     case "branch": {

package/package.json

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

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

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

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

@@ -86,6 +86,12 @@ Resolve source conflicts by editing the final intended source. Use
 `neo resolve --mine` or `neo resolve --theirs` only for a deliberate whole-side
 choice. Pull, inspect, dry-run, and retry; there is no force-CAS path.
 
+One record is one conflict, however many files declare it. A member declared by
+more than one class is marked in every declaring file, and `neo resolve`
+settles those files together; it refuses a record whose declarations are only
+partly resolved rather than settling the rest to the other side and leaving the
+declarations disagreeing.
+
 Compiled initializer IR is server-owned and does not participate in authored
 three-way merge decisions. Either `neo resolve` side adopts the server side as
 the new base for every conflict it settles — `--theirs` then reads clean, and
@@ -185,6 +191,18 @@ row is invisible to `neo status` by construction, which is why `neo doctor` is
 the only place it surfaces.
 `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.
+`neo doctor --fix` consumes those entries for the `unprojected-value-row`
+findings: it lists each orphan root with the number of rows it owns, confirms,
+then deletes them. Two guards make a stale audit fail the commit rather than
+delete a row that has since gained an owner: every row carries the CAS base the
+last pull recorded, and every transaction expects the version head the previous
+one produced, starting from the head that pull left. Adopting an orphan writes
+its new owner rather than the row itself, so only the head guard sees that, and
+a workspace with no recorded head is refused rather than written blind. More
+rows than one transaction budgets for go up in batches sized from the shared
+cost model against the immediate commit path. `--yes` answers the confirmation
+for scripted runs, and `--fix` has no `--json` form. No other finding kind has
+an automatic repair.
 
 The Node CLI talks directly to authenticated Convex APIs through the
 session-gated CAS boundary. Tokens use the OS credential store when available