@brainervirus/workit-pi 2.2.0 → 2.2.2

package/dist/worker.js

@@ -8563,6 +8563,7 @@ var resolverInputSchema = object({
 // packages/workit-core/src/core/task-engine.ts
 var verifiedWorkers = new WeakMap;
 var dispatchReservations = new WeakMap;
+var retryPause = new Int32Array(new SharedArrayBuffer(4));
 // packages/workit-pi/src/worker-protocol.ts
 var MAX_WORKER_LINE_BYTES = 64 * 1024;
 var MAX_WORKER_STDERR_BYTES = 64 * 1024;

package/dist/workit.js

@@ -10022,7 +10022,7 @@ class TaskStore {
       if (!current.data)
         return failure2("not_found", "workspace not found");
       if (current.data.revision !== expected)
-        return this.conflict(expected, current.data.revision);
+        return this.workspaceConflict(expected, current.data.revision);
       const previousBytes = this.snapshotBytes(this.workspacePath);
       if (!previousBytes)
         return failure2("storage_error", "workspace snapshot disappeared during mutation");
@@ -10065,7 +10065,7 @@ class TaskStore {
       if (task.data.revision !== expected)
         return this.conflict(expected, task.data.revision);
       if (workspace.data.revision !== input.expectedWorkspaceRevision)
-        return this.conflict(input.expectedWorkspaceRevision, workspace.data.revision);
+        return this.workspaceConflict(input.expectedWorkspaceRevision, workspace.data.revision);
       const previousWorkspaceBytes = this.snapshotBytes(this.workspacePath);
       const previousTaskBytes = this.snapshotBytes(this.taskPath(input.taskId));
       if (!previousWorkspaceBytes || !previousTaskBytes)
@@ -10875,6 +10875,9 @@ class TaskStore {
       actualRevision: actual
     });
   }
+  workspaceConflict(expected, actual) {
+    return failure2("revision_conflict", "workspace revision does not match; omit expectedWorkspaceRevision to use the current record", { expectedWorkspaceRevision: expected, actualWorkspaceRevision: actual });
+  }
   taskPath(taskId) {
     return path4.join(this.tasksDir, `${taskId}.json`);
   }
@@ -13728,8 +13731,10 @@ values are still concurrency-checked, so never copy revisions between calls.
 A busy result means another live Workit call holds the checkout lock: retry the
 same call; it is not a recovery condition. A lock left by a dead process is
 reclaimed on the next write, and \`workit doctor --fix-lock\` clears it on demand.
-A revision_conflict on a call that omitted expectedRevision is contention too:
-re-read the record and retry the call.
+An omitted revision absorbs a concurrent write: Workit re-reads, re-checks
+policy, and reapplies the call, returning busy under persistent contention. A
+revision_conflict means a revision you passed is stale: re-read the record
+before deciding whether to retry.
 A solo edit does not need writer acquisition; use it when concurrent checkout
 writers need coordination. Record only observed facts and checks. Evidence can
 become stale when its bound candidate changes; reconcile findings against the
@@ -15113,6 +15118,29 @@ var applyWorkerLifecycle = (input) => {
   return updated ? success(changed.data.task.revision, changed.data.workspace.revision, updated) : failure2("recovery_required", "worker disappeared during lifecycle observation");
 };
 var refsWithinScope = (refs, scope) => refs.every((ref) => ref.kind !== "file" || bindingCovers(scope, { description: "", paths: [ref.path], exclusions: [] }));
+var REVISION_RETRY_ATTEMPTS = 8;
+var retryPause = new Int32Array(new SharedArrayBuffer(4));
+var filledRevisions = (request) => {
+  const value = typeof request === "object" && request !== null ? request : {};
+  return {
+    task: value.expectedRevision === undefined,
+    workspace: value.expectedWorkspaceRevision === undefined
+  };
+};
+var filledConflict = (result, filled) => !result.ok && result.code === "revision_conflict" && (("actualRevision" in result.details) && filled.task || ("actualWorkspaceRevision" in result.details) && filled.workspace);
+var retryFilledRevisions = (filled, run) => {
+  if (!filled.task && !filled.workspace)
+    return run();
+  let result = run();
+  const deadline = Date.now() + defaultLockTimeout();
+  for (let attempt = 1;filledConflict(result, filled); attempt += 1) {
+    if (attempt >= REVISION_RETRY_ATTEMPTS || Date.now() >= deadline)
+      return failure2("busy", "records kept changing under concurrent writers; retry the call");
+    Atomics.wait(retryPause, 0, 0, Math.floor(Math.random() * 4 * attempt) + 1);
+    result = run();
+  }
+  return result;
+};
 var trustedNow = (context) => typeof context.now === "function" ? context.now() : context.now;
 var mapRef = (ref, ids) => {
   if (ref.kind !== "record")
@@ -15360,6 +15388,9 @@ class WorkitCore {
     if (input.expectedWorkspaceRevision === undefined)
       input.expectedWorkspaceRevision = workspace ? workspace.revision : null;
   }
+  retryOmittedRevisions(request, run) {
+    return retryFilledRevisions(filledRevisions(request), run);
+  }
   helperEntry(task, requireSession = false, requireActive = false) {
     const workerId = this.context.workerId ?? null;
     if (workerId === null)
@@ -15391,6 +15422,9 @@ class WorkitCore {
     return null;
   }
   state(request) {
+    return request?.action === "import" ? this.retryOmittedRevisions(request, () => this.stateOnce(request)) : this.stateOnce(request);
+  }
+  stateOnce(request) {
     const root = this.contextRootError();
     if (!root.ok)
       return root;
@@ -15492,6 +15526,9 @@ class WorkitCore {
     });
   }
   task(request) {
+    return this.retryOmittedRevisions(request, () => this.taskOnce(request));
+  }
+  taskOnce(request) {
     const root = this.contextRootError();
     if (!root.ok)
       return root;
@@ -15591,6 +15628,9 @@ class WorkitCore {
     }
   }
   policy(request) {
+    return this.retryOmittedRevisions(request, () => this.policyOnce(request));
+  }
+  policyOnce(request) {
     const root = this.contextRootError();
     if (!root.ok)
       return root;
@@ -15637,6 +15677,9 @@ class WorkitCore {
     return success(changed.data.revision, null, changed.data.policy);
   }
   evidence(request) {
+    return this.retryOmittedRevisions(request, () => this.evidenceOnce(request));
+  }
+  evidenceOnce(request) {
     const root = this.contextRootError();
     if (!root.ok)
       return root;
@@ -15721,6 +15764,23 @@ class WorkitCore {
   observeStandingDecision(request) {
     return this.recordDecision(request, undefined, true, true);
   }
+  commitTask(taskId, expected, filled, recheck, update) {
+    let revision = expected;
+    let first = true;
+    return retryFilledRevisions({ task: filled, workspace: false }, () => {
+      if (!first) {
+        const fresh = this.store.readTask(taskId);
+        if (!fresh.ok)
+          return fresh;
+        const checked = recheck(fresh.data);
+        if (!checked.ok)
+          return checked;
+        revision = fresh.data.revision;
+      }
+      first = false;
+      return this.store.mutateTask(taskId, revision, update, trustedNow(this.context));
+    });
+  }
   recordDecision(request, nativeObservation, nativeRequired = false, standing = false) {
     const root = this.contextRootError();
     if (!root.ok)
@@ -15745,6 +15805,7 @@ class WorkitCore {
       return task;
     if ((this.context.workerId ?? null) !== null)
       return failure2("permission_denied", "helpers cannot record or revoke decisions");
+    const filled = input.expectedRevision === undefined;
     this.fillRevisions(input, task.data);
     if (input.action === "record") {
       if (task.data.status === "closed")
@@ -15793,7 +15854,20 @@ class WorkitCore {
       const nativeProvenance = native?.ok ? retireNativeAuthority(native.data) : null;
       if (native?.ok && !nativeProvenance)
         return failure2("permission_denied", "native decision authority was retired");
-      const changed = this.store.mutateTask(task.data.id, input.expectedRevision, (current, mutation) => {
+      let standingProvenance = standingApproval?.ok === true ? standingApproval.data : null;
+      const recheck = (fresh) => {
+        if (fresh.status === "closed")
+          return failure2("invalid_transition", "closed task cannot record a decision");
+        if (!standingProvenance)
+          return success(null, null, null);
+        const again = verifyStandingApproval(this.store.root, fresh, this.context.caller, input.binding);
+        if (again.ok)
+          standingProvenance = again.data;
+        return again;
+      };
+      const changed = this.commitTask(task.data.id, input.expectedRevision, filled, recheck, (current, mutation) => {
+        if (current.status === "closed")
+          return failure2("invalid_transition", "closed task cannot record a decision");
         const latestContent = verifyDecisionContent(this.store, input.binding);
         if (!latestContent.ok)
           return latestContent;
@@ -15805,14 +15879,14 @@ class WorkitCore {
         const entry = {
           id: newId(),
           recordedAt: mutation.now,
-          provenance: standingApproval?.ok === true ? standingApproval.data : nativeProvenance ?? provenance(this.context, "agent_reported"),
+          provenance: standingProvenance ?? nativeProvenance ?? provenance(this.context, "agent_reported"),
           data
         };
         return success(mutation.revision, null, {
           ...current,
           decisions: [...current.decisions, entry]
         });
-      }, trustedNow(this.context));
+      });
       if (!changed.ok)
         return changed;
       return success(changed.data.revision, null, changed.data.decisions.at(-1));
@@ -15826,7 +15900,7 @@ class WorkitCore {
       return failure2("invalid_transition", "decision is already revoked");
     if (decision.data.consumption)
       return failure2("permission_denied", "consumed decision cannot be revoked");
-    const changed = this.store.mutateTask(task.data.id, input.expectedRevision, (current, mutation) => {
+    const changed = this.commitTask(task.data.id, input.expectedRevision, filled, () => success(null, null, null), (current, mutation) => {
       const entry = current.decisions.find((candidate) => candidate.id === input.decisionId);
       if (!entry)
         return failure2("not_found", "decision not found");
@@ -15843,13 +15917,16 @@ class WorkitCore {
         ...current,
         decisions: current.decisions.map((candidate) => candidate.id === input.decisionId ? updated : candidate)
       });
-    }, trustedNow(this.context));
+    });
     if (!changed.ok)
       return changed;
     const entry = changed.data.decisions.find((candidate) => candidate.id === input.decisionId);
     return entry ? success(changed.data.revision, null, entry) : failure2("recovery_required", "decision disappeared");
   }
   finding(request) {
+    return this.retryOmittedRevisions(request, () => this.findingOnce(request));
+  }
+  findingOnce(request) {
     const root = this.contextRootError();
     if (!root.ok)
       return root;
@@ -15973,6 +16050,9 @@ class WorkitCore {
     return entry ? success(changed.data.revision, null, entry) : failure2("recovery_required", "finding disappeared");
   }
   worker(request) {
+    return this.retryOmittedRevisions(request, () => this.workerOnce(request));
+  }
+  workerOnce(request) {
     const root = this.contextRootError();
     if (!root.ok)
       return root;
@@ -16320,6 +16400,9 @@ class WorkitCore {
     return applied;
   }
   writer(request) {
+    return this.retryOmittedRevisions(request, () => this.writerOnce(request));
+  }
+  writerOnce(request) {
     const root = this.contextRootError();
     if (!root.ok)
       return root;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brainervirus/workit-pi",
-  "version": "2.2.0",
+  "version": "2.2.2",
   "description": "Workit native extension for Pi — tools, method skills, and session continuity",
   "keywords": [
     "agentic-coding",