@brainervirus/workit-core 8.5.2 → 8.6.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brainervirus/workit-core",
-  "version": "8.5.2",
+  "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/hooks/context.ts

@@ -291,11 +291,11 @@ export const turnContextText = (input: HookInput, descriptor: HostDescriptor): s
   }
 };
 
-// Change-only per-turn context. A hook-process host (Claude Code, Codex)
-// keeps each injected additionalContext in the transcript, so the task
-// context is resent only when it changed since the last injection for the
-// session. Each hook is a fresh process: the last digest lives in the
-// workspace store (`hooks/turn-<session hash>.json`). Every cache failure
+// Change-only per-turn context. Claude Code, Codex and Pi keep each injected
+// context in the transcript, so the task context is resent only when it
+// changed since the last injection for the session. Each hook is a fresh
+// process (and a Pi session can resume in another one): the last digest
+// lives in the workspace store (`hooks/turn-<session hash>.json`). Every cache failure
 // answers "changed", so context is resent rather than lost.
 
 const TURN_TTL_MS = 7 * 24 * 60 * 60 * 1000;
@@ -376,13 +376,17 @@ export const changedTurnContext = (input: HookInput, text: string | null): strin
  * A session start already injects the task context (inside the contract), so
  * the per-turn digest is seeded with what the next prompt would carry: the
  * first turn after a start, resume or compaction does not resend it. A
- * session without task context clears its digest instead.
+ * session without task context clears its digest instead. An in-process
+ * host that renders its own per-turn `text` seeds with it.
  */
-export const seedTurnContext = (input: HookInput, descriptor: HostDescriptor): void => {
+export const seedTurnContext = (
+  input: HookInput,
+  descriptor: HostDescriptor,
+  text: string | null = turnContextText(input, descriptor),
+): void => {
   const file = turnMarker(input);
   if (!file) return;
   pruneTurnDigests(path.dirname(file), Date.now());
-  const text = turnContextText(input, descriptor);
   if (text) writeTurnDigest(file, digestOf(text));
   else clearTurnDigest(file);
 };

package/src/hooks/hosts/claude-code.ts

@@ -58,9 +58,8 @@ export const CLAUDE_CODE_DESCRIPTOR: HostDescriptor = {
     perTurn: "native",
     afterCompact: "native",
     task: "session-bound",
-    // The plugin's src/hook.ts dedups per-turn context itself (its own cache)
-    // until it moves onto the core's on-change resend.
-    turnResend: "every-turn",
+    // Each additionalContext stays in the transcript: resend only on change.
+    turnResend: "on-change",
   },
   subagents: {
     identity: "native",

package/src/hooks/hosts/pi.ts

@@ -24,12 +24,12 @@ export const PI_DESCRIPTOR: HostDescriptor = {
   shellPolicy: { deny: "native", channel: "block", failClosed: false },
   context: {
     sessionStart: "native",
-    // before_agent_start runs every turn, but the extension injects the task
-    // context once per session and again after compaction, never on change.
-    perTurn: "partial",
+    // before_agent_start runs every turn; its message stays in the session,
+    // so the extension resends the task context only when it changed.
+    perTurn: "native",
     afterCompact: "native",
     task: "session-bound",
-    turnResend: "per-session",
+    turnResend: "on-change",
   },
   subagents: {
     identity: "none",

package/src/hooks/index.ts

@@ -9,7 +9,9 @@ export {
   type Support,
 } from "./descriptor";
 export {
+  changedTurnContext,
   currentTaskEntry,
+  seedTurnContext,
   sessionCompactContext,
   sessionContextText,
   turnContextText,

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`,