@fluado/enmetu 0.3.0 → 0.5.0

package/dist/sync/syncCycleController.js

@@ -1,5 +1,5 @@
 import { EnmetuError } from '../contracts/errors.js';
-import { EMPTY_COMMIT_MEMORY, } from '../contracts/syncTypes.js';
+import { EMPTY_COMMIT_MEMORY, HOLD_NOTHING, } from '../contracts/syncTypes.js';
 import { withLastMove } from '../core/commit/commitMemory.js';
 import { withCycleId } from '../core/errors/withCycleId.js';
 import { incomingRefFor, verifiedRefFor } from '../core/git/enmetuRefs.js';
@@ -28,7 +28,9 @@ export const REBASE_REFUSED_AFTER = 3;
  *    memory (design 12.7); busy and paused return, committed and nothing go
  *    on, waiting goes on and is the outcome unless a later step returns
  *    something else. The check right before the commit is the commit step's,
- *    under index.lock.
+ *    under index.lock. The hold policy for step 9 (design 14.21): the commit
+ *    step's after committed or nothing, all after a hook rejection, nothing
+ *    after a clean status.
  * 6. Remote check: ls-remote, tracking ref, verified ref (seeded from tracking when missing).
  * 7. Verify and fetch: fetch into the incoming ref when the remote moved; the remote sha
  *    must descend from the verified sha, else halt UPSTREAM_REWRITTEN; then move the
@@ -39,6 +41,12 @@ export const REBASE_REFUSED_AFTER = 3;
  *    git.hasStagedChanges() says the real index differs from HEAD (git would
  *    refuse the rebase), integrate is skipped, UNPUSHED reported and waiting
  *    returned (Decision 84).
+ *    deferred (a save made during the cycle is dirty): UNPUSHED reported,
+ *    waiting TREE_CHANGING returned, the refusal count left as it is
+ *    (Decision 147), and pullDeferred carried to the next cycle: while it is
+ *    carried, a cycle that committed reports UNPUSHED and returns waiting
+ *    TREE_CHANGING before integrate; the first cycle that commits nothing
+ *    pulls and clears it (Decision 162).
  *    not-started: the count of consecutive refusals (input.notStartedRebases)
  *    goes up by one; the first logs REBASE_NOT_STARTED with git's first stderr
  *    line; UNPUSHED is reported; the outcome is busy, or paused REBASE_REFUSED
@@ -58,6 +66,7 @@ export async function syncCycleController(input, deps) {
     const carried = {
         commitMemory: input.commitMemory,
         notStartedRebases: input.notStartedRebases,
+        pullDeferred: input.pullDeferred,
     };
     const outcome = (cycleOutcome) => resultOf(cycleOutcome, null, carried);
     try {
@@ -115,6 +124,12 @@ async function runCycle(input, deps, carried, outcome) {
     // The commit's parent when this cycle committed: step 9 records the pull
     // from there, so the repair covers the commit and the pull in one move.
     let committedFrom = null;
+    // Which dirty paths the pull may set aside (design 14.21): after a clean
+    // status none, so a path dirty at step 9 is a save made during the cycle.
+    let hold = HOLD_NOTHING;
+    // Whether this cycle's commit step committed: with a deferred pull carried
+    // in, that defers the pull once more (Decision 162).
+    let committedThisCycle = false;
     if ((await deps.git.status()).length > 0) {
         // A person's merge, cherry-pick or revert that stopped after step 2 is in
         // that status; the commit step would only find it under index.lock (Decision 52).
@@ -135,9 +150,18 @@ async function runCycle(input, deps, carried, outcome) {
         }
         if (committed.kind === 'waiting') {
             waiting = committed.reason;
+            // A rejected commit leaves every dirty path uncommittable; a rejecting
+            // hook must not block incoming changes (D4), so the pull holds them all.
+            if (committed.reason === 'COMMIT_HOOK_REJECTED') {
+                hold = { kind: 'all' };
+            }
+        }
+        if (committed.kind === 'committed' || committed.kind === 'nothing') {
+            hold = committed.hold;
         }
         if (committed.kind === 'committed') {
             committedFrom = committed.memory.lastMove?.from ?? null;
+            committedThisCycle = true;
         }
     }
     else if (carried.commitMemory !== undefined) {
@@ -156,7 +180,10 @@ async function runCycle(input, deps, carried, outcome) {
     let verifiedSha = await deps.git.resolveCommit(verifiedRef);
     if (remoteHead.kind === 'unreachable') {
         await reportUnpushedAgainstLastKnown(trackingSha ?? verifiedSha, upstream, cycleId, deps);
-        return outcome({ kind: 'offline' });
+        return outcome({
+            kind: 'offline',
+            detail: offlineDetail(remoteHead.detail),
+        });
     }
     if (remoteHead.kind === 'absent') {
         // A deleted remote branch is never recreated by enmetu, so commits pile
@@ -175,7 +202,7 @@ async function runCycle(input, deps, carried, outcome) {
         const fetched = await deps.writer.fetch(upstream.remote, upstream.remoteRef, incomingRefFor(branchRef));
         if (fetched.kind === 'failed') {
             await reportUnpushedAgainstLastKnown(trackingSha ?? verifiedSha, upstream, cycleId, deps);
-            return outcome({ kind: 'offline' });
+            return outcome({ kind: 'offline', detail: offlineDetail(fetched.detail) });
         }
     }
     // Checked even when the fetch was skipped: a person's own fetch may already
@@ -198,6 +225,11 @@ async function runCycle(input, deps, carried, outcome) {
     // --- Step 9: integrate when behind ---
     if (behind === 0) {
         carried.notStartedRebases = resetCount(carried.notStartedRebases);
+        // A cycle that commits nothing ends a deferral; a committing one keeps
+        // it, the writer may still be at work, and pushes as before (Decision 162).
+        if (!committedThisCycle) {
+            carried.pullDeferred = resetFlag(carried.pullDeferred);
+        }
     }
     else {
         // git rebase refuses an index that differs from HEAD (Decision 84). A
@@ -210,6 +242,16 @@ async function runCycle(input, deps, carried, outcome) {
             reportUnpushed(ahead, upstream, cycleId, deps);
             return outcome({ kind: 'waiting', reason: waiting });
         }
+        // After a deferral for a save made during a cycle, a cycle that commits
+        // defers again; the pull runs in the first cycle whose commit step finds
+        // nothing new, as the WAITING line says (Decision 162). A check at one
+        // instant is not enough: a file saved every 40 ms is clean right after
+        // each commit, and a rebase started then walks it through every replayed
+        // version (CodeFloe run 1, 2026-11-08).
+        if (carried.pullDeferred === true && committedThisCycle) {
+            reportUnpushed(ahead, upstream, cycleId, deps);
+            return outcome({ kind: 'waiting', reason: 'TREE_CHANGING' });
+        }
         const pulledFrom = committedFrom ?? (await deps.git.headCommit());
         const integrated = await deps.integrate({
             cycleId,
@@ -217,7 +259,16 @@ async function runCycle(input, deps, carried, outcome) {
             ontoSha: remoteSha,
             behind,
             knownConflict: input.knownConflict,
+            hold,
         });
+        if (integrated.kind === 'deferred') {
+            // The next cycle commits the save first and pulls only once a cycle
+            // commits nothing (Decision 162); the runner logs WAITING once.
+            carried.pullDeferred = true;
+            reportUnpushed(ahead, upstream, cycleId, deps);
+            return outcome({ kind: 'waiting', reason: 'TREE_CHANGING' });
+        }
+        carried.pullDeferred = resetFlag(carried.pullDeferred);
         if (integrated.kind === 'not-started') {
             const refusals = (carried.notStartedRebases ?? 0) + 1;
             carried.notStartedRebases = refusals;
@@ -296,8 +347,13 @@ function resultOf(cycleOutcome, conflict, carried) {
         conflict,
         commitMemory: carried.commitMemory,
         notStartedRebases: carried.notStartedRebases,
+        pullDeferred: carried.pullDeferred,
     };
 }
+/** A flag the input carried goes back to false; an absent one stays absent, which means false. */
+function resetFlag(flag) {
+    return flag === undefined ? undefined : false;
+}
 /** A count the input carried goes back to 0; an absent one stays absent, which means 0. */
 function resetCount(count) {
     return count === undefined ? undefined : 0;
@@ -330,6 +386,15 @@ function reportUnpushed(ahead, upstream, cycleId, deps) {
  * observation of the remote; the verified ref covers a tracking ref that
  * `git fetch --prune` removed after the remote branch was deleted.
  */
+/**
+ * What git said, for the OFFLINE line (Decision 159): its first line is ssh's
+ * "Permission denied (publickey)." or "Connection refused", or the adapter's
+ * timeout message; the rest is git's generic advice.
+ */
+function offlineDetail(detail) {
+    const line = firstLine(detail);
+    return line === '' ? 'no detail from git' : line;
+}
 async function reportUnpushedAgainstLastKnown(lastKnownSha, upstream, cycleId, deps) {
     if (lastKnownSha === null) {
         deps.logger.log({

package/dist/sync/syncCycleRunner.js

@@ -3,6 +3,7 @@ import { errorMessage } from '../core/errors/errorMessage.js';
 const WAITING_MESSAGES = {
     PARTIAL_SELECTION_STAGED: 'waiting: a partial selection is staged; nothing is committed or pulled until you commit or unstage it, and after partialStagingWaitMs enmetu commits everything',
     COMMIT_HOOK_REJECTED: 'waiting: a commit hook rejected the commit; enmetu tries again when the files change',
+    TREE_CHANGING: 'waiting: a file was saved while this cycle ran; the pull waits for a cycle that finds nothing new to commit, so no file you are editing is set aside',
 };
 /**
  * Service: the memory that spans cycles. Numbers cycles c1, c2, ...; passes
@@ -33,10 +34,12 @@ export class SyncCycleRunner {
             this.knownConflict = result.conflict;
             if (this.carried !== null ||
                 result.commitMemory !== undefined ||
-                result.notStartedRebases !== undefined) {
+                result.notStartedRebases !== undefined ||
+                result.pullDeferred !== undefined) {
                 this.carried = {
                     commitMemory: result.commitMemory ?? EMPTY_COMMIT_MEMORY,
                     notStartedRebases: result.notStartedRebases ?? 0,
+                    pullDeferred: result.pullDeferred ?? false,
                 };
             }
             this.reportQuietTransition(result.outcome, cycleId);
@@ -64,6 +67,7 @@ export class SyncCycleRunner {
             knownConflict: this.knownConflict,
             commitMemory: this.carried.commitMemory,
             notStartedRebases: this.carried.notStartedRebases,
+            pullDeferred: this.carried.pullDeferred,
         };
     }
     reportQuietTransition(outcome, cycleId) {
@@ -132,7 +136,7 @@ function quietEntry(outcome, cycleId) {
             return {
                 level: 'WARN',
                 code: 'OFFLINE',
-                message: 'remote unreachable; retrying on every poll',
+                message: `remote unreachable (${outcome.detail}); retrying on every poll`,
                 cycleId,
             };
         case 'waiting':

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fluado/enmetu",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "description": "Keeps one git working tree committed and in sync with its upstream.",
   "license": "MIT",
   "author": "fluado UG (haftungsbeschränkt)",
@@ -20,7 +20,8 @@
     "dist"
   ],
   "engines": {
-    "node": ">=24"
+    "node": ">=24",
+    "bun": ">=1.4.4"
   },
   "devDependencies": {
     "@biomejs/biome": "2.3.8",