devlyn-cli 4.3.5 → 4.3.7

package/bin/devlyn.js

@@ -1564,8 +1564,8 @@ function cleanupCurrentFingerprints() {
   return Object.fromEntries([...CLEANUP_CORE, '_shared'].map((name) => [name, fingerprint(path.join(CONFIG_SOURCE, 'skills', name))]));
 }
 
-function cleanupGit(root, args) {
-  return spawnSync('git', ['-C', root, ...args], { env: { ...gitEnvironment(), GIT_OPTIONAL_LOCKS: '0' }, encoding: 'utf8' });
+function cleanupGit(root, args, options = {}) {
+  return spawnSync('git', ['-C', root, ...args], { env: { ...gitEnvironment(), GIT_OPTIONAL_LOCKS: '0' }, encoding: 'utf8', ...options });
 }
 
 let cleanupPythonBinary;
@@ -1834,43 +1834,129 @@ function cleanupDeliver(scope, items, current) {
     '--branch', branch, '--worktree', worktree, '--repository', scope.remote.repository,
     '--remote', 'origin', '--base', scope.remote.base], scope.root).stdout);
   if (allocated?.status !== 'ALLOCATED') return { error: cleanupReason('delivery-failed', { detail: allocated?.reason || 'allocation failed' }) };
-  const release = (error) => {
+  const release = (error = null) => {
     for (const args of [['worktree', 'remove', '--force', worktree], ['branch', '-D', branch]]) {
       const result = cleanupGit(scope.root, args);
-      if (result.error || result.status !== 0) return { error: cleanupReason(error.code, { ...error.params,
+      if (result.error || result.status !== 0) return { error: cleanupReason(error?.code || 'delivery-failed', { ...error?.params,
         releaseError: result.error?.message || result.stderr.trim(), worktree, receipt: allocated.receipt }) };
     }
     fs.rmSync(path.dirname(allocated.receipt), { recursive: true, force: true });
-    return { error };
+    return error ? { error } : {};
   };
+  const baseHead = cleanupGit(worktree, ['rev-parse', 'HEAD']);
+  if (baseHead.error || baseHead.status !== 0) return release(cleanupReason('repository-unreadable', { detail: baseHead.error?.message || baseHead.stderr.trim() }));
+  const base = baseHead.stdout.trim();
   let prepared;
-  try { prepared = cleanupDeliveryCommit(worktree, items, current, release); }
+  try { prepared = cleanupDeliveryCommit(worktree, items, current, release, cleanupSettledUpstream(scope.root, base)); }
   catch (error) { return release(cleanupReason('apply-failed', { detail: error.message })); }
+  if (prepared.error?.code === 'stale-plan') {
+    const head = cleanupGit(scope.root, ['rev-parse', 'HEAD']);
+    // A stale review must see the base's bytes next time. Local commits keep today's refusal.
+    if (!head.error && head.status === 0 && head.stdout.trim() !== base) {
+      const ancestor = cleanupGit(scope.root, ['merge-base', '--is-ancestor', head.stdout.trim(), base]);
+      if (!ancestor.error && ancestor.status === 0) {
+        const updated = cleanupUpdateCheckout(scope);
+        if (updated.error) return updated;
+      }
+    }
+  }
   if (prepared.error) return prepared;
+  // The remote base already settled every reviewed item: the checkout only has to take it.
+  if (!prepared.acceptance) return cleanupUpdateCheckout(scope);
   const completed = lastJson(run(['complete', '--receipt', allocated.receipt, '--acceptance', prepared.acceptance, '--writers-stopped'], scope.root).stdout);
   const status = completed?.delivery_status || completed?.status;
-  if (status === 'COMPLETE' || status === 'MERGED') return { delivery: { state: 'merged', url: completed.pr || null } };
+  if (status === 'COMPLETE' || status === 'MERGED') return { ...cleanupUpdateCheckout(scope), delivery: { state: 'merged', url: completed.pr || null } };
   if (completed?.pr) return { delivery: { state: 'pr-open', url: completed.pr } };
   const reason = completed?.reason || 'delivery did not complete';
   const auth = /\b(authentication|unauthorized|gh auth login|could not read Username|HTTP 40[13])\b/i.test(reason);
   return { error: cleanupReason(auth ? 'auth-failed' : 'delivery-failed', { detail: reason, ...(completed?.resume ? { resume: completed.resume } : {}) }) };
 }
 
+// With no fresh counterpart, the base settled an item only if it changed the path's content or
+// removed it in every spelling, while the checkout holds it under its tracked spelling unchanged
+// since the fork point. A copy committed or changed only here is not one the base settled.
+function cleanupSettledUpstream(root, base) {
+  const read = (cwd, args, options) => {
+    const result = cleanupGit(cwd, args, options);
+    return !result.error && result.status === 0 ? result.stdout : null;
+  };
+  const object = (spec) => read(root, ['rev-parse', '--verify', '--quiet', spec])?.trim() || null;
+  const fork = read(root, ['merge-base', 'HEAD', base])?.trim();
+  let upstream; // the base's paths, folded to lower case, read once and only when needed
+  return (relative) => {
+    if (!fork) return false;
+    if (upstream === undefined) {
+      upstream = read(root, ['ls-tree', '-r', '-z', '--name-only', base], { maxBuffer: 1 << 30 })
+        ?.split('\0').filter(Boolean).map((name) => name.toLowerCase()) ?? null;
+    }
+    const lower = relative.toLowerCase();
+    if (!upstream) return false;
+    // The tracked spelling, which a case-insensitive file system lets differ from the one on disk.
+    const tracked = read(root, ['ls-files', '-z', '--', `:(icase,literal)${relative}`])?.split('\0').find(Boolean);
+    const spelled = tracked?.slice(0, relative.length);
+    if (!spelled || spelled.toLowerCase() !== lower) return false;
+    const before = object(`${fork}:${spelled}`);
+    if (before === null || before !== object(`HEAD:${spelled}`)) return false;
+    const after = object(`${base}:${spelled}`);
+    return after !== null ? after !== before
+      : !upstream.some((name) => name === lower || name.startsWith(`${lower}/`));
+  };
+}
+
+// The remote base's cleanup or changed copies reach this checkout only when it takes that base: a checkout on
+// the base branch is fast-forwarded to it, as a task's owner reconciles after delivery. The base is
+// fetched into a ref this call owns (FETCH_HEAD can be rewritten by another fetch meanwhile) and
+// merged by its commit, only while the checkout is still the one checked before the fetch, and the
+// result must be that commit. Another branch, or a fast-forward Git refuses (local changes or ignored
+// files in the way, local commits), is left as it is.
+function cleanupUpdateCheckout(scope) {
+  const failed = (detail) => ({ error: cleanupReason('update-checkout', { detail }) });
+  const read = (args) => {
+    const result = cleanupGit(scope.root, args);
+    return !result.error && result.status === 0 ? result.stdout.trim() : null;
+  };
+  const checkout = () => [read(['symbolic-ref', '--quiet', '--short', 'HEAD']), read(['rev-parse', 'HEAD'])];
+  const [branch, head] = checkout();
+  if (branch !== scope.remote.base || !head) return failed(`${branch || 'a detached HEAD'} is checked out`);
+  const ref = `refs/devlyn/cleanup/${crypto.randomBytes(8).toString('hex')}`;
+  try {
+    const fetched = cleanupGit(scope.root, ['fetch', '--quiet', '--no-write-fetch-head', 'origin', `+refs/heads/${scope.remote.base}:${ref}`]);
+    if (fetched.error || fetched.status !== 0) return failed(fetched.error?.message || fetched.stderr.trim());
+    const target = read(['rev-parse', '--verify', `${ref}^{commit}`]);
+    const [now, at] = checkout();
+    if (!target || now !== branch || at !== head) return failed('the checkout changed while the base was fetched');
+    // The branch's own merge options (`--squash`, `-s ours`) would turn this into something else.
+    const merged = cleanupGit(scope.root, ['-c', `branch.${branch}.mergeOptions=`,
+      'merge', '--ff-only', '--no-squash', '--no-autostash', '--no-overwrite-ignore', '--quiet', target]);
+    if (merged.error || merged.status !== 0) return failed(merged.error?.message || merged.stderr.trim());
+    const [after, landed] = checkout();
+    return after === branch && landed === target ? {} : failed('the fast-forward did not land on the base');
+  } finally {
+    cleanupGit(scope.root, ['update-ref', '-d', ref]);
+  }
+}
+
 // Inside the allocated worktree: prove every reviewed item, remove them, commit, and write the
 // acceptance completion binds. A failure releases the worktree; so does a throw, in the caller.
-function cleanupDeliveryCommit(worktree, items, current, release) {
+// With every reviewed item already settled by the remote base, the worktree is released with
+// nothing to deliver.
+function cleanupDeliveryCommit(worktree, items, current, release, settledUpstream) {
   const fresh = cleanupProjectScope(worktree, current);
   const available = new Map(fresh.items.map((item) => [`${item.kind}\u0000${item.relative}`, item]));
   const pairs = items.map((reviewed) => {
     const fresh = available.get(`${reviewed.kind}\u0000${reviewed.relative}`);
     return { reviewed, fresh, before: fresh && cleanupPreimage(fresh.path) };
   });
-  const stale = pairs.filter(({ reviewed, fresh, before }) => !fresh || fresh.action !== reviewed.action || fresh.route !== 'delivery'
-    || before.type !== reviewed.before.type || before.sha256 !== reviewed.before.sha256);
+  const stale = pairs.filter(({ reviewed, fresh, before }) => (fresh
+    ? fresh.action !== reviewed.action || fresh.route !== 'delivery'
+      || before.type !== reviewed.before.type || before.sha256 !== reviewed.before.sha256
+    : !settledUpstream(reviewed.relative)));
   // Check the entire batch before mutating even one item; the remote base cannot replace the reviewed preimage.
   if (stale.length) return release(cleanupReason('stale-plan', { detail: stale.map(({ reviewed }) => reviewed.relative).join(', ') }));
+  const present = pairs.filter(({ fresh }) => fresh);
+  if (!present.length) return release();
   const applied = [];
-  for (const { reviewed, fresh } of pairs) {
+  for (const { reviewed, fresh } of present) {
     const error = cleanupApplyItem({ ...fresh, before: reviewed.before });
     if (error) return release(cleanupReason(error.code, { ...error.params, detail: reviewed.relative }));
     applied.push(fresh.relative);

package/bin/skill-history.json

@@ -766,6 +766,8 @@
     "4.3.2",
     "4.3.3",
     "4.3.4",
-    "4.3.5"
+    "4.3.5",
+    "4.3.6",
+    "4.3.7"
   ]
 }

package/native/claude/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "devlyn",
-  "version": "4.3.5",
+  "version": "4.3.7",
   "description": "Devlyn harness skills",
   "skills": "./skills/"
 }

package/native/codex/.agents/plugins/marketplace.json

@@ -1,5 +1,5 @@
 {
-  "name": "devlyn-harness-v4-3-5",
+  "name": "devlyn-harness-v4-3-7",
   "plugins": [
     {
       "name": "devlyn",

package/native/codex/plugins/devlyn/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "devlyn",
-  "version": "4.3.5",
+  "version": "4.3.7",
   "description": "Devlyn harness skills",
   "skills": "./skills/"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "devlyn-cli",
-  "version": "4.3.5",
+  "version": "4.3.7",
   "description": "Loop & harness engineering for AI coding agents (Claude Code, Codex, and any AGENTS.md-driven agent) — core engineering principles for CLAUDE.md/AGENTS.md and a loop designer that splits one intent into tasks agents drain hands-free",
   "homepage": "https://github.com/fysoul17/devlyn-cli#readme",
   "bin": {

package/release.json

@@ -1,7 +1,7 @@
 {
   "schemaVersion": 1,
   "package": "devlyn-cli",
-  "version": "4.3.5",
+  "version": "4.3.7",
   "principles": {
     "defaults": "config/skills/_shared/runtime-principles.md",
     "memory": {
@@ -129,7 +129,7 @@
     },
     {
       "path": "bin/devlyn.js",
-      "sha256": "8ba08fe52c9529dee1bf13498ab3237fc25830f7f7305337fd832f32d158be7e",
+      "sha256": "5841ad32184de3095edffc5d05ae78dded34dc0ce829e8f805218de8b0085b1f",
       "executable": true
     },
     {
@@ -164,7 +164,7 @@
     },
     {
       "path": "bin/skill-history.json",
-      "sha256": "9f05ea3fb4cb17ee7b907e4ade9e8d337e02e0b027900d4f10b4285659c0d611",
+      "sha256": "8272d3975ef06e1108c16c0d56b2178a4de73e2020f82f1f10a50c2a3d5ddb46",
       "executable": false
     },
     {
@@ -309,7 +309,7 @@
     },
     {
       "path": "native/claude/.claude-plugin/plugin.json",
-      "sha256": "c98a45d3472202762065f334608b691be0e092dbb462d50e8409e7a7f4f8ef79",
+      "sha256": "c582e887aaad4322678e85ba02997ff51ef8f30d2fa50458024787884422117b",
       "executable": false
     },
     {
@@ -439,12 +439,12 @@
     },
     {
       "path": "native/codex/.agents/plugins/marketplace.json",
-      "sha256": "27ded4de671a2051d0b3408449e1c54259575499ee1ab030b54560bef253b966",
+      "sha256": "74699fb150844bc39ebd1cf11696c993d22c7f9add43b21e8656efd8af3f70de",
       "executable": false
     },
     {
       "path": "native/codex/plugins/devlyn/.codex-plugin/plugin.json",
-      "sha256": "c98a45d3472202762065f334608b691be0e092dbb462d50e8409e7a7f4f8ef79",
+      "sha256": "c582e887aaad4322678e85ba02997ff51ef8f30d2fa50458024787884422117b",
       "executable": false
     },
     {
@@ -1619,12 +1619,12 @@
     },
     {
       "path": "package.json",
-      "sha256": "17b8bb37a212506ba6b8cb78ae7339f373e8b98f1948ae4c6d4ce7b5baa2171d",
+      "sha256": "0450b10c13cf6b932b441138368a46060b2a2278bfde57474bb73b4ceb160de9",
       "executable": false
     }
   ],
   "digest": {
     "algorithm": "sha256",
-    "value": "9eb18506f59eae355306d846f340a7f1ac5ed59f3009c5bafb5f846a56cac45b"
+    "value": "05823285e84ce3fc21e7003776b7216cbdbb78b7f4cc0f5029d2976736326f59"
   }
 }