@stravica-ai/digital-operator-pa 0.1.12 → 0.1.13

package/dist/engineering-pa-cli/src/sync/git.mjs

@@ -69,8 +69,31 @@ export async function fetchOrigin(runner, { cwd }) {
   return runner.spawn('git', ['fetch', 'origin'], { cwd });
 }
 
+// `--autostash` is load-bearing, not convenience. estate-sync commits
+// FIRST (see run.mjs step 6), but only the registry-scoped IN-SCOPE dirty
+// paths are ever staged — dirty paths under an excluded mount subtree
+// (down-path deliveries of canonical-owned content, materialised into the
+// workspace by library-sync on hosts that run no wrap-pr leg) legitimately
+// remain unstaged at rebase time. A plain `git pull --rebase` refuses to
+// start over those unstaged changes ("cannot pull with rebase: You have
+// unstaged changes"), which wedged ops-01 twice on 2026-07-29
+// (w-2026-07-29-019): exit 2 every tick while the sync's own
+// push-race-lost commits piled up ahead and the workspace diverged
+// (ahead-2/behind-5), taking every librarian sweep down with
+// fail-clone-behind/dirty until a human ran stash -> rebase -> push ->
+// pop by hand. `--autostash` is exactly that manual recovery, done by
+// git itself: stash the unstaged (excluded-scope) dirt, rebase, pop.
+// carry-home and housekeeping already pull with --autostash for the same
+// reason.
+//
+// If popping the autostash conflicts (upstream changed the same excluded
+// file differently), git completes the rebase, KEEPS the changes in the
+// stash, and prints "applying autostash resulted in conflicts" — the
+// working tree is left clean, the push still proceeds, and run.mjs
+// detects that message and surfaces it in the audit record (see
+// AUTOSTASH_CONFLICT_RE) rather than letting parked dirt go silent.
 export async function pullRebase(runner, { cwd, branch }) {
-  return runner.spawn('git', ['pull', '--rebase', '--quiet', 'origin', branch], { cwd });
+  return runner.spawn('git', ['pull', '--rebase', '--autostash', '--quiet', 'origin', branch], { cwd });
 }
 
 export async function rebaseAbort(runner, { cwd }) {

package/dist/engineering-pa-cli/src/sync/run.mjs

@@ -25,8 +25,18 @@
 //      `git commit -m "estate-sync <ISO ts>" -m "<body>"`.
 //      (this happens BEFORE the pull — git pull --rebase refuses to run
 //      with uncommitted changes in the index or working tree)
-//   7. git pull --rebase origin <branch> (fetch already done in step 2)
+//   7. git pull --rebase --autostash origin <branch> (fetch already done
+//      in step 2). --autostash matters: step 6 stages only IN-SCOPE dirty
+//      paths, so registry-excluded dirt (down-path deliveries of
+//      mount-owned content on hosts with no wrap-pr leg) legitimately
+//      remains unstaged here — without autostash the rebase refuses to
+//      start over it and the sync wedges with exit 2 on every tick
+//      (observed live on ops-01, 2026-07-29, w-2026-07-29-019).
 //      on rebase conflict: git rebase --abort + fail-rebase audit + exit 2
+//      (abort also restores the autostash). If the rebase succeeds but
+//      POPPING the autostash conflicts, git keeps the dirt in the stash
+//      and completes — we detect the message and record
+//      autostashConflict:true in the audit rather than going silent.
 //   8. git push. on rejection: fetch + pull --rebase + push retry. one
 //      retry only.
 //   9. append success audit to logs/runs.jsonl
@@ -89,6 +99,25 @@ function log(line, { stderr = process.stderr } = {}) {
   stderr.write(`[estate-sync] ${line}\n`);
 }
 
+// Git's exact wording when a rebase completes but re-applying the
+// autostash conflicts: "Applying autostash resulted in conflicts. Your
+// changes are safe in the stash. ..." (sequencer.c, stable across
+// versions). The rebase itself SUCCEEDS in this case (exit 0) — the
+// excluded-scope dirt is parked in `git stash` and the working tree is
+// left clean. That is a safe state (the next down-path re-materialises
+// the same content), but it must never be silent: the audit record
+// carries autostashConflict:true so a human can `git stash pop` / `drop`
+// deliberately.
+const AUTOSTASH_CONFLICT_RE = /applying autostash resulted in conflicts/i;
+
+function detectAutostashConflict(res, stderr) {
+  const matched = AUTOSTASH_CONFLICT_RE.test(`${res.stdout || ''}\n${res.stderr || ''}`);
+  if (matched) {
+    log('rebase succeeded but applying the autostash conflicted — excluded-scope dirt is parked in `git stash` (run `git stash pop` or `git stash drop` deliberately)', { stderr });
+  }
+  return matched;
+}
+
 async function writeAudit(runsLog, record, stderr) {
   try {
     await appendFile(runsLog, JSON.stringify(record) + '\n');
@@ -317,8 +346,10 @@ export async function runSync({
     // If fetch failed earlier, we'd be rebasing onto stale refs which
     // either no-ops (if local refs already match) or fails spuriously.
     let autoResolvedPaths = [];
+    let autostashConflict = false;
     if (upfrontFetch.code === 0) {
       const prRes = await pullRebase(runner, { cwd: repoRoot, branch });
+      autostashConflict = detectAutostashConflict(prRes, stderr) || autostashConflict;
       if (prRes.code !== 0) {
         log(`git pull --rebase failed: ${prRes.stderr.trim()}`, { stderr });
         // Before aborting, see if the conflict is limited to files that
@@ -365,9 +396,12 @@ export async function runSync({
     // pointing at remote refs (nothing to push). If we committed, we have
     // at least one local-only commit. If we were just behind, pull
     // brought us up to date — nothing to push.
-    const autoResolveFields = autoResolvedPaths.length > 0
-      ? { autoResolved: autoResolvedPaths.length, autoResolvedPaths }
-      : {};
+    const autoResolveFields = {
+      ...(autoResolvedPaths.length > 0
+        ? { autoResolved: autoResolvedPaths.length, autoResolvedPaths }
+        : {}),
+      ...(autostashConflict ? { autostashConflict: true } : {}),
+    };
 
     const { ahead: aheadAfter } = await aheadBehind(runner, { cwd: repoRoot });
     const needsPush = Number.isFinite(aheadAfter) && aheadAfter > 0;
@@ -416,6 +450,7 @@ export async function runSync({
       return 2;
     }
     const pr2 = await pullRebase(runner, { cwd: repoRoot, branch });
+    autostashConflict = detectAutostashConflict(pr2, stderr) || autostashConflict;
     if (pr2.code !== 0) {
       log(`git pull --rebase (for push-retry) failed: ${pr2.stderr.trim()}`, { stderr });
       // Symmetric with step 7: if the push-retry rebase conflicts only
@@ -460,9 +495,12 @@ export async function runSync({
     }
     log('pushed after rebase', { stderr });
     // Recompute so any auto-resolve during the push-retry is captured.
-    const autoResolveFieldsFinal = autoResolvedPaths.length > 0
-      ? { autoResolved: autoResolvedPaths.length, autoResolvedPaths }
-      : {};
+    const autoResolveFieldsFinal = {
+      ...(autoResolvedPaths.length > 0
+        ? { autoResolved: autoResolvedPaths.length, autoResolvedPaths }
+        : {}),
+      ...(autostashConflict ? { autostashConflict: true } : {}),
+    };
     await writeAudit(runsLog, {
       ts: tsIso,
       status: 'ok',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stravica-ai/digital-operator-pa",
-  "version": "0.1.12",
+  "version": "0.1.13",
   "description": "Digital Operator PA — single-bundled public package surface (bins + library) for the platform.",
   "type": "module",
   "main": "./index.mjs",