chainlesschain 0.166.74 → 0.166.77

package/src/lib/with-file-lock.js

@@ -519,7 +519,62 @@ function reclaimLegacyDirectory(_fs, lockDir, stat) {
   return true;
 }
 
-function completePublishedRelease(_fs, lockDir, owner, claimant, ownerAlive) {
+function completePublishedRelease(
+  _fs,
+  lockDir,
+  owner,
+  claimant,
+  ownerAlive,
+  ownerBodyFinished = false,
+) {
+  const finishedPath = path.join(
+    lockDir,
+    `.release-body-finished-${owner.token}`,
+  );
+  if (ownerBodyFinished) {
+    // Publication is already known by the owner. Persist its ended-body proof
+    // before reading the release marker: a sharing error on that read must not
+    // strand an abandoned staging path behind a still-live owner.
+    const ownerPath = path.join(lockDir, "owner.json");
+    const current = readOwnerResult(_fs, ownerPath);
+    if (
+      current.error?.code === "ENOENT" ||
+      (current.owner && !sameOwner(current.owner, owner))
+    ) {
+      return { published: true, completed: true };
+    }
+    if (current.error) throw current.error;
+    try {
+      writeOwnerMarker(_fs, finishedPath, owner);
+    } catch (error) {
+      if (error?.code === "ENOENT") {
+        const latest = readOwnerResult(_fs, ownerPath);
+        if (
+          latest.error?.code === "ENOENT" ||
+          (latest.owner && !sameOwner(latest.owner, owner))
+        ) {
+          return { published: true, completed: true };
+        }
+      }
+      if (error?.code !== "EEXIST") throw error;
+      const existing = readOwnerResult(_fs, finishedPath);
+      if (existing.error) throw existing.error;
+      if (!sameOwner(existing.owner, owner)) {
+        throw new Error("Mismatched ended-body release proof");
+      }
+    }
+    // A contender can finish the handoff after the first owner read. Remove
+    // only our own proof if its write raced with a replacement directory.
+    const latest = readOwnerResult(_fs, ownerPath);
+    if (
+      latest.error?.code === "ENOENT" ||
+      (latest.owner && !sameOwner(latest.owner, owner))
+    ) {
+      removeOwnMarker(_fs, finishedPath, owner);
+      return { published: true, completed: true };
+    }
+    if (latest.error) throw latest.error;
+  }
   const markerPath = path.join(lockDir, `.release-${owner.token}`);
   const marker = readOwner(_fs, markerPath);
   if (!sameOwner(marker, owner)) {
@@ -536,7 +591,9 @@ function completePublishedRelease(_fs, lockDir, owner, claimant, ownerAlive) {
     marker.releaseAfterPathRemoved &&
     pathStatus(_fs, marker.releaseAfterPathRemoved) !== "absent"
   ) {
-    return { published: true, completed: false };
+    if (!sameOwner(readOwner(_fs, finishedPath), owner)) {
+      return { published: true, completed: false };
+    }
   }
   const claimPath = path.join(lockDir, `.release-claim-${owner.token}`);
   for (;;) {
@@ -602,13 +659,20 @@ function releaseOwnedDirectory(
   ownerAlive,
   releaseWasPublished = false,
 ) {
+  if (releaseWasPublished) {
+    // A contender can already detach this directory. Never use the direct
+    // read-owner -> rename path after publication: it could rename a new
+    // owner's lock if a contender completes the handoff between those calls.
+    // The exclusive cleanup claim serializes all published-release helpers.
+    // The owner's body has ended even when its final commit threw and left
+    // the staging path behind. Only this owner may bypass that guard; other
+    // contenders must continue waiting until commit or claimed cleanup.
+    completePublishedRelease(_fs, lockDir, owner, owner, ownerAlive, true);
+    return true;
+  }
   if (!sameOwner(readOwner(_fs, path.join(lockDir, "owner.json")), owner)) {
-    // Once this exact owner published a guarded handoff, a contender is allowed
-    // to detach the old directory as soon as the final staging path disappears.
-    // A missing or replacement lock therefore proves successful release, not
-    // ownership loss. Without that publication the strict legacy verdict stays
-    // fail-closed.
-    return releaseWasPublished;
+    // Without a published handoff, missing or replaced ownership fails closed.
+    return false;
   }
   // Atomically move the exact owned directory out of the acquisition path,
   // then remove that uniquely-tokened directory. A replacement owner may
@@ -627,7 +691,7 @@ function releaseOwnedDirectory(
       }
       return true;
     } catch (error) {
-      if (error?.code === "ENOENT") return releaseWasPublished;
+      if (error?.code === "ENOENT") return false;
       // Windows sharing transients fall back to the marker-based release.
     }
   }
@@ -635,18 +699,19 @@ function releaseOwnedDirectory(
   try {
     writeOwnerMarker(_fs, markerPath, owner);
   } catch (error) {
-    if (error?.code === "ENOENT") return releaseWasPublished;
+    if (error?.code === "ENOENT") return false;
     if (error?.code === "EEXIST") {
       const existing = readOwner(_fs, markerPath);
       if (!sameOwner(existing, owner)) return false;
-      return completePublishedRelease(_fs, lockDir, owner, owner, ownerAlive)
-        .published;
+      completePublishedRelease(_fs, lockDir, owner, owner, ownerAlive);
+      return true;
     }
     throw error;
   }
   if (!sameOwner(readOwner(_fs, path.join(lockDir, "owner.json")), owner)) {
-    removeOwnMarker(_fs, markerPath, owner);
-    return false;
+    // The successful marker write above already handed release to contenders.
+    // A replacement owner is therefore a completed handoff, not lock loss.
+    return true;
   }
   if (typeof _fs.renameSync === "function") {
     // After publishing the marker, use the same exclusive claim protocol as a
@@ -657,8 +722,8 @@ function releaseOwnedDirectory(
     // contender may win the cleanup claim before this owner does; that is a
     // successful release, not lost ownership, because every acquirer must
     // complete or wait behind the published marker before entering its body.
-    return completePublishedRelease(_fs, lockDir, owner, owner, ownerAlive)
-      .published;
+    completePublishedRelease(_fs, lockDir, owner, owner, ownerAlive);
+    return true;
   }
   _fs.rmSync(lockDir, { recursive: true, force: true });
   return true;

package/src/runtime/headless-runner.js

@@ -2443,6 +2443,13 @@ async function runAgentHeadlessInWorkspace(
   const skillDecisionOptions = resolveHeadlessSkillDecisionOptions(options);
   let skillDecisionRuntime = null;
   if (skillDecisionOptions.mode !== "off") {
+    const previousUnknownDecisionUsage = store.findLatestEvent(
+      sessionId,
+      "model_usage_unknown",
+      (event) =>
+        typeof event?.data?.operationId === "string" &&
+        event.data.operationId.startsWith("decision:"),
+    );
     const decisionProvider =
       deps.decisionProvider ||
       createDecisionProvider({
@@ -2469,6 +2476,7 @@ async function runAgentHeadlessInWorkspace(
       observe: (observation) =>
         persistDecisionEvent("skill_decision_observation", observation),
       sessionBudget: options.sessionBudget || null,
+      initialUsageUnknown: previousUnknownDecisionUsage != null,
       timeoutMs: skillDecisionOptions.timeoutMs,
     });
   }

package/src/assets/web-panel/assets/devWarning-Isft1nEX.js

@@ -1 +0,0 @@
-import{Q as r}from"./index-BOjTRSHE.js";const o=((n,a,e)=>{r(n,`[ant-design-vue: ${a}] ${e}`)});export{o as d};

package/src/assets/web-panel/assets/index-B_T9NUk7.js

@@ -1 +0,0 @@
-import{C as o}from"./Col-BmstiyBM.js";import{a0 as t}from"./index-BOjTRSHE.js";import"./vendor-Bn1JzzAn.js";import"./index-BA0FMuDX.js";import"./icons-DG5UD-6K.js";const s=t(o);export{s as default};

package/src/assets/web-panel/assets/index-DBqUxaat.js

@@ -1 +0,0 @@
-import{A as o}from"./Row-B6Ukqvli.js";import{a0 as t}from"./index-BOjTRSHE.js";import"./vendor-Bn1JzzAn.js";import"./responsiveObserve-DzFM_TQf.js";import"./useFlexGapSupport-CjXXcU1j.js";import"./styleChecker-BzoT0TfJ.js";import"./index-BA0FMuDX.js";import"./icons-DG5UD-6K.js";const l=t(o);export{l as default};