@brainervirus/workit-mcp 2.2.0 → 2.2.1

package/dist/index.js

@@ -19059,7 +19059,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");
@@ -19102,7 +19102,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)
@@ -19912,6 +19912,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`);
   }
@@ -22964,6 +22967,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")
@@ -23211,6 +23237,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)
@@ -23242,6 +23271,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;
@@ -23343,6 +23375,9 @@ class WorkitCore {
     });
   }
   task(request) {
+    return this.retryOmittedRevisions(request, () => this.taskOnce(request));
+  }
+  taskOnce(request) {
     const root = this.contextRootError();
     if (!root.ok)
       return root;
@@ -23442,6 +23477,9 @@ class WorkitCore {
     }
   }
   policy(request) {
+    return this.retryOmittedRevisions(request, () => this.policyOnce(request));
+  }
+  policyOnce(request) {
     const root = this.contextRootError();
     if (!root.ok)
       return root;
@@ -23488,6 +23526,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;
@@ -23572,6 +23613,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)
@@ -23596,6 +23654,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")
@@ -23644,7 +23703,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;
@@ -23656,14 +23728,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));
@@ -23677,7 +23749,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");
@@ -23694,13 +23766,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;
@@ -23824,6 +23899,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;
@@ -24171,6 +24249,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-mcp",
-  "version": "2.2.0",
+  "version": "2.2.1",
   "private": false,
   "description": "Workit shared MCP transport for the eight task and policy operation families",
   "keywords": [
@@ -42,7 +42,7 @@
     "build": "bun scripts/build.ts"
   },
   "dependencies": {
-    "@brainervirus/workit-core": "^2.2.0",
+    "@brainervirus/workit-core": "^2.2.1",
     "@modelcontextprotocol/sdk": "1.32.0",
     "zod": "4.6.5"
   },