superbee 0.4.4-pre.16 → 0.4.4-pre.17

package/dist/superbee.mjs

@@ -44,7 +44,7 @@ var __toESM = (mod, isNodeMode, target3) => (target3 = mod != null ? __create(__
 var define_SUPERBEE_BUILD_IDENTITY_default;
 var init_define_SUPERBEE_BUILD_IDENTITY = __esm({
   "<define:__SUPERBEE_BUILD_IDENTITY__>"() {
-    define_SUPERBEE_BUILD_IDENTITY_default = { schema: "superbee.build-identity.v1", package: { name: "superbee", version: "0.4.4-pre.16" }, source: { commit: "66fdb860f1569884cb7b0c037feabd69afd25136", dirty: false }, artifact: { channel: "npm-package" }, compatibility_contracts: { skill: 1, hook: 1, mcp: 1 } };
+    define_SUPERBEE_BUILD_IDENTITY_default = { schema: "superbee.build-identity.v1", package: { name: "superbee", version: "0.4.4-pre.17" }, source: { commit: "a6b98ce916f5cfcaa684d6244573dc567820f1b7", dirty: false }, artifact: { channel: "npm-package" }, compatibility_contracts: { skill: 1, hook: 1, mcp: 1 } };
   }
 });
 
@@ -48474,27 +48474,54 @@ var init_claim_conflict = __esm({
 // ../cli/src/saved-conflicts.ts
 import { readFile as readFile3, rm as rm2 } from "node:fs/promises";
 import path27 from "node:path";
-function differingFields(left, right, stamped) {
-  const keys2 = /* @__PURE__ */ new Set([...Object.keys(left), ...Object.keys(right)]);
-  return [...keys2].filter((key4) => !stamped.has(key4) && JSON.stringify(left[key4]) !== JSON.stringify(right[key4])).sort();
-}
 function decodesLosslessly(bytes2) {
   return Buffer.from(bytes2.toString("utf8"), "utf8").equals(bytes2);
 }
+function comparableText(relPath, bytes2, ownerField) {
+  if (!isConceptDocPath(relPath) || !decodesLosslessly(bytes2)) return null;
+  const text7 = bytes2.toString("utf8");
+  const close = text7.indexOf("\n---\n", 3);
+  if (!text7.startsWith("---\n") || close === -1) return null;
+  const lines = text7.slice(4, close).split("\n");
+  const kept = [];
+  const continues = (line2) => line2 !== void 0 && /^(?:\s|-(?:\s|$))/.test(line2);
+  for (let index2 = 0; index2 < lines.length; index2++) {
+    const line2 = lines[index2];
+    const key4 = /^([^\s#:'"-][^\s:]*):(?:\s|$)/.exec(line2)?.[1];
+    if (key4 !== void 0 && key4 === ownerField) {
+      if (continues(lines[index2 + 1]) || !ONE_LINE_VALUE.test(line2.slice(key4.length + 1).trim())) return null;
+    } else if (key4 !== void 0 && ENGINE_STAMPED_FIELDS.has(key4)) {
+      if (line2.includes("#")) return null;
+      while (continues(lines[index2 + 1])) {
+        if (lines[++index2].includes("#")) return null;
+      }
+    } else {
+      kept.push(line2);
+    }
+  }
+  return `${kept.join("\n")}
+---
+${text7.slice(close + 5)}`;
+}
 function copyIsCarried(relPath, copy, current) {
   if (current === null) return false;
   if (copy.equals(current)) return true;
-  if (!isConceptDocPath(relPath)) return false;
-  if (!decodesLosslessly(copy) || !decodesLosslessly(current)) return false;
-  let saved;
-  let now;
-  try {
-    saved = parseMarkdown(copy.toString("utf8"), relPath);
-    now = parseMarkdown(current.toString("utf8"), relPath);
+  const saved = comparableText(relPath, copy);
+  return saved !== null && saved === comparableText(relPath, current);
+}
+function lostClaim(relPath, copy, current, policy) {
+  try {
+    const fields2 = parseMarkdown(current.toString("utf8"), relPath).frontmatter;
+    const ownerField = policy.forType(fields2.type)?.ownerField;
+    if (ownerField === void 0) return null;
+    const saved = comparableText(relPath, copy, ownerField);
+    if (saved === null || saved !== comparableText(relPath, current, ownerField)) return null;
+    const owner = recordedOwner(fields2, ownerField);
+    const yourOwner = recordedOwner(parseMarkdown(copy.toString("utf8"), relPath).frontmatter, ownerField);
+    return { ...owner !== void 0 ? { owner } : {}, ...yourOwner !== void 0 ? { yourOwner } : {} };
   } catch {
-    return false;
+    return null;
   }
-  return saved.body === now.body && differingFields(saved.frontmatter, now.frontmatter, ENGINE_STAMPED_FIELDS).length === 0;
 }
 async function readIfThere(file2) {
   try {
@@ -48508,6 +48535,8 @@ async function readIfThere(file2) {
 async function classify(boardPath, key4) {
   const byPath = /* @__PURE__ */ new Map();
   const carried = [];
+  const lostClaims = [];
+  let policy;
   for (const copy of listSavedCopies(defaultSyncStore.exportsDir(key4))) {
     let discardWith = "remove";
     let unreadable = false;
@@ -48519,6 +48548,17 @@ async function classify(boardPath, key4) {
         carried.push(copy);
         continue;
       }
+      if (current !== null && isConceptDocPath(copy.relPath)) {
+        policy ??= await loadClaimPolicy(boardPath);
+        const lost = lostClaim(copy.relPath, bytes2, current, policy);
+        if (lost !== null) {
+          lostClaims.push({
+            copy,
+            claim: { id: conceptIdFromPath(copy.relPath), ...lost.owner !== void 0 ? { owner: lost.owner } : {}, ...lost.yourOwner !== void 0 ? { your_owner: lost.yourOwner } : {} }
+          });
+          continue;
+        }
+      }
       const upstream = readDocBytesAtRef(boardPath, `refs/remotes/${boardRefOf(boardPath)}`, copy.relPath);
       discardWith = current === null ? upstream === null ? "take" : "remove" : upstream === null || !current.equals(upstream) ? "revise" : "take";
     } catch {
@@ -48529,18 +48569,25 @@ async function classify(boardPath, key4) {
     entry.copies.push(copy);
     byPath.set(copy.relPath, entry);
   }
-  return { unsettled: [...byPath.values()], carried };
+  return { unsettled: [...byPath.values()], carried, lostClaims };
 }
 async function unsettledConflicts(boardPath, key4) {
   return (await classify(boardPath, key4)).unsettled;
 }
 async function removeCarriedCopies(boardPath, key4) {
-  for (const copy of (await classify(boardPath, key4)).carried) {
+  const { carried, lostClaims } = await classify(boardPath, key4);
+  const settled = /* @__PURE__ */ new Map();
+  for (const { copy, claim } of lostClaims) {
+    carried.push(copy);
+    settled.set(claim.id, claim);
+  }
+  for (const copy of carried) {
     await rm2(copy.file, { force: true }).catch(() => {
     });
     if (copy.bodyFile !== null) await rm2(copy.bodyFile, { force: true }).catch(() => {
     });
   }
+  return [...settled.values()];
 }
 function inspectCommand(inv, id, dir) {
   const suffix = dir === void 0 ? commandFragment`` : commandFragment` --dir ${commandToken(dir)}`;
@@ -48567,6 +48614,7 @@ function unsettledMessage(unsettled) {
   const more = names.length > 5 ? ` and ${names.length - 5} more` : "";
   return `${names.length} saved conflict${names.length === 1 ? "" : "s"} still need${names.length === 1 ? "s" : ""} a decision: ${shown3}${more}`;
 }
+var ONE_LINE_VALUE;
 var init_saved_conflicts = __esm({
   "../cli/src/saved-conflicts.ts"() {
     "use strict";
@@ -48577,6 +48625,7 @@ var init_saved_conflicts = __esm({
     init_command_text();
     init_claim_conflict();
     init_cursor2();
+    ONE_LINE_VALUE = /^(?:"[^"#]*"|'[^'#]*'|[^\s\[\]{}|>&*!#'"-][^#]*)?$/;
   }
 });
 
@@ -49795,7 +49844,7 @@ function convergeDocLine(c, claim, keptRefused) {
       return `${label} \u2014 teammate's version kept (your side deleted it; nothing to save); the document is back with their change, so carry it over if you moved it, then delete it again`;
     }
     if (!c.landed) {
-      const recreate = fixingVerb ? " \u2014 re-create with doc write" : "";
+      const recreate = fixingVerb ? " \u2014 re-create with sync --resolve keep" : "";
       return `${label} \u2014 teammate's deletion kept; yours saved at ${c.exportPath}${recreate}`;
     }
     const reconcile = fixingVerb ? keptRefused ? `; doc update cannot read the kept version (${keptRefused.code}), so copy yours over it to reconcile` : " \u2014 reconcile with doc update" : "";
@@ -49812,8 +49861,8 @@ function convergeHelp(inv, id, bodyExportPath) {
 function copyOverHelp(inv, exportPath, file2) {
   return `cp ${commandToken(exportPath)} ${commandToken(file2)} (this discards the teammate's version from your working tree, and the sync replaces it on the board; it stays in the board's Git history) \u2192 ${inv} sync`;
 }
-function recreateHelp(inv, id, bodyExportPath) {
-  return `${inv} doc write ${commandToken(id)} --type <Type> --body-file ${commandToken(bodyExportPath)} \u2192 ${inv} sync`;
+function recreateHelp(inv, id) {
+  return `${inv} sync --resolve keep --doc ${commandToken(id)} \u2192 ${inv} sync`;
 }
 function pickHelp(inv, conflicts, analyses) {
   const usable = (c, i) => c.isDoc && c.bodyExportPath !== null && analyses[i]?.claim?.only !== true;
@@ -49824,7 +49873,7 @@ function pickHelp(inv, conflicts, analyses) {
     return keptRefused && reconcilable.exportPath !== null ? copyOverHelp(inv, reconcilable.exportPath, keptRefused.file) : convergeHelp(inv, reconcilable.entry, reconcilable.bodyExportPath);
   }
   const recreatable = conflicts.find(usable);
-  if (recreatable) return recreateHelp(inv, recreatable.entry, recreatable.bodyExportPath);
+  if (recreatable) return recreateHelp(inv, recreatable.entry);
   return void 0;
 }
 function keptDocMeta(frontmatter) {
@@ -49963,7 +50012,7 @@ var init_converge = __esm({
     PUSH_FAIL_ACCESS_MESSAGE = "committed to the board locally \u2014 your work is saved. The remote did not accept the update to origin/board. Verify the active HTTPS/SSH identity, repository-specific Write access, and board-update policy; re-run sync only after one of those conditions changes.";
     PUSH_FAIL_NETWORK_MESSAGE = "committed to the board locally \u2014 your work is saved. The update to origin/board could not reach the remote; re-run sync after connectivity changes.";
     EMPTY_ANALYSIS = { meta: {}, frontmatterDiffers: [] };
-    SAVED_COPIES_NOTE = "each saved copy stays listed until its file is removed or sync --resolve settles it: revise before your merge is pushed, take after, which then leaves the document unchanged";
+    SAVED_COPIES_NOTE = "each saved copy stays listed until its file is removed or sync --resolve settles it: revise before your merge is pushed, take after, which then leaves the document unchanged. A copy that differs only by a lost claim is settled by the next sync, which reports it";
     UNKNOWN_FIELD = "unknown";
   }
 });
@@ -56217,6 +56266,7 @@ async function receiptPhase(run, board, commitResult2, delta, pushed, establishA
     hookHint
   });
   if (pushed.gate) receipt5.gate = `passed: ${String(pushed.gate.command)} (attempt ${String(pushed.gate.attempt)})`;
+  if (run.settledClaims?.length) receipt5.lost_claims_settled = cap(run.settledClaims.map((claim) => ({ ...claim })), run.limit);
   const unsettled = await unsettledConflicts(board.boardPath, board.key);
   const counts = { sent: pushed.documents, received: delta.originDelta.length };
   if (unsettled.length > 0) {
@@ -56310,13 +56360,22 @@ async function syncCommand(argv2, deps2 = {}) {
     }
     refuseOutgoingWorktreePrivateState(board.boardPath, "sync", `${run.inv} sync`);
   }
-  if (!run.pullOnly) await removeCarriedCopies(board.boardPath, board.key);
+  if (!run.pullOnly) run.settledClaims = await removeCarriedCopies(board.boardPath, board.key);
   const commitResult2 = await commitPhase(board, run.pullOnly);
   if (commitResult2.held) {
     await heldRun(run, board, baseline, commitResult2.held);
     return;
   }
-  await pullPhase(run, board, commitResult2);
+  try {
+    await pullPhase(run, board, commitResult2);
+  } catch (error51) {
+    if (!(error51 instanceof CliError) || !run.settledClaims?.length) throw error51;
+    throw new CliError(error51.code, error51.message, {
+      details: { ...error51.details, lost_claims_settled: cap(run.settledClaims.map((claim) => ({ ...claim })), run.limit) },
+      ...error51.help !== void 0 ? { help: error51.help } : {},
+      handled: error51.handled
+    });
+  }
   if (!run.pullOnly) refuseMovedBoard(board.boardPath);
   const delta = await deltaPhase(board, baseline);
   if (!run.pullOnly) holdMalformedCommitted(run, board, delta);
@@ -56415,7 +56474,7 @@ enriched delta of docs that arrived this run (capped; --limit controls the row c
 
 When a doc changed on BOTH sides, sync CONVERGES: your teammate's version is kept on the board,
 YOUR version is saved to an export file named in the receipt, and the sync completes (the
-board is never left mid-state; non-conflicted local changes still land). The run exits 5 with
+board is never left mid-state; non-conflicted local changes land on the local board, unpushed until the next sync). The run exits 5 with
 one row per conflicted doc and the reconcile chain: \`sync --show-incoming <id>\` to view the kept
 incoming version, \`doc update <id> --body-file <export-file>\` to write your merged version on
 top, then \`sync\` again to share it. The saved copy stays listed until you settle it.
@@ -56424,7 +56483,10 @@ A saved copy stays reported until it is settled: \`status\` reads \`needs_decisi
 document, and every later \`sync\` lists it in \`saved_conflicts\`, with the command that shows it
 and the one command that discards it. Only a new conflict exits 5; a copy from an earlier run does
 not change the exit code. A copy whose content the document already holds, apart from engine
-stamps, is settled by itself: the next \`sync\` removes it. A repeat conflict on one document keeps
+stamps, is settled by itself: the next \`sync\` removes it. So is a lost claim race, a copy whose
+text differs only by the one-line owner field its kind declares, which that \`sync\` reports once in
+\`lost_claims_settled\` with the value the copy held; any other difference in the text, a comment or
+a state field included, stays listed. A repeat conflict on one document keeps
 the earlier copy and saves the new one beside it, unless its bytes match a saved copy, which is
 then that copy. Copies are kept per clone folder, so moving a clone leaves them under its old path.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "superbee",
-  "version": "0.4.4-pre.16",
+  "version": "0.4.4-pre.17",
   "type": "module",
   "description": "Agent-facing Superbee CLI for reading and writing local OKF knowledge bundles: context notes, docs, cross-links, and live bundle Views.",
   "keywords": [