@cmnwlth/sync 0.1.0

package/LICENSE

@@ -0,0 +1,202 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2026 Kristof Feys
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/index.js

@@ -0,0 +1,582 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import path4 from "path";
+import { parseArgs } from "util";
+import { resolveBrainDir } from "@cmnwlth/core";
+
+// src/daemon.ts
+import { promises as fs3 } from "fs";
+import path3 from "path";
+import chokidar from "chokidar";
+
+// src/engine.ts
+import { buildIndex, regenerateDerived } from "@cmnwlth/core";
+
+// src/conflict.ts
+import { promises as fs2 } from "fs";
+import path2 from "path";
+import { makeNoteId, parseNote, serializeNote, writeNote } from "@cmnwlth/core";
+
+// src/git.ts
+import { promises as fs } from "fs";
+import path from "path";
+import { findSecrets, loadBrainConfig, scanOptions } from "@cmnwlth/core";
+import { simpleGit } from "simple-git";
+var NOTE_DIRS = ["memory", "decisions", "work-state", "people"];
+function isNoteFile(rel) {
+  if (!rel.endsWith(".md")) return false;
+  const parts = rel.split("/");
+  const name = parts[parts.length - 1];
+  const parent = parts[parts.length - 2];
+  if (name === "INDEX.md") return false;
+  return parent !== void 0 && NOTE_DIRS.includes(parent);
+}
+function isScannableForSecrets(rel) {
+  if (isNoteFile(rel)) return true;
+  const name = rel.split("/").pop();
+  return name === "COMMONWEALTH.md" || name === "INDEX.md";
+}
+function openRepo(dir) {
+  return simpleGit(dir, {
+    // core.quotepath=false: git otherwise octal-escapes and double-quotes non-ASCII paths in
+    // porcelain output (e.g. `"caf\303\251/x.md"`), which broke `isNoteFile` — the trailing quote
+    // fails the `.md` check — so a secret in a non-ASCII-named note was never scanned (#99).
+    config: ["core.editor=true", "core.quotepath=false"],
+    // core.editor is on simple-git's block list; we set it to the non-interactive `true`
+    // binary purely so unattended `rebase --continue` can record its commit.
+    unsafe: { allowUnsafeEditor: true }
+  });
+}
+async function stagedFiles(dir) {
+  const out = await openRepo(dir).diff(["--cached", "--name-only", "-z"]);
+  return out.split("\0").filter((l) => l.length > 0);
+}
+async function unstage(dir, files) {
+  if (files.length === 0) return;
+  await openRepo(dir).raw(["reset", "-q", "--", ...files]);
+}
+async function commitAllExceptSecrets(dir, message) {
+  const git = openRepo(dir);
+  await git.add(["-A"]);
+  const secretsBlocked = await scrubStagedSecrets(dir);
+  const status = await git.status();
+  if (status.staged.length === 0) return { committed: false, secretsBlocked };
+  await git.commit(message);
+  return { committed: true, secretsBlocked };
+}
+async function scrubStagedSecrets(dir) {
+  const opts = scanOptions(await loadBrainConfig(dir));
+  const secretsBlocked = [];
+  for (const rel of await stagedFiles(dir)) {
+    if (!isScannableForSecrets(rel)) continue;
+    let content;
+    try {
+      content = await fs.readFile(path.join(dir, rel), "utf8");
+    } catch {
+      continue;
+    }
+    if (findSecrets(content, opts).length > 0) secretsBlocked.push(rel);
+  }
+  await unstage(dir, secretsBlocked);
+  return secretsBlocked;
+}
+async function hasRemote(dir) {
+  const remotes = await openRepo(dir).getRemotes();
+  return remotes.some((r) => r.name === "origin");
+}
+async function conflictedPaths(dir) {
+  return (await openRepo(dir).status()).conflicted;
+}
+async function pullRebase(dir) {
+  const git = openRepo(dir);
+  if (!await hasRemote(dir)) return { conflicts: false };
+  const status = await git.status();
+  const branch = status.current;
+  if (!branch) return { conflicts: false };
+  await git.fetch("origin");
+  let upstream = status.tracking;
+  if (!upstream) {
+    const remoteBranches = await git.branch(["-r"]);
+    const candidate = `origin/${branch}`;
+    if (remoteBranches.all.includes(candidate)) upstream = candidate;
+  }
+  if (!upstream) return { conflicts: false };
+  try {
+    await git.raw(["rebase", "--autostash", upstream]);
+    return { conflicts: false };
+  } catch (err) {
+    const conflicted = (await git.status()).conflicted;
+    if (conflicted.length > 0) return { conflicts: true };
+    throw err;
+  }
+}
+async function abortRebase(dir) {
+  try {
+    await openRepo(dir).raw(["rebase", "--abort"]);
+  } catch {
+  }
+}
+async function isRebasing(dir) {
+  const gitDir = (await openRepo(dir).revparse(["--git-dir"])).trim();
+  const base = path.isAbsolute(gitDir) ? gitDir : path.join(dir, gitDir);
+  for (const name of ["rebase-merge", "rebase-apply"]) {
+    try {
+      await fs.access(path.join(base, name));
+      return true;
+    } catch {
+    }
+  }
+  return false;
+}
+async function needsPush(dir) {
+  if (!await hasRemote(dir)) return false;
+  const status = await openRepo(dir).status();
+  if (!status.current) return false;
+  if (!status.tracking) return true;
+  return status.ahead > 0;
+}
+async function push(dir) {
+  const git = openRepo(dir);
+  if (!await hasRemote(dir)) return;
+  const branch = (await git.status()).current;
+  if (!branch) return;
+  await git.push(["-u", "origin", branch]);
+}
+
+// src/conflict.ts
+async function showStage(dir, stage, relPath) {
+  try {
+    return await openRepo(dir).raw(["show", `:${stage}:${relPath}`]);
+  } catch {
+    return null;
+  }
+}
+async function writeSibling(brainDir, relPath, raw, side) {
+  const dir = path2.posix.dirname(relPath);
+  const base = path2.posix.basename(relPath, ".md");
+  let note = null;
+  try {
+    note = parseNote(raw, relPath);
+  } catch {
+    note = null;
+  }
+  if (note) {
+    const newId = makeNoteId(`${note.frontmatter.title} (${side})`, note.frontmatter.created);
+    const newRel2 = `${dir}/${newId}.md`;
+    const rewritten = {
+      ...note,
+      frontmatter: { ...note.frontmatter, id: newId },
+      path: newRel2
+    };
+    await fs2.writeFile(path2.join(brainDir, newRel2), serializeNote(rewritten), "utf8");
+    return newRel2;
+  }
+  const newRel = `${dir}/${base}-${side}-${randomTag()}.md`;
+  await fs2.writeFile(path2.join(brainDir, newRel), raw, "utf8");
+  return newRel;
+}
+function randomTag() {
+  return Math.random().toString(36).slice(2, 6);
+}
+async function resolveConflictsAsSiblings(brainDir, conflictedPaths2) {
+  const git = openRepo(brainDir);
+  const resolved = [];
+  for (const relPath of conflictedPaths2) {
+    const remoteRaw = await showStage(brainDir, 2, relPath);
+    const localRaw = await showStage(brainDir, 3, relPath);
+    const abs = path2.join(brainDir, relPath);
+    if (localRaw !== null && remoteRaw !== null) {
+      const oursPath = await writeSibling(brainDir, relPath, localRaw, "ours");
+      const theirsPath = await writeSibling(brainDir, relPath, remoteRaw, "theirs");
+      await fs2.rm(abs, { force: true });
+      resolved.push({ original: relPath, oursPath, theirsPath });
+      continue;
+    }
+    const survivor = localRaw ?? remoteRaw;
+    if (survivor !== null) {
+      await fs2.writeFile(abs, survivor, "utf8");
+      resolved.push({ original: relPath, oursPath: relPath, theirsPath: relPath });
+    } else {
+      await fs2.rm(abs, { force: true });
+      resolved.push({ original: relPath, oursPath: relPath, theirsPath: relPath });
+    }
+  }
+  if (resolved.length > 0) {
+    const lines = resolved.map(
+      (r) => `- \`${r.original}\` \u2192 ours: \`${r.oursPath}\`, theirs: \`${r.theirsPath}\``
+    );
+    await writeNote(brainDir, {
+      kind: "memory",
+      title: `Sync conflict resolved as siblings (${resolved.length})`,
+      tags: ["conflict"],
+      body: [
+        "A same-file sync conflict was auto-resolved without data loss: both versions",
+        "were kept as separate sibling notes for review. Reconcile and supersede as needed.",
+        "",
+        ...lines
+      ].join("\n")
+    });
+  }
+  await git.add(["-A"]);
+  await scrubStagedSecrets(brainDir);
+  try {
+    await git.raw(["rebase", "--continue"]);
+  } catch {
+    const status = await git.status();
+    if (status.conflicted.length === 0) {
+      try {
+        await git.raw(["rebase", "--skip"]);
+      } catch {
+      }
+    }
+  }
+  return resolved;
+}
+
+// src/lock.ts
+import { acquireSyncLock } from "@cmnwlth/core";
+
+// src/queue.ts
+var SerialQueue = class {
+  /** Tail of the promise chain; each enqueue appends to it. */
+  tail = Promise.resolve();
+  /**
+   * Run `fn` after every previously-enqueued task has settled. Returns a promise for
+   * `fn`'s result. A rejection in one task does not break the chain — later tasks still
+   * run — but it is propagated to that task's own caller.
+   */
+  enqueue(fn) {
+    const run = this.tail.then(() => fn());
+    this.tail = run.then(
+      () => void 0,
+      () => void 0
+    );
+    return run;
+  }
+};
+
+// src/engine.ts
+var NOOP_SUMMARY = {
+  committed: false,
+  pulled: false,
+  pushed: false,
+  conflicts: [],
+  secretsBlocked: []
+};
+var MAX_REBASE_ROUNDS = 50;
+var SyncEngine = class {
+  brainDir;
+  queue;
+  constructor(brainDir, opts = {}) {
+    this.brainDir = brainDir;
+    this.queue = opts.queue ?? new SerialQueue();
+  }
+  /** Run one full sync cycle, serialized against every other queued mutation. */
+  syncOnce() {
+    return this.queue.enqueue(() => this.runSyncOnce());
+  }
+  async runSyncOnce() {
+    const dir = this.brainDir;
+    const release = await acquireSyncLock(dir);
+    if (!release) return { ...NOOP_SUMMARY };
+    try {
+      if (await isRebasing(dir)) await abortRebase(dir);
+      return await this.syncLocked(dir);
+    } finally {
+      await release();
+    }
+  }
+  /** The sync cycle proper, run while holding the cross-process lock (see {@link runSyncOnce}). */
+  async syncLocked(dir) {
+    const { committed, secretsBlocked } = await commitAllExceptSecrets(
+      dir,
+      "commonwealth: sync local changes"
+    );
+    const remote = await hasRemote(dir);
+    let pulled = false;
+    const conflicts = [];
+    if (remote) {
+      const { conflicts: hadConflict } = await pullRebase(dir);
+      pulled = true;
+      if (hadConflict) {
+        let rounds = 0;
+        while (await isRebasing(dir)) {
+          if (rounds++ >= MAX_REBASE_ROUNDS) {
+            throw new Error(`Rebase did not converge after ${MAX_REBASE_ROUNDS} rounds`);
+          }
+          const paths = await conflictedPaths(dir);
+          if (paths.length === 0) break;
+          conflicts.push(...await resolveConflictsAsSiblings(dir, paths));
+        }
+      }
+    }
+    await buildIndex(dir);
+    await regenerateDerived(dir);
+    const derived = await commitAllExceptSecrets(dir, "commonwealth: regenerate derived index");
+    for (const p of derived.secretsBlocked) {
+      if (!secretsBlocked.includes(p)) secretsBlocked.push(p);
+    }
+    let pushed = false;
+    if (remote && await needsPush(dir)) {
+      await push(dir);
+      pushed = true;
+    }
+    return { committed, pulled, pushed, conflicts, secretsBlocked };
+  }
+};
+
+// src/daemon.ts
+var COMMONWEALTH_DIR = ".commonwealth";
+var PID_FILE = "sync.pid";
+function makeIgnored(brainDir) {
+  const gitDir = path3.join(brainDir, ".git");
+  const indexDir = path3.join(brainDir, "index");
+  const commonwealthDir = path3.join(brainDir, COMMONWEALTH_DIR);
+  const stagingDir = path3.join(brainDir, "staging");
+  const commonwealthMd = path3.join(brainDir, "COMMONWEALTH.md");
+  return (p) => {
+    if (p === gitDir || p.startsWith(gitDir + path3.sep)) return true;
+    if (p === indexDir || p.startsWith(indexDir + path3.sep)) return true;
+    if (p === commonwealthDir || p.startsWith(commonwealthDir + path3.sep)) return true;
+    if (p === stagingDir || p.startsWith(stagingDir + path3.sep)) return true;
+    if (/\.db(-shm|-wal)?$/.test(p)) return true;
+    if (p.endsWith(".tmp")) return true;
+    if (p === commonwealthMd) return true;
+    if (path3.basename(p) === "INDEX.md") return true;
+    return false;
+  };
+}
+var DRAIN_TIMEOUT_MS = 3e4;
+var Daemon = class {
+  engine;
+  watcher;
+  timer;
+  debounceTimer;
+  queue = new SerialQueue();
+  opts = {};
+  /** True while a sync is running; a trigger during it coalesces into one re-run. */
+  syncing = false;
+  /** A trigger arrived while `syncing` — run exactly one more pass when the current one ends. */
+  rerun = false;
+  stopping = false;
+  /**
+   * Start watching + polling `brainDir`. Runs an initial sync, then wires the watcher and
+   * poll loop. Writes a PID file so a separate CLI `status`/`stop` can find this process.
+   * Refuses to start if another daemon is already running for this brain (#100), so two
+   * daemons never race the same repo.
+   */
+  async start(brainDir, opts = {}) {
+    if (await isRunning(brainDir)) {
+      throw new Error(
+        `A Commonwealth sync daemon is already running for ${brainDir} (pid ${await readPid(brainDir)}). Stop it first, or run \`commonwealth sync stop\`.`
+      );
+    }
+    const intervalMs = opts.intervalMs ?? 15e3;
+    const debounceMs = opts.debounceMs ?? 500;
+    this.opts = opts;
+    this.engine = new SyncEngine(brainDir, { queue: this.queue });
+    await writePid(brainDir);
+    await this.runSync();
+    this.watcher = chokidar.watch(brainDir, {
+      ignored: makeIgnored(brainDir),
+      ignoreInitial: true,
+      persistent: true
+    });
+    const onFsEvent = () => {
+      if (this.debounceTimer) clearTimeout(this.debounceTimer);
+      this.debounceTimer = setTimeout(() => void this.runSync(), debounceMs);
+    };
+    this.watcher.on("add", onFsEvent).on("change", onFsEvent).on("unlink", onFsEvent);
+    this.timer = setInterval(() => void this.runSync(), intervalMs);
+  }
+  /**
+   * Run a sync, COALESCING concurrent triggers (#100). The watcher and the poll timer both call
+   * this; if a sync is already running, we just mark `rerun` instead of enqueuing another — so a
+   * sync that outlasts the poll interval can never grow an unbounded backlog. When the running
+   * pass ends, we do exactly one more if any trigger arrived meanwhile.
+   */
+  async runSync() {
+    if (this.syncing) {
+      this.rerun = true;
+      return;
+    }
+    this.syncing = true;
+    try {
+      do {
+        this.rerun = false;
+        if (this.stopping) return;
+        try {
+          const summary = await this.engine.syncOnce();
+          this.opts.onSync?.(summary);
+        } catch (err) {
+          this.opts.onError?.(err);
+        }
+      } while (this.rerun);
+    } finally {
+      this.syncing = false;
+    }
+  }
+  /**
+   * Tear down watcher + timers, DRAIN any in-flight sync (bounded by {@link DRAIN_TIMEOUT_MS}),
+   * then remove the PID file. Draining means a SIGTERM no longer exits mid `git commit`/`rebase`/
+   * `push`, which would strand the repo (#100). Safe to call more than once.
+   */
+  async stop() {
+    this.stopping = true;
+    if (this.debounceTimer) {
+      clearTimeout(this.debounceTimer);
+      this.debounceTimer = void 0;
+    }
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = void 0;
+    }
+    if (this.watcher) {
+      await this.watcher.close();
+      this.watcher = void 0;
+    }
+    await Promise.race([
+      this.queue.enqueue(() => Promise.resolve()),
+      new Promise((resolve) => setTimeout(resolve, DRAIN_TIMEOUT_MS))
+    ]);
+    if (this.engine) {
+      await removePid(this.engine.brainDir);
+    }
+  }
+};
+function pidPath(brainDir) {
+  return path3.join(brainDir, COMMONWEALTH_DIR, PID_FILE);
+}
+async function writePid(brainDir) {
+  const file = pidPath(brainDir);
+  await fs3.mkdir(path3.dirname(file), { recursive: true });
+  await fs3.writeFile(file, `${process.pid}
+`, "utf8");
+}
+async function readPid(brainDir) {
+  try {
+    const raw = await fs3.readFile(pidPath(brainDir), "utf8");
+    const pid = Number.parseInt(raw.trim(), 10);
+    return Number.isFinite(pid) ? pid : null;
+  } catch {
+    return null;
+  }
+}
+async function isRunning(brainDir) {
+  const pid = await readPid(brainDir);
+  if (pid === null) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function removePid(brainDir) {
+  await fs3.rm(pidPath(brainDir), { force: true });
+}
+
+// src/format.ts
+function formatSyncSummary(s) {
+  let line = `[commonwealth-sync] sync: committed=${s.committed} pulled=${s.pulled} pushed=${s.pushed} conflicts=${s.conflicts.length}`;
+  if (s.secretsBlocked.length > 0) {
+    line += `
+[commonwealth-sync] withheld ${s.secretsBlocked.length} note(s) containing a secret (not committed/pushed): ${s.secretsBlocked.join(", ")}`;
+  }
+  return line;
+}
+
+// src/index.ts
+async function resolveDir(dirFlag) {
+  if (dirFlag && dirFlag.length > 0) return path4.resolve(dirFlag);
+  const env = process.env.COMMONWEALTH_BRAIN_DIR;
+  if (env && env.length > 0) return path4.resolve(env);
+  return resolveBrainDir(process.cwd());
+}
+async function cmdSync(dir) {
+  const engine = new SyncEngine(dir);
+  const summary = await engine.syncOnce();
+  console.error(formatSyncSummary(summary));
+}
+async function cmdStart(dir, intervalMs) {
+  const daemon = new Daemon();
+  await daemon.start(dir, {
+    intervalMs,
+    onSync: (s) => console.error(formatSyncSummary(s)),
+    onError: (err) => console.error("[commonwealth-sync] sync error:", err)
+  });
+  console.error(`[commonwealth-sync] daemon started on ${dir} (pid ${process.pid})`);
+  const shutdown = async () => {
+    console.error("[commonwealth-sync] shutting down");
+    await daemon.stop();
+    process.exit(0);
+  };
+  process.on("SIGINT", () => void shutdown());
+  process.on("SIGTERM", () => void shutdown());
+}
+async function cmdStatus(dir) {
+  const running = await isRunning(dir);
+  const pid = await readPid(dir);
+  if (running) {
+    console.error(`[commonwealth-sync] running on ${dir} (pid ${pid})`);
+  } else {
+    console.error(`[commonwealth-sync] not running on ${dir}`);
+  }
+}
+async function cmdStop(dir) {
+  const running = await isRunning(dir);
+  const pid = await readPid(dir);
+  if (running && pid !== null) {
+    process.kill(pid, "SIGTERM");
+    console.error(`[commonwealth-sync] sent SIGTERM to pid ${pid}`);
+  } else {
+    console.error(`[commonwealth-sync] no running daemon on ${dir}`);
+  }
+}
+async function main() {
+  const { values, positionals } = parseArgs({
+    allowPositionals: true,
+    options: {
+      dir: { type: "string" },
+      interval: { type: "string" }
+    }
+  });
+  const sub = positionals[0];
+  const dir = await resolveDir(values.dir);
+  if (dir === null) {
+    console.error(
+      `[commonwealth-sync] no Commonwealth brain configured for ${process.cwd()} \u2014 run \`commonwealth init\` here, add a registry mapping, or pass --dir <brain>.`
+    );
+    process.exit(1);
+  }
+  const interval = values.interval ? Number.parseInt(values.interval, 10) : void 0;
+  switch (sub) {
+    case "sync":
+      await cmdSync(dir);
+      return;
+    case "start":
+      await cmdStart(
+        dir,
+        interval !== void 0 && Number.isFinite(interval) ? interval : void 0
+      );
+      return;
+    // daemon keeps the event loop alive
+    case "status":
+      await cmdStatus(dir);
+      return;
+    case "stop":
+      await cmdStop(dir);
+      return;
+    default:
+      console.error(
+        "usage: commonwealth-sync <sync|start|status|stop> [--dir DIR] [--interval MS]"
+      );
+      process.exit(sub ? 1 : 2);
+  }
+}
+main().catch((err) => {
+  console.error("[commonwealth-sync] fatal:", err);
+  process.exit(1);
+});
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts","../src/daemon.ts","../src/engine.ts","../src/conflict.ts","../src/git.ts","../src/lock.ts","../src/queue.ts","../src/format.ts"],"sourcesContent":["import path from \"node:path\";\nimport { parseArgs } from \"node:util\";\nimport { resolveBrainDir } from \"@cmnwlth/core\";\nimport { Daemon, isRunning, readPid } from \"./daemon.js\";\nimport { SyncEngine } from \"./engine.js\";\nimport { formatSyncSummary } from \"./format.js\";\n\n/**\n * Commonwealth sync CLI (`commonwealth-sync`). Subcommands:\n *   sync   [--dir DIR]                 one-shot syncOnce, then exit\n *   start  [--dir DIR] [--interval MS] run the resident daemon in the foreground\n *   status [--dir DIR]                 report whether a daemon is running\n *   stop   [--dir DIR]                 signal a running daemon to exit\n *\n * DIR resolves as: `--dir` → `$COMMONWEALTH_BRAIN_DIR` → `@cmnwlth/core`'s registry\n * resolver against the cwd (marker → ancestor-brain → user registry, #69) → `null`. This\n * file carries NO shebang — tsup's banner adds exactly one at build time.\n */\n\n/**\n * Resolve the brain dir for the cwd, or `null` when none is configured (#69). Consulting the\n * registry (not just cwd) means `commonwealth-sync status` reports on the brain the working\n * directory actually maps to — the same one the MCP server and hooks use.\n */\nasync function resolveDir(dirFlag: string | undefined): Promise<string | null> {\n  if (dirFlag && dirFlag.length > 0) return path.resolve(dirFlag);\n  const env = process.env.COMMONWEALTH_BRAIN_DIR;\n  if (env && env.length > 0) return path.resolve(env);\n  return resolveBrainDir(process.cwd());\n}\n\nasync function cmdSync(dir: string): Promise<void> {\n  const engine = new SyncEngine(dir);\n  const summary = await engine.syncOnce();\n  console.error(formatSyncSummary(summary));\n}\n\nasync function cmdStart(dir: string, intervalMs: number | undefined): Promise<void> {\n  const daemon = new Daemon();\n  await daemon.start(dir, {\n    intervalMs,\n    onSync: (s) => console.error(formatSyncSummary(s)),\n    onError: (err) => console.error(\"[commonwealth-sync] sync error:\", err),\n  });\n  console.error(`[commonwealth-sync] daemon started on ${dir} (pid ${process.pid})`);\n\n  // Keep the process alive; tear down cleanly on termination signals.\n  const shutdown = async (): Promise<void> => {\n    console.error(\"[commonwealth-sync] shutting down\");\n    await daemon.stop();\n    process.exit(0);\n  };\n  process.on(\"SIGINT\", () => void shutdown());\n  process.on(\"SIGTERM\", () => void shutdown());\n}\n\nasync function cmdStatus(dir: string): Promise<void> {\n  const running = await isRunning(dir);\n  const pid = await readPid(dir);\n  if (running) {\n    console.error(`[commonwealth-sync] running on ${dir} (pid ${pid})`);\n  } else {\n    console.error(`[commonwealth-sync] not running on ${dir}`);\n  }\n}\n\nasync function cmdStop(dir: string): Promise<void> {\n  const running = await isRunning(dir);\n  const pid = await readPid(dir);\n  if (running && pid !== null) {\n    process.kill(pid, \"SIGTERM\");\n    console.error(`[commonwealth-sync] sent SIGTERM to pid ${pid}`);\n  } else {\n    console.error(`[commonwealth-sync] no running daemon on ${dir}`);\n  }\n}\n\nasync function main(): Promise<void> {\n  const { values, positionals } = parseArgs({\n    allowPositionals: true,\n    options: {\n      dir: { type: \"string\" },\n      interval: { type: \"string\" },\n    },\n  });\n\n  const sub = positionals[0];\n  const dir = await resolveDir(values.dir);\n  if (dir === null) {\n    console.error(\n      `[commonwealth-sync] no Commonwealth brain configured for ${process.cwd()} — run ` +\n        `\\`commonwealth init\\` here, add a registry mapping, or pass --dir <brain>.`,\n    );\n    process.exit(1);\n  }\n  const interval = values.interval ? Number.parseInt(values.interval, 10) : undefined;\n\n  switch (sub) {\n    case \"sync\":\n      await cmdSync(dir);\n      return;\n    case \"start\":\n      await cmdStart(\n        dir,\n        interval !== undefined && Number.isFinite(interval) ? interval : undefined,\n      );\n      return; // daemon keeps the event loop alive\n    case \"status\":\n      await cmdStatus(dir);\n      return;\n    case \"stop\":\n      await cmdStop(dir);\n      return;\n    default:\n      console.error(\n        \"usage: commonwealth-sync <sync|start|status|stop> [--dir DIR] [--interval MS]\",\n      );\n      process.exit(sub ? 1 : 2);\n  }\n}\n\nmain().catch((err) => {\n  console.error(\"[commonwealth-sync] fatal:\", err);\n  process.exit(1);\n});\n","import { promises as fs } from \"node:fs\";\nimport path from \"node:path\";\nimport chokidar, { type FSWatcher } from \"chokidar\";\nimport { SyncEngine, type SyncSummary } from \"./engine.js\";\nimport { SerialQueue } from \"./queue.js\";\n\n/** Options for {@link Daemon.start}. */\nexport interface DaemonOptions {\n  /** Background poll interval for inbound teammate changes (ms). Default 15000. */\n  intervalMs?: number;\n  /** Debounce window for filesystem-triggered syncs (ms). Default 500. */\n  debounceMs?: number;\n  /** Called after each background sync completes (for tests / logging). */\n  onSync?: (summary: SyncSummary) => void;\n  /** Called if a background sync throws (for tests / logging). */\n  onError?: (err: unknown) => void;\n}\n\n/** Directory Commonwealth owns for local process state (PID file, etc.). */\nconst COMMONWEALTH_DIR = \".commonwealth\";\nconst PID_FILE = \"sync.pid\";\n\n/**\n * Chokidar v4 `ignored` predicate. v4 takes a FUNCTION (not globs): the full path is\n * tested. We skip git internals, the derived (gitignored) index, sqlite sidecars, and\n * temp files — none of which should trigger a sync.\n */\nfunction makeIgnored(brainDir: string): (p: string) => boolean {\n  const gitDir = path.join(brainDir, \".git\");\n  const indexDir = path.join(brainDir, \"index\");\n  const commonwealthDir = path.join(brainDir, COMMONWEALTH_DIR);\n  const stagingDir = path.join(brainDir, \"staging\");\n  const commonwealthMd = path.join(brainDir, \"COMMONWEALTH.md\");\n  return (p: string): boolean => {\n    if (p === gitDir || p.startsWith(gitDir + path.sep)) return true;\n    if (p === indexDir || p.startsWith(indexDir + path.sep)) return true;\n    if (p === commonwealthDir || p.startsWith(commonwealthDir + path.sep)) return true;\n    // Per-user review queue: local-only, never synced (ADR-0008).\n    if (p === stagingDir || p.startsWith(stagingDir + path.sep)) return true;\n    if (/\\.db(-shm|-wal)?$/.test(p)) return true;\n    if (p.endsWith(\".tmp\")) return true;\n    // Derived artifacts are rewritten by every sync (regenerateDerived); watching them\n    // would make each sync retrigger the next — an unbounded loop. They are never a\n    // legitimate sync trigger, so ignore them.\n    if (p === commonwealthMd) return true;\n    if (path.basename(p) === \"INDEX.md\") return true;\n    return false;\n  };\n}\n\n/**\n * The resident sync daemon (ADR-0006): watches a brain working copy and continuously\n * converges it with the remote. On any filesystem change it debounces then runs a sync;\n * a periodic poll pulls inbound teammate changes even without local edits. Every sync\n * runs through the engine's serial queue, so watcher and poll can never race.\n */\n/** How long {@link Daemon.stop} waits for an in-flight sync to finish before giving up. */\nconst DRAIN_TIMEOUT_MS = 30_000;\n\nexport class Daemon {\n  private engine?: SyncEngine;\n  private watcher?: FSWatcher;\n  private timer?: NodeJS.Timeout;\n  private debounceTimer?: NodeJS.Timeout;\n  private readonly queue = new SerialQueue();\n  private opts: DaemonOptions = {};\n  /** True while a sync is running; a trigger during it coalesces into one re-run. */\n  private syncing = false;\n  /** A trigger arrived while `syncing` — run exactly one more pass when the current one ends. */\n  private rerun = false;\n  private stopping = false;\n\n  /**\n   * Start watching + polling `brainDir`. Runs an initial sync, then wires the watcher and\n   * poll loop. Writes a PID file so a separate CLI `status`/`stop` can find this process.\n   * Refuses to start if another daemon is already running for this brain (#100), so two\n   * daemons never race the same repo.\n   */\n  async start(brainDir: string, opts: DaemonOptions = {}): Promise<void> {\n    if (await isRunning(brainDir)) {\n      throw new Error(\n        `A Commonwealth sync daemon is already running for ${brainDir} (pid ${await readPid(brainDir)}). ` +\n          `Stop it first, or run \\`commonwealth sync stop\\`.`,\n      );\n    }\n\n    const intervalMs = opts.intervalMs ?? 15_000;\n    const debounceMs = opts.debounceMs ?? 500;\n    this.opts = opts;\n    this.engine = new SyncEngine(brainDir, { queue: this.queue });\n\n    await writePid(brainDir);\n\n    // Initial reconcile on startup.\n    await this.runSync();\n\n    // Filesystem watch → debounced sync. v4 `ignored` is a predicate over the full path.\n    this.watcher = chokidar.watch(brainDir, {\n      ignored: makeIgnored(brainDir),\n      ignoreInitial: true,\n      persistent: true,\n    });\n    const onFsEvent = (): void => {\n      if (this.debounceTimer) clearTimeout(this.debounceTimer);\n      this.debounceTimer = setTimeout(() => void this.runSync(), debounceMs);\n    };\n    this.watcher.on(\"add\", onFsEvent).on(\"change\", onFsEvent).on(\"unlink\", onFsEvent);\n\n    // Periodic poll for inbound changes.\n    this.timer = setInterval(() => void this.runSync(), intervalMs);\n  }\n\n  /**\n   * Run a sync, COALESCING concurrent triggers (#100). The watcher and the poll timer both call\n   * this; if a sync is already running, we just mark `rerun` instead of enqueuing another — so a\n   * sync that outlasts the poll interval can never grow an unbounded backlog. When the running\n   * pass ends, we do exactly one more if any trigger arrived meanwhile.\n   */\n  private async runSync(): Promise<void> {\n    if (this.syncing) {\n      this.rerun = true;\n      return;\n    }\n    this.syncing = true;\n    try {\n      do {\n        this.rerun = false;\n        if (this.stopping) return;\n        try {\n          const summary = await this.engine!.syncOnce();\n          this.opts.onSync?.(summary);\n        } catch (err) {\n          this.opts.onError?.(err);\n        }\n      } while (this.rerun);\n    } finally {\n      this.syncing = false;\n    }\n  }\n\n  /**\n   * Tear down watcher + timers, DRAIN any in-flight sync (bounded by {@link DRAIN_TIMEOUT_MS}),\n   * then remove the PID file. Draining means a SIGTERM no longer exits mid `git commit`/`rebase`/\n   * `push`, which would strand the repo (#100). Safe to call more than once.\n   */\n  async stop(): Promise<void> {\n    this.stopping = true;\n    if (this.debounceTimer) {\n      clearTimeout(this.debounceTimer);\n      this.debounceTimer = undefined;\n    }\n    if (this.timer) {\n      clearInterval(this.timer);\n      this.timer = undefined;\n    }\n    if (this.watcher) {\n      await this.watcher.close();\n      this.watcher = undefined;\n    }\n    // Wait for whatever is already queued to settle (enqueuing an empty task resolves only after\n    // all prior queued work does), but never block shutdown forever on a hung git op.\n    await Promise.race([\n      this.queue.enqueue(() => Promise.resolve()),\n      new Promise<void>((resolve) => setTimeout(resolve, DRAIN_TIMEOUT_MS)),\n    ]);\n    if (this.engine) {\n      await removePid(this.engine.brainDir);\n    }\n  }\n}\n\n/** Absolute path of the daemon PID file for a brain. */\nfunction pidPath(brainDir: string): string {\n  return path.join(brainDir, COMMONWEALTH_DIR, PID_FILE);\n}\n\n/** Write the current process id to the brain's PID file. */\nexport async function writePid(brainDir: string): Promise<void> {\n  const file = pidPath(brainDir);\n  await fs.mkdir(path.dirname(file), { recursive: true });\n  await fs.writeFile(file, `${process.pid}\\n`, \"utf8\");\n}\n\n/** Read the recorded PID, or null if there is no PID file. */\nexport async function readPid(brainDir: string): Promise<number | null> {\n  try {\n    const raw = await fs.readFile(pidPath(brainDir), \"utf8\");\n    const pid = Number.parseInt(raw.trim(), 10);\n    return Number.isFinite(pid) ? pid : null;\n  } catch {\n    return null;\n  }\n}\n\n/** True if a daemon PID is recorded AND that process is currently alive. */\nexport async function isRunning(brainDir: string): Promise<boolean> {\n  const pid = await readPid(brainDir);\n  if (pid === null) return false;\n  try {\n    process.kill(pid, 0); // signal 0 = existence check, doesn't actually signal\n    return true;\n  } catch {\n    return false; // no such process (or not permitted) → treat as not running\n  }\n}\n\n/** Remove the PID file if present. */\nexport async function removePid(brainDir: string): Promise<void> {\n  await fs.rm(pidPath(brainDir), { force: true });\n}\n","import { buildIndex, regenerateDerived } from \"@cmnwlth/core\";\nimport { resolveConflictsAsSiblings, type ResolvedConflict } from \"./conflict.js\";\nimport {\n  abortRebase,\n  commitAllExceptSecrets,\n  conflictedPaths,\n  hasRemote,\n  isRebasing,\n  needsPush,\n  pullRebase,\n  push,\n} from \"./git.js\";\nimport { acquireSyncLock } from \"./lock.js\";\nimport { SerialQueue } from \"./queue.js\";\n\n/** A pass that did nothing (no lock, or nothing to do): every flag false, no conflicts/secrets. */\nconst NOOP_SUMMARY: SyncSummary = {\n  committed: false,\n  pulled: false,\n  pushed: false,\n  conflicts: [],\n  secretsBlocked: [],\n};\n\n/** Options for constructing a {@link SyncEngine}. */\nexport interface SyncEngineOptions {\n  /** Existing serial queue to share (e.g. with a daemon). One is created if omitted. */\n  queue?: SerialQueue;\n}\n\n/** Outcome of a single {@link SyncEngine.syncOnce} pass. */\nexport interface SyncSummary {\n  /** A commit of local (pre-pull) changes was created. */\n  committed: boolean;\n  /** A pull/rebase actually ran (a remote + upstream existed). */\n  pulled: boolean;\n  /** A push to origin ran. */\n  pushed: boolean;\n  /** Same-file conflicts that were resolved as siblings this pass. */\n  conflicts: ResolvedConflict[];\n  /**\n   * Repo-relative note paths withheld from the local commit because they contained a\n   * secret (#16). They remain modified/uncommitted in the working tree for the user to fix.\n   */\n  secretsBlocked: string[];\n}\n\n/** Safety valve so a pathological rebase can't spin forever. */\nconst MAX_REBASE_ROUNDS = 50;\n\n/**\n * The testable sync core over a single brain working copy. `syncOnce` runs the full\n * cycle THROUGH a serial queue so concurrent callers (watcher, poll, CLI) never race\n * (issue #7): commit local → pull/rebase → resolve conflicts as siblings → rebuild\n * derived index → commit derived → push. Degrades gracefully with no remote configured.\n */\nexport class SyncEngine {\n  readonly brainDir: string;\n  readonly queue: SerialQueue;\n\n  constructor(brainDir: string, opts: SyncEngineOptions = {}) {\n    this.brainDir = brainDir;\n    this.queue = opts.queue ?? new SerialQueue();\n  }\n\n  /** Run one full sync cycle, serialized against every other queued mutation. */\n  syncOnce(): Promise<SyncSummary> {\n    return this.queue.enqueue(() => this.runSyncOnce());\n  }\n\n  private async runSyncOnce(): Promise<SyncSummary> {\n    const dir = this.brainDir;\n\n    // 0a. Cross-process lock: another process (a one-shot `sync`, or a second daemon) may be\n    //     mid-sync on this same repo. The in-process SerialQueue can't see it, so acquire a\n    //     file lock; if a live process holds it, skip this pass rather than race its git ops\n    //     (#100). The daemon/poll will sync again shortly; a one-shot defers to the running one.\n    const release = await acquireSyncLock(dir);\n    if (!release) return { ...NOOP_SUMMARY };\n    try {\n      // 0b. Recover a rebase stranded by a previously crashed/killed pass (#100). Committing new\n      //     work while mid-rebase would land it on a detached HEAD and then the pullRebase below\n      //     fails. Abort first so we start from a clean branch tip with local commits intact.\n      if (await isRebasing(dir)) await abortRebase(dir);\n      return await this.syncLocked(dir);\n    } finally {\n      await release();\n    }\n  }\n\n  /** The sync cycle proper, run while holding the cross-process lock (see {@link runSyncOnce}). */\n  private async syncLocked(dir: string): Promise<SyncSummary> {\n    // 1. Commit local changes first, so the rebase replays them onto teammates' work.\n    //    Scrub secrets pre-commit (#16): note files carrying a credential are unstaged and\n    //    left uncommitted, so a leaked secret is never committed or pushed.\n    const { committed, secretsBlocked } = await commitAllExceptSecrets(\n      dir,\n      \"commonwealth: sync local changes\",\n    );\n\n    // 2. Pull with rebase; resolve any same-file conflicts as siblings, then finish.\n    const remote = await hasRemote(dir);\n    let pulled = false;\n    const conflicts: ResolvedConflict[] = [];\n\n    if (remote) {\n      const { conflicts: hadConflict } = await pullRebase(dir);\n      pulled = true;\n      if (hadConflict) {\n        // A rebase can stop on several commits in turn; resolve each round until done.\n        let rounds = 0;\n        while (await isRebasing(dir)) {\n          if (rounds++ >= MAX_REBASE_ROUNDS) {\n            throw new Error(`Rebase did not converge after ${MAX_REBASE_ROUNDS} rounds`);\n          }\n          const paths = await conflictedPaths(dir);\n          if (paths.length === 0) break; // stopped for a non-conflict reason; loop guards it\n          conflicts.push(...(await resolveConflictsAsSiblings(dir, paths)));\n        }\n      }\n    }\n\n    // 3. Rebuild derived artifacts from the (now-merged) note set.\n    await buildIndex(dir);\n    await regenerateDerived(dir);\n\n    // 4. Commit derived changes (COMMONWEALTH.md / INDEX.md) if regeneration moved anything.\n    //    Re-scrub: `add -A` here would otherwise re-stage a secret note left in the working\n    //    tree by step 1, so route this commit through the same guard and merge the results.\n    const derived = await commitAllExceptSecrets(dir, \"commonwealth: regenerate derived index\");\n    for (const p of derived.secretsBlocked) {\n      if (!secretsBlocked.includes(p)) secretsBlocked.push(p);\n    }\n\n    // 5. Push only when the branch is actually ahead of its upstream — so an idle poll\n    //    doesn't hit the remote every interval, while still pushing commits made outside\n    //    the engine (e.g. a raw `git commit`) or left unpushed by an earlier failure.\n    let pushed = false;\n    if (remote && (await needsPush(dir))) {\n      await push(dir);\n      pushed = true;\n    }\n\n    return { committed, pulled, pushed, conflicts, secretsBlocked };\n  }\n}\n","import { promises as fs } from \"node:fs\";\nimport path from \"node:path\";\nimport { makeNoteId, parseNote, serializeNote, writeNote, type Note } from \"@cmnwlth/core\";\nimport { openRepo, scrubStagedSecrets } from \"./git.js\";\n\n/** One conflicting note, split into its two surviving sibling files. */\nexport interface ResolvedConflict {\n  /** The path git reported as conflicted (repo-relative). */\n  original: string;\n  /** Repo-relative path of the file holding the local (\"ours\", stage :2) content. */\n  oursPath: string;\n  /** Repo-relative path of the file holding the incoming (\"theirs\", stage :3) content. */\n  theirsPath: string;\n}\n\n/** Read a specific merge stage of a path via `git show :<stage>:<path>`; null if absent. */\nasync function showStage(dir: string, stage: 2 | 3, relPath: string): Promise<string | null> {\n  try {\n    return await openRepo(dir).raw([\"show\", `:${stage}:${relPath}`]);\n  } catch {\n    return null; // add/add on one side only, or the stage doesn't exist\n  }\n}\n\n/**\n * Rewrite one side's raw content so it lands as a NEW, distinct note file: fresh id +\n * matching filename, so ours and theirs coexist instead of overwriting each other.\n * Falls back to writing the raw bytes verbatim (under `suffix`) if it isn't parseable\n * frontmatter — we never lose content.\n */\nasync function writeSibling(\n  brainDir: string,\n  relPath: string,\n  raw: string,\n  side: \"ours\" | \"theirs\",\n): Promise<string> {\n  const dir = path.posix.dirname(relPath);\n  const base = path.posix.basename(relPath, \".md\");\n\n  let note: Note | null = null;\n  try {\n    note = parseNote(raw, relPath);\n  } catch {\n    note = null;\n  }\n\n  if (note) {\n    // Give it a brand-new id/filename so it can never collide with the other side.\n    const newId = makeNoteId(`${note.frontmatter.title} (${side})`, note.frontmatter.created);\n    const newRel = `${dir}/${newId}.md`;\n    const rewritten: Note = {\n      ...note,\n      frontmatter: { ...note.frontmatter, id: newId },\n      path: newRel,\n    };\n    await fs.writeFile(path.join(brainDir, newRel), serializeNote(rewritten), \"utf8\");\n    return newRel;\n  }\n\n  // Unparseable — preserve raw bytes under a unique, obviously-derived name.\n  const newRel = `${dir}/${base}-${side}-${randomTag()}.md`;\n  await fs.writeFile(path.join(brainDir, newRel), raw, \"utf8\");\n  return newRel;\n}\n\nfunction randomTag(): string {\n  return Math.random().toString(36).slice(2, 6);\n}\n\n/**\n * Resolve same-file conflicts without data loss (ADR-0003 §c / issue #8). For each\n * conflicted note:\n *   - extract BOTH the local (\"ours\", stage :2) and incoming (\"theirs\", stage :3) content,\n *   - write each as a SEPARATE sibling note (at least one gets a fresh {@link makeNoteId}\n *     id/filename so they coexist),\n *   - remove the original conflicted path (its content survives in the siblings, with no\n *     git conflict markers anywhere),\n *   - record a `conflict`-tagged memory note naming the two siblings for human review.\n * Then stage everything and continue the in-progress rebase to completion.\n */\nexport async function resolveConflictsAsSiblings(\n  brainDir: string,\n  conflictedPaths: string[],\n): Promise<ResolvedConflict[]> {\n  const git = openRepo(brainDir);\n  const resolved: ResolvedConflict[] = [];\n\n  for (const relPath of conflictedPaths) {\n    // These stages are always reached via a REBASE (engine pullRebase → `rebase upstream`), and\n    // a rebase inverts the usual sense of ours/theirs: stage :2 is the branch being replayed onto\n    // (upstream = the teammate's REMOTE content) and stage :3 is our own replayed commit (LOCAL).\n    // Label accordingly so the sibling filenames and the review note aren't backwards (#100).\n    const remoteRaw = await showStage(brainDir, 2, relPath);\n    const localRaw = await showStage(brainDir, 3, relPath);\n    const abs = path.join(brainDir, relPath);\n\n    // Both sides present: split into two siblings, drop the marker-laden original.\n    if (localRaw !== null && remoteRaw !== null) {\n      const oursPath = await writeSibling(brainDir, relPath, localRaw, \"ours\");\n      const theirsPath = await writeSibling(brainDir, relPath, remoteRaw, \"theirs\");\n      await fs.rm(abs, { force: true });\n      resolved.push({ original: relPath, oursPath, theirsPath });\n      continue;\n    }\n\n    // One side only (add/delete): keep whichever content exists, verbatim, no markers.\n    const survivor = localRaw ?? remoteRaw;\n    if (survivor !== null) {\n      await fs.writeFile(abs, survivor, \"utf8\");\n      resolved.push({ original: relPath, oursPath: relPath, theirsPath: relPath });\n    } else {\n      // Neither stage has content (delete/delete) — accept the deletion.\n      await fs.rm(abs, { force: true });\n      resolved.push({ original: relPath, oursPath: relPath, theirsPath: relPath });\n    }\n  }\n\n  // File a review record BEFORE staging, so it's committed alongside the resolution.\n  if (resolved.length > 0) {\n    const lines = resolved.map(\n      (r) => `- \\`${r.original}\\` → ours: \\`${r.oursPath}\\`, theirs: \\`${r.theirsPath}\\``,\n    );\n    await writeNote(brainDir, {\n      kind: \"memory\",\n      title: `Sync conflict resolved as siblings (${resolved.length})`,\n      tags: [\"conflict\"],\n      body: [\n        \"A same-file sync conflict was auto-resolved without data loss: both versions\",\n        \"were kept as separate sibling notes for review. Reconcile and supersede as needed.\",\n        \"\",\n        ...lines,\n      ].join(\"\\n\"),\n    });\n  }\n\n  // Stage the resolution and advance the rebase. `--continue` may stop again on the next\n  // replayed commit's conflict (nonzero exit) — that's expected; the engine loops back and\n  // calls us again. An emptied commit needs `--skip` instead. Swallow both; only a truly\n  // unexpected failure with no conflicts and no rebase left in progress re-throws.\n  await git.add([\"-A\"]);\n  // Re-scrub before committing: `add -A` above (re)stages EVERYTHING in the worktree, including\n  // a secret note that the engine's pre-commit scrub deliberately left unstaged (and, for a new\n  // note, untracked — which `rebase --autostash` does not stash). Without this, `rebase --continue`\n  // would fold that secret into the resolution commit and the engine would push it (#98). The\n  // unstaged secret note stays in the worktree and is reported by the engine's step-4 scrub.\n  await scrubStagedSecrets(brainDir);\n  try {\n    // openRepo injects core.editor=true, so --continue records the resolution commit\n    // non-interactively instead of trying to open an editor.\n    await git.raw([\"rebase\", \"--continue\"]);\n  } catch {\n    const status = await git.status();\n    if (status.conflicted.length === 0) {\n      // Nothing conflicting left but continue failed → likely an emptied commit; skip it.\n      try {\n        await git.raw([\"rebase\", \"--skip\"]);\n      } catch {\n        // Fall through — engine re-checks rebase state and will surface a real failure.\n      }\n    }\n  }\n\n  return resolved;\n}\n","import { promises as fs } from \"node:fs\";\nimport path from \"node:path\";\nimport { findSecrets, loadBrainConfig, scanOptions } from \"@cmnwlth/core\";\nimport { simpleGit, type SimpleGit } from \"simple-git\";\n\n/** Note-kind folders whose markdown is scanned for secrets before commit. */\nconst NOTE_DIRS = [\"memory\", \"decisions\", \"work-state\", \"people\"] as const;\n\n/**\n * True if a repo-relative path is a markdown note file — i.e. its immediate parent folder is a\n * note-kind folder (`INDEX.md` excluded). Works for both the flat kind root (`memory/x.md`) and\n * per-project subtrees (`<project>/memory/x.md`, ADR-0015), so the secret scrub keeps covering\n * every note regardless of layout.\n */\nfunction isNoteFile(rel: string): boolean {\n  if (!rel.endsWith(\".md\")) return false;\n  const parts = rel.split(\"/\");\n  const name = parts[parts.length - 1];\n  const parent = parts[parts.length - 2];\n  if (name === \"INDEX.md\") return false;\n  return parent !== undefined && (NOTE_DIRS as readonly string[]).includes(parent);\n}\n\n/**\n * Files the pre-commit scrub must scan for secrets: note files PLUS the generated router/index\n * (COMMONWEALTH.md, every INDEX.md). Those derived files embed note TITLES, so a secret in a\n * title would ride into them and get pushed even though the note file itself is blocked — the\n * derived files aren't note-files and so escaped the scrub entirely (#79). Scanning them closes\n * the leak; they're regenerated each sync, so a blocked derived file self-heals once the secret\n * is removed from the source note.\n */\nfunction isScannableForSecrets(rel: string): boolean {\n  if (isNoteFile(rel)) return true;\n  const name = rel.split(\"/\").pop();\n  return name === \"COMMONWEALTH.md\" || name === \"INDEX.md\";\n}\n\n/**\n * Open a simple-git handle bound to a working directory. `core.editor=true` is injected\n * into every invocation (via `-c`) so non-interactive steps that would otherwise open an\n * editor — notably `rebase --continue` recording a resolution commit — never block.\n */\nexport function openRepo(dir: string): SimpleGit {\n  return simpleGit(dir, {\n    // core.quotepath=false: git otherwise octal-escapes and double-quotes non-ASCII paths in\n    // porcelain output (e.g. `\"caf\\303\\251/x.md\"`), which broke `isNoteFile` — the trailing quote\n    // fails the `.md` check — so a secret in a non-ASCII-named note was never scanned (#99).\n    config: [\"core.editor=true\", \"core.quotepath=false\"],\n    // core.editor is on simple-git's block list; we set it to the non-interactive `true`\n    // binary purely so unattended `rebase --continue` can record its commit.\n    unsafe: { allowUnsafeEditor: true },\n  });\n}\n\n/** True if the working tree has staged, unstaged, or untracked changes. */\nexport async function hasChanges(dir: string): Promise<boolean> {\n  const status = await openRepo(dir).status();\n  return !status.isClean();\n}\n\n/**\n * Stage everything and commit — but only if there is something to commit. Returns true\n * if a commit was actually created, false when the tree was already clean (so callers\n * can report whether local work landed without probing git themselves).\n */\nexport async function commitAll(dir: string, message: string): Promise<boolean> {\n  const git = openRepo(dir);\n  await git.add([\"-A\"]);\n  const status = await git.status();\n  if (status.isClean()) return false;\n  await git.commit(message);\n  return true;\n}\n\n/**\n * Repo-relative paths that are currently staged (`git diff --cached --name-only`).\n * Used by the pre-commit secret scrub to know which files a commit is about to include.\n */\nexport async function stagedFiles(dir: string): Promise<string[]> {\n  // `-z`: NUL-delimited and never quoted/escaped, so non-ASCII paths (and paths with spaces)\n  // come through verbatim and the secret scrub sees every staged note file (#99).\n  const out = await openRepo(dir).diff([\"--cached\", \"--name-only\", \"-z\"]);\n  return out.split(\"\\0\").filter((l) => l.length > 0);\n}\n\n/** Remove `files` from the index (`git reset -q -- <files>`), leaving the working tree. */\nexport async function unstage(dir: string, files: string[]): Promise<void> {\n  if (files.length === 0) return;\n  await openRepo(dir).raw([\"reset\", \"-q\", \"--\", ...files]);\n}\n\n/** Outcome of {@link commitAllExceptSecrets}: commit status plus any blocked note paths. */\nexport interface GuardedCommit {\n  /** A commit was actually created (there were staged changes after scrubbing). */\n  committed: boolean;\n  /** Repo-relative note paths withheld because they contained a secret. */\n  secretsBlocked: string[];\n}\n\n/**\n * Pre-commit secret scrub (#16, defense-in-depth for hand-edited files). Stage everything\n * (`add -A`), scan every staged MARKDOWN note file for secrets, and unstage any offenders\n * so they are neither committed nor pushed. Commit the remainder only if staged changes\n * survive. Blocked files are left modified/uncommitted in the working tree for the user to\n * fix. Returns whether a commit landed and which note paths were withheld.\n */\nexport async function commitAllExceptSecrets(dir: string, message: string): Promise<GuardedCommit> {\n  const git = openRepo(dir);\n  await git.add([\"-A\"]);\n\n  const secretsBlocked = await scrubStagedSecrets(dir);\n\n  const status = await git.status();\n  if (status.staged.length === 0) return { committed: false, secretsBlocked };\n  await git.commit(message);\n  return { committed: true, secretsBlocked };\n}\n\n/**\n * Scan every currently-STAGED markdown note file for secrets and unstage any offenders,\n * returning the repo-relative paths withheld. Leaves the files modified/uncommitted in the\n * working tree. This is the reusable core of the pre-commit scrub — call it before ANY commit\n * that stages with `add -A`, including the conflict-resolution `rebase --continue` path, so a\n * blocked secret note can never ride along into a commit and get pushed (#98).\n */\nexport async function scrubStagedSecrets(dir: string): Promise<string[]> {\n  // Honor the brain's secret-scanner tuning (#46): entropy detection + allowlist, off by default.\n  const opts = scanOptions(await loadBrainConfig(dir));\n  const secretsBlocked: string[] = [];\n  for (const rel of await stagedFiles(dir)) {\n    if (!isScannableForSecrets(rel)) continue;\n    let content: string;\n    try {\n      content = await fs.readFile(path.join(dir, rel), \"utf8\");\n    } catch {\n      continue; // deletion or unreadable — nothing to scan\n    }\n    if (findSecrets(content, opts).length > 0) secretsBlocked.push(rel);\n  }\n  await unstage(dir, secretsBlocked);\n  return secretsBlocked;\n}\n\n/** The current branch name, or null if detached / no commits yet. */\nexport async function currentBranch(dir: string): Promise<string | null> {\n  return (await openRepo(dir).status()).current;\n}\n\n/** True if the repo has an `origin` remote configured. */\nexport async function hasRemote(dir: string): Promise<boolean> {\n  const remotes = await openRepo(dir).getRemotes();\n  return remotes.some((r) => r.name === \"origin\");\n}\n\n/** Repo-relative paths that are currently in a merge/rebase conflict state. */\nexport async function conflictedPaths(dir: string): Promise<string[]> {\n  return (await openRepo(dir).status()).conflicted;\n}\n\n/**\n * Fetch and rebase the current branch onto its upstream (`--autostash` so local WIP is\n * preserved). Returns `{ conflicts }` — true when the rebase stopped on a conflict that\n * the caller must resolve. Other rebase failures are re-thrown.\n *\n * No-ops (returns `{ conflicts: false }`) when there is no `origin` remote or the branch\n * has no upstream tracking ref, so a local-only brain syncs without error.\n */\nexport async function pullRebase(dir: string): Promise<{ conflicts: boolean }> {\n  const git = openRepo(dir);\n  if (!(await hasRemote(dir))) return { conflicts: false };\n\n  const status = await git.status();\n  const branch = status.current;\n  if (!branch) return { conflicts: false };\n\n  await git.fetch(\"origin\");\n\n  // Determine the upstream: prefer the tracked ref, else fall back to origin/<branch>\n  // if the remote actually has it (first push may not have set tracking yet).\n  let upstream = status.tracking;\n  if (!upstream) {\n    const remoteBranches = await git.branch([\"-r\"]);\n    const candidate = `origin/${branch}`;\n    if (remoteBranches.all.includes(candidate)) upstream = candidate;\n  }\n  if (!upstream) return { conflicts: false };\n\n  try {\n    await git.raw([\"rebase\", \"--autostash\", upstream]);\n    return { conflicts: false };\n  } catch (err) {\n    // A conflict leaves us mid-rebase with entries in `conflicted`; anything else is fatal.\n    const conflicted = (await git.status()).conflicted;\n    if (conflicted.length > 0) return { conflicts: true };\n    throw err;\n  }\n}\n\n/**\n * Abort an in-progress rebase, restoring the branch to its pre-rebase tip (local commits intact).\n * Best-effort: if there is somehow no rebase to abort, git errors and we swallow it — the caller\n * only calls this after {@link isRebasing} returned true, to recover a rebase stranded by a prior\n * crashed pass (#100).\n */\nexport async function abortRebase(dir: string): Promise<void> {\n  try {\n    await openRepo(dir).raw([\"rebase\", \"--abort\"]);\n  } catch {\n    // Nothing to abort / already clean — nothing to recover.\n  }\n}\n\n/** True if a rebase is currently in progress (a `.git/rebase-*` dir exists). */\nexport async function isRebasing(dir: string): Promise<boolean> {\n  const gitDir = (await openRepo(dir).revparse([\"--git-dir\"])).trim();\n  const base = path.isAbsolute(gitDir) ? gitDir : path.join(dir, gitDir);\n  for (const name of [\"rebase-merge\", \"rebase-apply\"]) {\n    try {\n      await fs.access(path.join(base, name));\n      return true;\n    } catch {\n      // not present — check the next\n    }\n  }\n  return false;\n}\n\n/**\n * True when there is something to push: no upstream yet (first push, to set tracking) or\n * the branch is ahead of its upstream. Lets callers skip idle pushes without missing\n * commits made outside the engine (e.g. a raw `git commit`). Assumes a recent fetch.\n */\nexport async function needsPush(dir: string): Promise<boolean> {\n  if (!(await hasRemote(dir))) return false;\n  const status = await openRepo(dir).status();\n  if (!status.current) return false;\n  if (!status.tracking) return true; // upstream not set yet → push to establish it\n  return status.ahead > 0;\n}\n\n/** Push the current branch to `origin`, setting upstream so future pulls track it. */\nexport async function push(dir: string): Promise<void> {\n  const git = openRepo(dir);\n  if (!(await hasRemote(dir))) return;\n  const branch = (await git.status()).current;\n  if (!branch) return;\n  await git.push([\"-u\", \"origin\", branch]);\n}\n","// The cross-process sync lock now lives in @cmnwlth/core so both the sync engine and the\n// curate consolidation pass can share it (#29). Re-exported here for existing importers.\nexport { acquireSyncLock } from \"@cmnwlth/core\";\n","/**\n * A strict FIFO async mutex. Every task passed to {@link SerialQueue.enqueue} runs\n * to completion (or rejection) before the next one starts, so overlapping callers can\n * never interleave. This is the sync write queue (issue #7): ALL git mutations funnel\n * through one instance so concurrent triggers (watcher, poll, CLI) never race.\n */\nexport class SerialQueue {\n  /** Tail of the promise chain; each enqueue appends to it. */\n  private tail: Promise<unknown> = Promise.resolve();\n\n  /**\n   * Run `fn` after every previously-enqueued task has settled. Returns a promise for\n   * `fn`'s result. A rejection in one task does not break the chain — later tasks still\n   * run — but it is propagated to that task's own caller.\n   */\n  enqueue<T>(fn: () => Promise<T>): Promise<T> {\n    // Chain onto the current tail, swallowing prior errors so the chain never wedges.\n    const run = this.tail.then(() => fn());\n    // Advance the tail to this task's settlement, ignoring its outcome for chaining.\n    this.tail = run.then(\n      () => undefined,\n      () => undefined,\n    );\n    return run;\n  }\n}\n","import type { SyncSummary } from \"./engine.js\";\n\n/**\n * One-line (occasionally two-line) human summary of a sync pass for the CLI/daemon log. The\n * second line is emitted only when notes were withheld for containing a secret (#99): a\n * silently-withheld note is a trust problem, so the user must always see which paths were held\n * back (they remain uncommitted in the working tree to fix). Pure function.\n */\nexport function formatSyncSummary(s: SyncSummary): string {\n  let line =\n    `[commonwealth-sync] sync: committed=${s.committed} pulled=${s.pulled} ` +\n    `pushed=${s.pushed} conflicts=${s.conflicts.length}`;\n  if (s.secretsBlocked.length > 0) {\n    line += `\\n[commonwealth-sync] withheld ${s.secretsBlocked.length} note(s) containing a secret (not committed/pushed): ${s.secretsBlocked.join(\", \")}`;\n  }\n  return line;\n}\n"],"mappings":"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","names":["path","fs","path","fs","path","path","newRel","fs","conflictedPaths","path","fs","path"]}

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@cmnwlth/sync",
+  "version": "0.1.0",
+  "description": "Resident sync daemon + engine: git pull/commit/push, write queue, conflict-as-siblings",
+  "license": "Apache-2.0",
+  "type": "module",
+  "bin": {
+    "commonwealth-sync": "./dist/index.js"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "chokidar": "^4.0.0",
+    "simple-git": "^3.27.0",
+    "@cmnwlth/core": "0.1.0"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/kristoffeys/commonwealth.git",
+    "directory": "packages/sync"
+  },
+  "homepage": "https://github.com/kristoffeys/commonwealth#readme",
+  "bugs": "https://github.com/kristoffeys/commonwealth/issues",
+  "scripts": {
+    "build": "tsup",
+    "typecheck": "tsc --noEmit"
+  }
+}