@brainervirus/workit-cli 2.2.0 → 2.2.2

package/dist/index.js

@@ -9822,7 +9822,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");
@@ -9865,7 +9865,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)
@@ -10675,6 +10675,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 path5.join(this.tasksDir, `${taskId}.json`);
   }
@@ -14756,6 +14759,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)
@@ -14787,6 +14793,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;
@@ -14888,6 +14897,9 @@ class WorkitCore {
     });
   }
   task(request) {
+    return this.retryOmittedRevisions(request, () => this.taskOnce(request));
+  }
+  taskOnce(request) {
     const root = this.contextRootError();
     if (!root.ok)
       return root;
@@ -14987,6 +14999,9 @@ class WorkitCore {
     }
   }
   policy(request) {
+    return this.retryOmittedRevisions(request, () => this.policyOnce(request));
+  }
+  policyOnce(request) {
     const root = this.contextRootError();
     if (!root.ok)
       return root;
@@ -15033,6 +15048,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;
@@ -15117,6 +15135,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)
@@ -15141,6 +15176,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")
@@ -15189,7 +15225,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;
@@ -15201,14 +15250,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));
@@ -15222,7 +15271,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");
@@ -15239,13 +15288,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;
@@ -15369,6 +15421,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;
@@ -15716,6 +15771,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;
@@ -16474,7 +16532,25 @@ var provenance = (context, kind = context.provenanceKind ?? "host_observed") =>
     return changed;
   const updated = changed.data.task.workers.find((candidate) => candidate.id === input.workerId);
   return updated ? success(changed.data.task.revision, changed.data.workspace.revision, updated) : failure2("recovery_required", "worker disappeared during lifecycle observation");
-}, refsWithinScope = (refs, scope) => refs.every((ref) => ref.kind !== "file" || bindingCovers(scope, { description: "", paths: [ref.path], exclusions: [] })), trustedNow = (context) => typeof context.now === "function" ? context.now() : context.now, mapRef = (ref, ids) => {
+}, refsWithinScope = (refs, scope) => refs.every((ref) => ref.kind !== "file" || bindingCovers(scope, { description: "", paths: [ref.path], exclusions: [] })), REVISION_RETRY_ATTEMPTS = 8, retryPause, filledRevisions = (request) => {
+  const value = typeof request === "object" && request !== null ? request : {};
+  return {
+    task: value.expectedRevision === undefined,
+    workspace: value.expectedWorkspaceRevision === undefined
+  };
+}, filledConflict = (result, filled) => !result.ok && result.code === "revision_conflict" && (("actualRevision" in result.details) && filled.task || ("actualWorkspaceRevision" in result.details) && filled.workspace), 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;
+}, trustedNow = (context) => typeof context.now === "function" ? context.now() : context.now, mapRef = (ref, ids) => {
   if (ref.kind !== "record")
     return ref;
   return { ...ref, id: ids.get(ref.id) ?? ref.id };
@@ -16685,11 +16761,13 @@ var init_task_engine = __esm(() => {
   init_authority();
   init_policy_resolver();
   init_auto_approval();
+  init_store_lock();
   init_task_context();
   init_workers();
   init_task_evaluation();
   verifiedWorkers = new WeakMap;
   dispatchReservations = new WeakMap;
+  retryPause = new Int32Array(new SharedArrayBuffer(4));
 });
 
 // packages/workit-core/src/core.ts
@@ -73026,7 +73104,7 @@ import path34 from "node:path";
 // packages/workit-cli/package.json
 var package_default = {
   name: "@brainervirus/workit-cli",
-  version: "2.1.5",
+  version: "2.2.1",
   private: false,
   description: "Workit CLI — setup wizard, doctor, and task control for agentic coding workflows",
   keywords: [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brainervirus/workit-cli",
-  "version": "2.2.0",
+  "version": "2.2.2",
   "private": false,
   "description": "Workit CLI — setup wizard, doctor, and task control for agentic coding workflows",
   "keywords": [
@@ -37,9 +37,9 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@brainervirus/workit-core": "^2.2.0",
-    "@brainervirus/workit-cursor": "^2.2.0",
-    "@brainervirus/workit-opencode": "^2.2.0",
+    "@brainervirus/workit-core": "^2.2.2",
+    "@brainervirus/workit-cursor": "^2.2.2",
+    "@brainervirus/workit-opencode": "^2.2.2",
     "@inkjs/ui": "2.0.0",
     "ink": "7.1.1",
     "react": "19.2.8"