@magic-markdown/cli 0.3.12 → 0.3.13

package/dist/index.js

@@ -918,7 +918,8 @@ function selectorFromRange(markdown, range) {
 function remapAnchor(markdown, anchor) {
   const lines = getLines(markdown);
   const quoteLines = anchor.selector.quote.split(/\r?\n/);
-  const best = findQuote(lines, quoteLines);
+  const candidates = findQuoteCandidates(lines, quoteLines);
+  const best = bestCandidate(lines, candidates, anchor.selector);
   if (!best) {
     return {
       ...anchor,
@@ -939,30 +940,44 @@ function remapAnchor(markdown, anchor) {
 function remapAnchors(markdown, anchors) {
   return anchors.map((anchor) => remapAnchor(markdown, anchor));
 }
-function findQuote(lines, quoteLines) {
-  if (quoteLines.length === 0) return void 0;
+function findQuoteCandidates(lines, quoteLines) {
+  if (quoteLines.length === 0) return [];
+  const ranges = [];
+  const quoteText = quoteLines.join("\n");
   for (let index = 0; index <= lines.length - quoteLines.length; index += 1) {
     const candidate = lines.slice(index, index + quoteLines.length);
-    if (candidate.join("\n") === quoteLines.join("\n")) {
-      return { startLine: index + 1, endLine: index + quoteLines.length };
-    }
+    if (candidate.join("\n") === quoteText) ranges.push({ startLine: index + 1, endLine: index + quoteLines.length });
   }
-  return void 0;
+  return ranges;
+}
+function bestCandidate(lines, candidates, selector) {
+  if (candidates.length <= 1) return candidates[0];
+  const scored = candidates.map((range) => ({ range, score: scoreContext(lines, range.startLine, range.endLine, selector) })).sort((left, right) => right.score - left.score);
+  const best = scored[0];
+  if (!best) return void 0;
+  const tied = scored.filter((candidate) => candidate.score === best.score);
+  return tied.length === 1 ? best.range : void 0;
 }
 function scoreContext(lines, startLine, endLine, selector) {
   let score = 0.7;
-  if (selector.prefix) {
-    const expectedPrefix = selector.prefix.split(/\r?\n/).filter(Boolean).slice(-3).join("\n");
-    const actualPrefix = lines.slice(Math.max(0, startLine - 4), startLine - 1).join("\n");
+  const expectedPrefix = contextPrefix(selector.prefix);
+  if (expectedPrefix) {
+    const actualPrefix = contextPrefix(lines.slice(Math.max(0, startLine - 4), startLine - 1).join("\n"));
     if (expectedPrefix && actualPrefix.endsWith(expectedPrefix)) score += 0.15;
   }
-  if (selector.suffix) {
-    const expectedSuffix = selector.suffix.split(/\r?\n/).filter(Boolean).slice(0, 3).join("\n");
-    const actualSuffix = lines.slice(endLine, endLine + 3).join("\n");
+  const expectedSuffix = contextSuffix(selector.suffix);
+  if (expectedSuffix) {
+    const actualSuffix = contextSuffix(lines.slice(endLine, endLine + 3).join("\n"));
     if (expectedSuffix && actualSuffix.startsWith(expectedSuffix)) score += 0.15;
   }
   return Math.min(1, score);
 }
+function contextPrefix(value) {
+  return value?.split(/\r?\n/).filter(Boolean).slice(-3).join("\n") ?? "";
+}
+function contextSuffix(value) {
+  return value?.split(/\r?\n/).filter(Boolean).slice(0, 3).join("\n") ?? "";
+}
 
 // ../core/src/text-merge.ts
 var MAX_DIFF_CELLS = 25e6;
@@ -1163,6 +1178,9 @@ function regionTouchesSuggestionRange(region, baseStart, baseEnd) {
   return region.baseStart < baseEnd && regionEnd > baseStart;
 }
 function currentSuggestionRange(markdown, suggestion, anchor) {
+  const anchoredRange = currentAnchorRange(markdown, suggestion, anchor);
+  if (anchoredRange) return anchoredRange;
+  if (anchor && !anchorIsReliable(anchor)) return void 0;
   const hintedRange = suggestion.patch.range;
   if (rangeIsWithin(markdown, hintedRange) && extractLineRange(markdown, hintedRange) === suggestion.patch.before) return hintedRange;
   const candidates = findBeforeCandidates(markdown, suggestion.patch.before);
@@ -1177,6 +1195,14 @@ function currentSuggestionRange(markdown, suggestion, anchor) {
   if (best.score < 0.7) return void 0;
   return best.range;
 }
+function currentAnchorRange(markdown, suggestion, anchor) {
+  if (!anchor || !anchorIsReliable(anchor) || !anchor.range) return void 0;
+  if (!rangeIsWithin(markdown, anchor.range)) return void 0;
+  return extractLineRange(markdown, anchor.range) === suggestion.patch.before ? anchor.range : void 0;
+}
+function anchorIsReliable(anchor) {
+  return anchor.status === "mapped" && anchor.confidence >= 0.65;
+}
 function findBeforeCandidates(markdown, before) {
   const lines = getLines(markdown);
   const beforeLines = linePattern(before);
@@ -1200,22 +1226,22 @@ function linePattern(value) {
 function scoreContext2(markdown, range, anchor) {
   const lines = getLines(markdown);
   let score = anchor.selector.quote === extractLineRange(markdown, range) ? 0.7 : 0.65;
-  const expectedPrefix = contextPrefix(anchor.selector.prefix);
+  const expectedPrefix = contextPrefix2(anchor.selector.prefix);
   if (expectedPrefix) {
-    const actualPrefix = contextPrefix(lines.slice(Math.max(0, range.startLine - 4), range.startLine - 1).join("\n"));
+    const actualPrefix = contextPrefix2(lines.slice(Math.max(0, range.startLine - 4), range.startLine - 1).join("\n"));
     if (actualPrefix?.endsWith(expectedPrefix)) score += 0.15;
   }
-  const expectedSuffix = contextSuffix(anchor.selector.suffix);
+  const expectedSuffix = contextSuffix2(anchor.selector.suffix);
   if (expectedSuffix) {
-    const actualSuffix = contextSuffix(lines.slice(range.endLine, range.endLine + 3).join("\n"));
+    const actualSuffix = contextSuffix2(lines.slice(range.endLine, range.endLine + 3).join("\n"));
     if (actualSuffix?.startsWith(expectedSuffix)) score += 0.15;
   }
   return Math.min(1, score);
 }
-function contextPrefix(value) {
+function contextPrefix2(value) {
   return value?.split(/\r?\n/).filter(Boolean).slice(-3).join("\n") || void 0;
 }
-function contextSuffix(value) {
+function contextSuffix2(value) {
   return value?.split(/\r?\n/).filter(Boolean).slice(0, 3).join("\n") || void 0;
 }
 
@@ -4606,44 +4632,46 @@ function gatherMarks(schema2, marks) {
 }
 
 // ../core/src/pm-schema.ts
+var blockAttrs = { blockId: { default: null } };
 var canonicalSchema = new Schema({
   nodes: {
     // The doc allows suggestion marks on its block children so pending
     // block-level suggestions (node marks) survive fromJSON and can be
     // structurally reverted before serialization.
     doc: { content: "block+", marks: "insertion deletion modification" },
-    paragraph: { group: "block", content: "inline*" },
+    paragraph: { group: "block", content: "inline*", attrs: blockAttrs },
     heading: {
       group: "block",
       content: "inline*",
-      attrs: { level: { default: 1 } }
+      attrs: { ...blockAttrs, level: { default: 1 } }
     },
-    blockquote: { group: "block", content: "block+" },
+    blockquote: { group: "block", content: "block+", attrs: blockAttrs },
     codeBlock: {
       group: "block",
       content: "text*",
       marks: "",
       code: true,
-      attrs: { language: { default: null } }
+      attrs: { ...blockAttrs, language: { default: null } }
     },
-    horizontalRule: { group: "block" },
-    bulletList: { group: "block", content: "listItem+" },
+    horizontalRule: { group: "block", attrs: blockAttrs },
+    bulletList: { group: "block", content: "listItem+", attrs: blockAttrs },
     orderedList: {
       group: "block",
       content: "listItem+",
-      attrs: { start: { default: 1 } }
+      attrs: { ...blockAttrs, start: { default: 1 } }
     },
-    listItem: { content: "paragraph block*" },
-    taskList: { group: "block", content: "taskItem+" },
+    listItem: { content: "paragraph block*", attrs: blockAttrs },
+    taskList: { group: "block", content: "taskItem+", attrs: blockAttrs },
     taskItem: {
       content: "paragraph block*",
-      attrs: { checked: { default: false } }
+      attrs: { ...blockAttrs, checked: { default: false } }
     },
-    table: { group: "block", content: "tableRow+" },
-    tableRow: { content: "(tableCell | tableHeader)+" },
+    table: { group: "block", content: "tableRow+", attrs: blockAttrs },
+    tableRow: { content: "(tableCell | tableHeader)+", attrs: blockAttrs },
     tableHeader: {
       content: "block+",
       attrs: {
+        ...blockAttrs,
         colspan: { default: 1 },
         rowspan: { default: 1 },
         colwidth: { default: null }
@@ -4652,6 +4680,7 @@ var canonicalSchema = new Schema({
     tableCell: {
       content: "block+",
       attrs: {
+        ...blockAttrs,
         colspan: { default: 1 },
         rowspan: { default: 1 },
         colwidth: { default: null }
@@ -10950,6 +10979,36 @@ function backticksFor2(node, side) {
   return result;
 }
 
+// ../core/src/pm-parse.ts
+var parser = new MarkdownParser(canonicalSchema, new lib_default(), {
+  blockquote: { block: "blockquote" },
+  paragraph: { block: "paragraph" },
+  list_item: { block: "listItem" },
+  bullet_list: { block: "bulletList" },
+  ordered_list: {
+    block: "orderedList",
+    getAttrs: (tok) => ({ start: Number(tok.attrGet("start")) || 1 })
+  },
+  heading: { block: "heading", getAttrs: (tok) => ({ level: Number(tok.tag.slice(1)) || 1 }) },
+  code_block: { block: "codeBlock", noCloseToken: true },
+  fence: { block: "codeBlock", getAttrs: (tok) => ({ language: tok.info || null }), noCloseToken: true },
+  hr: { node: "horizontalRule" },
+  hardbreak: { node: "hardBreak" },
+  em: { mark: "italic" },
+  strong: { mark: "bold" },
+  s: { mark: "strike" },
+  link: { mark: "link", getAttrs: (tok) => ({ href: tok.attrGet("href") }) },
+  code_inline: { mark: "code", noCloseToken: true },
+  image: {
+    node: "image",
+    getAttrs: (tok) => ({
+      alt: tok.content,
+      src: tok.attrGet("src"),
+      title: tok.attrGet("title")
+    })
+  }
+});
+
 // ../core/src/remote-document-io.ts
 var RemoteDocumentIO = class {
   constructor(document) {
@@ -10997,7 +11056,7 @@ var RemoteDocumentIO = class {
 };
 
 // src/agent.ts
-var CLI_VERSION = "0.3.12";
+var CLI_VERSION = "0.3.13";
 var CLI_PACKAGE_NAME = "@magic-markdown/cli";
 var AGENT_COMMANDS = [
   {
@@ -11058,10 +11117,11 @@ var AGENT_COMMANDS = [
   {
     name: "remote",
     summary: "Read, organize, comment on, suggest edits to, monitor, and restore the active Magic Markdown remote join.",
-    usage: "mdocs remote map|graph|context|review|create-file|move-file|comment|suggest|reject|events|history|restore|library|create-folder|update-folder|move-root|invite-folder --json",
+    usage: "mdocs remote status|map|graph|context|review|create-file|move-file|comment|suggest|reject|events|history|restore|library|create-folder|update-folder|move-root|invite-folder --json",
     output: "json",
     mutates: true,
     examples: [
+      "mdocs remote status --expect-scope file --expect-root root_abc --expect-doc doc_abc --json",
       "mdocs remote context --summary --json",
       "mdocs remote context --start-line 1 --end-line 100 --no-review --json",
       "mdocs remote context --start-line 101 --end-line 200 --no-review --json",
@@ -11081,6 +11141,7 @@ var AGENT_COMMANDS = [
       "mdocs remote invite-folder fold_abc123 --email person@example.com --role edit --json"
     ],
     notes: [
+      "Use remote status --json immediately after joining when the handoff includes expected scope/root/doc values. If it reports wrong_binding, stop and ask for the correct share or connector.",
       "Use remote context --summary --json first on file-scoped joins and before reading large documents. It returns metadata, heading line numbers, current head, review counts, and suggested next commands without dumping Markdown.",
       "remote context accepts --start-line and --end-line (1-based, inclusive) to page through large documents. The response always includes totalLines, startLine, and endLine \u2014 if totalLines > endLine, request the next page with --start-line <endLine+1>.",
       "Use remote context --no-review when reading document content only; use remote review to list open comments, open suggestions, and anchors separately.",
@@ -11358,11 +11419,12 @@ Run \`mdocs help <command>\` (or \`mdocs <command> --help\`) for usage, examples
 ## Start Here
 
 1. If given a Magic Markdown share URL, run \`mdocs join <share-url> --json\` first, and always include \`--name "<your agent name>"\` (for example \`--name "Claude Code"\`) so collaborators can see which agent is connected. Use \`mdocs remote ...\` commands after joining.
-2. If working in a local workspace, run \`mdocs doctor --json\` to validate the workspace and learn recommended next commands.
-3. Run \`mdocs map --json\` or \`mdocs remote map --json\` to list documents, paths, docIds, open comments, open suggestions, anchor review counts, and link counts. File-scoped joins (most share links) cover a single document, so \`mdocs remote map\` is unavailable for them \u2014 use \`mdocs remote context --summary --json\` instead. Project-scoped joins cover one root; workspace-scoped joins cover Home and can target duplicate paths as \`<rootId>:<path-or-docId>\`.
-4. Run \`mdocs graph --json\` or project-scoped \`mdocs remote graph --json\` before broad edits to inspect the Obsidian-style document graph built from Markdown links and wikilinks.
-5. For a document, run \`mdocs context <path|docId> --summary --json\` locally or \`mdocs remote context <path|docId> --summary --json\` for a joined share before reading full content. Then page Markdown with \`--start-line\` / \`--end-line\` and \`--no-review\` when you only need document text.
-6. Pull review state separately with \`mdocs review <path|docId> --json\` locally or \`mdocs remote review <path|docId> --json\` for a joined share. Use \`mdocs comment\` / \`mdocs remote comment\` for review notes and \`mdocs suggest\` / \`mdocs remote suggest\` for proposed replacements. Do not insert comments, CriticMarkup, directives, or Magic markers into Markdown files.
+2. If the handoff includes expected binding values, run \`mdocs remote status --expect-scope <file|project> --expect-root <rootId> --expect-doc <docId> --json\` after joining. If it reports \`wrong_binding\`, stop and ask for the correct share or connector.
+3. If working in a local workspace, run \`mdocs doctor --json\` to validate the workspace and learn recommended next commands.
+4. Run \`mdocs map --json\` or \`mdocs remote map --json\` to list documents, paths, docIds, open comments, open suggestions, anchor review counts, and link counts. File-scoped joins (most share links) cover a single document, so \`mdocs remote map\` is unavailable for them \u2014 use \`mdocs remote context --summary --json\` instead. Project-scoped joins cover one root; workspace-scoped joins cover Home and can target duplicate paths as \`<rootId>:<path-or-docId>\`.
+5. Run \`mdocs graph --json\` or project-scoped \`mdocs remote graph --json\` before broad edits to inspect the Obsidian-style document graph built from Markdown links and wikilinks.
+6. For a document, run \`mdocs context <path|docId> --summary --json\` locally or \`mdocs remote context <path|docId> --summary --json\` for a joined share before reading full content. Then page Markdown with \`--start-line\` / \`--end-line\` and \`--no-review\` when you only need document text.
+7. Pull review state separately with \`mdocs review <path|docId> --json\` locally or \`mdocs remote review <path|docId> --json\` for a joined share. Use \`mdocs comment\` / \`mdocs remote comment\` for review notes and \`mdocs suggest\` / \`mdocs remote suggest\` for proposed replacements. Do not insert comments, CriticMarkup, directives, or Magic markers into Markdown files.
 
 ## Filesystem Bridge / Resume
 
@@ -11407,7 +11469,7 @@ If Magic and the local root both changed the same document while you were offlin
 ## Errors, Conflicts, and Exit Codes
 
 - Errors go to stderr. With \`--json\` they are structured: \`{ "ok": false, "error": { "code", "message", "hint" }, "cliVersion" }\`. Follow the \`hint\`.
-- Exit codes: 0 ok, 1 internal, 2 usage/invalid range, 3 conflict, 4 not found, 5 network, 6 unauthorized (share link revoked or expired).
+- Exit codes: 0 ok, 1 internal, 2 usage/invalid range, 3 conflict, 4 not found or wrong binding, 5 network, 6 unauthorized (share link revoked or expired).
 - \`remote comment\` and \`remote suggest\` are concurrency-safe: the server merges review additions without clobbering concurrent edits, and the CLI rebases and retries automatically. A surviving \`conflict\` error means the document is changing rapidly \u2014 refetch context and retry.
 - \`remote events --json\` may return \`"truncated": true\` when older events were dropped from the bounded event log. Do not assume nothing happened; refetch with \`mdocs remote context --summary --json\`, then read needed pages and review state.
 - Retries are safe: remote writes carry a changeId and the server deduplicates replays.
@@ -11431,7 +11493,7 @@ Start the local stdio MCP server with:
 mdocs serve-mcp --cwd /path/to/workspace
 \`\`\`
 
-The MCP server exposes document resources, image resources, workspace map and graph resources, an agent guide resource, typed tools for comments and suggestions, and the \`magic_markdown_agent_workflow\` prompt. Use \`mdocs_context\` / \`magic_context\` with \`summary: true\` before dumping Markdown; use \`includeReview: false\` for content-only reads and \`mdocs_review\` / \`magic_review\` for review state.
+The MCP server exposes document resources, image resources, workspace map and graph resources, an agent guide resource, typed tools for comments and suggestions, and the \`magic_markdown_agent_workflow\` prompt. Use \`magic_status\` first when expected binding values are available; stop if it returns \`wrong_binding\`. Then use \`mdocs_context\` / \`magic_context\` with \`summary: true\` before dumping Markdown; use \`includeReview: false\` for content-only reads and \`mdocs_review\` / \`magic_review\` for review state.
 `;
 }
 function formatCommandReference() {
@@ -11459,6 +11521,7 @@ var CLI_EXIT_CODES = {
   invalid_range: 2,
   conflict: 3,
   not_found: 4,
+  wrong_binding: 4,
   network_error: 5,
   unauthorized: 6
 };
@@ -12511,6 +12574,16 @@ async function postReview(record, docId, additions, actor) {
   );
   return response.document;
 }
+async function postReviewOperation(record, docId, operation, actor) {
+  return fetchJson(
+    `${record.origin}/api/workspaces/${encodeURIComponent(record.workspaceId)}/roots/${encodeURIComponent(record.rootId)}/documents/${encodeURIComponent(docId)}/review-ops`,
+    {
+      method: "POST",
+      headers: { ...shareHeaders(record.shareUrl), "Content-Type": "application/json" },
+      body: JSON.stringify({ actor, operation })
+    }
+  );
+}
 async function pushDocument(record, baseDocument, markdown, sidecar) {
   const createdAt = (/* @__PURE__ */ new Date()).toISOString();
   const payload = {
@@ -12808,6 +12881,8 @@ async function runJoinsCommand(root) {
 async function runRemoteCommand(root, subcommand, parsed) {
   const record = await normalizedSelectedJoin(root, parsed.flags);
   switch (subcommand) {
+    case "status":
+      return remoteStatus(record, parsed.flags);
     case "map":
     case void 0: {
       if (record.scope === "file") {
@@ -12861,10 +12936,53 @@ async function runRemoteCommand(root, subcommand, parsed) {
       return rejoin(root, record.joinId, parsed.flags);
     default:
       throw new CliError("usage_error", `Unknown remote subcommand: ${subcommand}`, {
-        hint: "Use mdocs remote map|graph|context|review|create-file|move-file|comment|suggest|reject|events|history|restore|library|create-folder|update-folder|move-root|invite-folder|rejoin."
+        hint: "Use mdocs remote status|map|graph|context|review|create-file|move-file|comment|suggest|reject|events|history|restore|library|create-folder|update-folder|move-root|invite-folder|rejoin."
       });
   }
 }
+async function remoteStatus(record, flags) {
+  const document = record.rootId && record.docId ? (await fetchState(record)).document : void 0;
+  const expected = expectedBinding(flags);
+  const actual = {
+    joinId: record.joinId,
+    scope: record.scope,
+    workspaceId: record.workspaceId,
+    rootId: record.rootId,
+    docId: document?.docId ?? record.docId,
+    path: document?.path,
+    currentHead: document?.currentSha ?? record.currentHead,
+    agent: { id: record.agentId, name: record.agentName },
+    currentDocument: document ? {
+      docId: document.docId,
+      path: document.path,
+      title: document.title,
+      currentSha: document.currentSha
+    } : void 0
+  };
+  const mismatches = bindingMismatches(expected, actual);
+  if (mismatches.length > 0) {
+    throw new CliError("wrong_binding", "This Magic binding is for a different document or scope.", {
+      hint: "Use the connector URL or CLI join command from the handoff copy.",
+      details: {
+        expected,
+        actual,
+        verification: { matches: false, mismatches }
+      }
+    });
+  }
+  return {
+    ok: true,
+    connected: true,
+    ...actual,
+    expected,
+    verification: { matches: true, mismatches: [] },
+    nextCommands: [
+      record.scope === "workspace" ? "mdocs remote map --json" : void 0,
+      record.scope === "project" ? "mdocs remote map --json" : void 0,
+      record.scope === "workspace" ? void 0 : "mdocs remote context --summary --json"
+    ].filter(Boolean)
+  };
+}
 async function remoteGraph(record) {
   assertProjectScope(record, "graph");
   const rootRecord = assertRootScoped(record, "graph");
@@ -13108,13 +13226,24 @@ async function remoteSuggest(root, record, parsed) {
   const replacement = await readRequiredTextFlag(parsed.flags, root, ["with", "replacement"]);
   const message = await readOptionalTextFlag(parsed.flags, root, ["message"]) ?? "Suggested edit";
   const range = parseRange(requiredFlag(parsed.flags, "range"));
-  const result = await submitReview(
-    root,
-    record,
-    parsed.command[2] ?? record.docId,
-    (io, docId) => addSuggestion(io, docId, range, replacement, message, actorForRecord(record))
+  const pathOrDocId = parsed.command[2] ?? record.docId;
+  if (!pathOrDocId) {
+    throw new CliError("usage_error", "Missing document path or docId.", {
+      hint: "Pass a document path or docId, or join with --doc <docId>."
+    });
+  }
+  const document = await fetchDocument(record, pathOrDocId);
+  const documentRecord = rootScopedRecordFor(record, document.rootId);
+  await refreshPresence(documentRecord, document.docId);
+  const result = await postReviewOperation(
+    documentRecord,
+    document.docId,
+    { kind: "create_suggestion", payload: { ...range, replacement, message } },
+    actorForRecord(record)
   );
-  return { suggestion: result.created, document: result.document };
+  if (result.document) await recordHead(root, record, result.document);
+  const placementStatus = result.reviewRecord?.placement?.status;
+  return { suggestion: result.suggestion, reviewRecord: result.reviewRecord, placementStatus, projectionStatus: result.projectionStatus, document: result.document };
 }
 async function remoteCreateFolder(record, parsed) {
   assertProjectScope(record, "create-folder");
@@ -13379,6 +13508,33 @@ function joinSummary(record, document) {
     ].filter(Boolean)
   };
 }
+function expectedBinding(flags) {
+  const scope = stringFlag(flags, "expect-scope", "expected-scope");
+  const rootId = stringFlag(flags, "expect-root", "expected-root");
+  const docId = stringFlag(flags, "expect-doc", "expected-doc");
+  const path = stringFlag(flags, "expect-path", "expected-path");
+  return {
+    ...scope ? { scope } : {},
+    ...rootId ? { rootId } : {},
+    ...docId ? { docId } : {},
+    ...path ? { path } : {}
+  };
+}
+function stringFlag(flags, primary, alias) {
+  const value = flags[primary] ?? flags[alias];
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function bindingMismatches(expected, actual) {
+  const checks = [
+    ["scope", expected.scope, actual.scope],
+    ["rootId", expected.rootId, actual.rootId],
+    ["docId", expected.docId, actual.docId],
+    ["path", expected.path, actual.path]
+  ];
+  return checks.flatMap(
+    ([field, expectedValue, actualValue]) => expectedValue && expectedValue !== actualValue ? [{ field, expected: expectedValue, actual: actualValue }] : []
+  );
+}
 function assertProjectScope(record, command) {
   if (record.scope === "project") return;
   throw new CliError("usage_error", `remote ${command} requires a project-scoped join.`, {
@@ -14575,6 +14731,7 @@ Commands:
   checkpoint create|list|restore      Manage local reversible checkpoints
   join <share-url> --json             Join a Magic Markdown share through the CLI
   joins --json                        List saved Magic Markdown remote joins
+  remote status --json                Verify the active remote join binding
   remote map|graph|context|review|create-file|move-file
                                       Work with documents in the active remote join
   remote comment|suggest              Add remote review comments and suggestions
@@ -14643,7 +14800,8 @@ main().catch((error) => {
         code: cliError.code,
         message: cliError.message,
         ...hint ? { hint } : {},
-        ...usage && cliError.hint ? { usage } : {}
+        ...usage && cliError.hint ? { usage } : {},
+        ...cliError.details !== void 0 ? { details: cliError.details } : {}
       },
       cliVersion: CLI_VERSION
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@magic-markdown/cli",
-  "version": "0.3.12",
+  "version": "0.3.13",
   "description": "Magic Markdown agent CLI (mdocs): read, review, comment on, suggest edits to, and sync clean Markdown workspaces.",
   "type": "module",
   "license": "MIT",