@brainervirus/workit-core 8.6.0 → 8.6.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brainervirus/workit-core",
-  "version": "8.6.0",
+  "version": "8.6.1",
   "private": false,
   "description": "Workit shared core — task, policy, evidence, review, decision, worker, and writer state for agentic coding workflows",
   "keywords": [

package/src/git/ops.ts

@@ -811,6 +811,32 @@ export type PushOutcome = {
 };
 
 const SHA = /^[0-9a-f]{40,64}$/u;
+const SHA_PREFIX = /^[0-9a-f]{7,39}$/u;
+
+/** Resolve an abbreviated `--expect` against the known remote tips; refuse unknown or ambiguous. */
+export function resolveExpectPrefix(
+  prefix: string,
+  tips: ReadonlyArray<string | null | undefined>,
+  label: string,
+): { ok: true; sha: string } | { ok: false; code: "invalid_input"; error: string } {
+  const known = [...new Set(tips.filter((tip): tip is string => typeof tip === "string"))];
+  if (!SHA_PREFIX.test(prefix))
+    return {
+      ok: false,
+      code: "invalid_input",
+      error: "--expect must be a commit sha (full, or an abbreviation of at least 7 hex digits)",
+    };
+  const matches = known.filter((tip) => tip.startsWith(prefix));
+  if (matches.length === 1) return { ok: true, sha: matches[0] };
+  return {
+    ok: false,
+    code: "invalid_input",
+    error:
+      matches.length > 1
+        ? `--expect ${prefix} is ambiguous for ${label}; choose one of: ${matches.join(", ")}`
+        : `--expect ${prefix} matches no known tip of ${label}${known.length ? `; known: ${known.join(", ")}` : ""}; pass the full sha`,
+  };
+}
 
 export function executePush(
   cwd: string,
@@ -835,10 +861,18 @@ export function executePush(
     const args = ["push", "--porcelain", "--no-follow-tags", "--recurse-submodules=no"];
     if (input.forceWithLease) {
       const explicit = input.expect !== undefined && input.expect !== null;
-      if (explicit && !SHA.test(input.expect as string))
-        return failure("invalid_input", "--expect must be a full commit sha");
+      let expectSha = input.expect ?? null;
+      if (explicit && !SHA.test(expectSha as string)) {
+        const resolved = resolveExpectPrefix(
+          expectSha as string,
+          [before.sha, recordedRemoteTip(cwd, plan)],
+          `${plan.remote}/${plan.branch}`,
+        );
+        if (!resolved.ok) return failure(resolved.code, resolved.error);
+        expectSha = resolved.sha;
+      }
       const integrate = `git fetch ${plan.remote} ${plan.branch} && git rebase ${plan.remote}/${plan.branch}  # or merge it; then: workit git push`;
-      const recorded = explicit ? (input.expect as string) : recordedRemoteTip(cwd, plan);
+      const recorded = explicit ? (expectSha as string) : recordedRemoteTip(cwd, plan);
       // A new branch needs no lease; otherwise workit must have recorded the tip.
       if (recorded === undefined && before.sha !== null)
         return failure(

package/src/ledger.ts

@@ -1608,7 +1608,11 @@ export function clearStanding(
  * Is `branch` checked out, with uncommitted changes, in another worktree of
  * this repository? (`codeKey` sees only the cwd's own worktree.)
  */
-function dirtyElsewhere(cwd: string, branch: string): boolean {
+function dirtyElsewhere(cwd: string, branch: string, head: string): boolean {
+  // A checkout of exactly the branch head (a verifier's detached worktree)
+  // judges what it holds: clean judges that head, whatever state another
+  // checkout of the branch is in; dirty (or unreadable) does not.
+  if (headSha(cwd) === head) return worktreeTree(cwd)?.dirty !== false;
   const list = git(cwd, ["worktree", "list", "--porcelain"]);
   let worktree: string | null = null;
   for (const line of (list ?? "").split("\n")) {
@@ -1668,7 +1672,7 @@ export function recordVerdict(
   if (!ledger.ok) return ledger;
   const key = codeKey(context.cwd, { branch, base: context.base });
   if (!key.head) return err("not_found", `branch "${branch}" has no commit to judge`);
-  if (key.dirty === true || (key.dirty === null && dirtyElsewhere(context.cwd, branch)))
+  if (key.dirty === true || (key.dirty === null && dirtyElsewhere(context.cwd, branch, key.head)))
     return err(
       "blocked",
       `dirty_worktree: ${branch} has uncommitted changes, so its head is not what was judged`,