@brainervirus/workit-core 8.30.0 → 8.31.1

package/package.json

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

package/src/core/policy/carry.ts

@@ -17,7 +17,8 @@
 import { mergeBase, fileAt } from "../../git/rev";
 import { computeLane, driftFiles, kindOf, parseRiskPaths, RISK_PATHS_FILE } from "./lane";
 
-export type CarryRule = "lane-none" | "tests-only";
+/** `rebase`: the same patch on a moved base (ledger.ts exact carry), never a drift rule. */
+export type CarryRule = "lane-none" | "tests-only" | "rebase";
 
 export type Drift =
   | { carries: true; rule: CarryRule; since: string; files: string[] }

package/src/hooks/model-switch.ts

@@ -0,0 +1,35 @@
+// A mid-session model switch (#435): the new model inherits a long context
+// whose Workit contract sits far up, so the host re-sends the compact contract
+// and the current turn context once per change, never on every turn.
+
+/** The last model seen per session, in the host plugin's own state. */
+export type SessionModels = Map<string, string>;
+
+const MAX_SESSIONS = 256;
+
+/**
+ * Record `model` for the session and say whether it differs from the last one
+ * seen. The first model a session reports is a start, not a switch; an unknown
+ * model (null) changes nothing.
+ */
+export const modelSwitched = (
+  models: SessionModels,
+  sessionId: string,
+  model: string | null,
+): boolean => {
+  if (!model) return false;
+  const previous = models.get(sessionId);
+  models.delete(sessionId);
+  models.set(sessionId, model);
+  if (models.size > MAX_SESSIONS) models.delete(models.keys().next().value!);
+  return previous !== undefined && previous !== model;
+};
+
+/** `provider/id` from a host's model reference, or null when it names none. */
+export const modelKey = (model: unknown): string | null => {
+  if (model === null || typeof model !== "object") return null;
+  const { id, providerID, provider } = model as Record<string, unknown>;
+  if (typeof id !== "string" || !id) return null;
+  const source = typeof providerID === "string" ? providerID : provider;
+  return typeof source === "string" && source ? `${source}/${id}` : id;
+};

package/src/hooks/repeat-failure.ts

@@ -0,0 +1,115 @@
+// A repeated identical failing Workit call (#435): the second failure in a row
+// of the same tool and args (or the same `workit …` command) in a session ends
+// with one line naming the exact corrected next call, instead of the same error.
+import { createHash } from "node:crypto";
+
+export const SAME_CALL_FAILED = "Same call failed twice:";
+
+/** The last failing call's hash per session, in the host plugin's own state. */
+export type FailureMemo = Map<string, string>;
+
+const MAX_SESSIONS = 256;
+
+const stable = (value: unknown): string =>
+  JSON.stringify(value, (_key, entry: unknown) =>
+    entry && typeof entry === "object" && !Array.isArray(entry)
+      ? Object.fromEntries(Object.entries(entry).toSorted(([a], [b]) => a.localeCompare(b)))
+      : entry,
+  ) ?? "null";
+
+const hashOf = (call: string): string =>
+  createHash("sha256").update(call).digest("hex").slice(0, 32);
+
+/**
+ * Record this call's outcome for the session. A success clears the memo; a
+ * failure returns the escalation line when the previous call failed the same
+ * way and a corrected call is known.
+ */
+const record = (
+  memo: FailureMemo,
+  sessionId: string,
+  call: string,
+  failed: boolean,
+  next: string | null,
+): string | null => {
+  const previous = memo.get(sessionId);
+  memo.delete(sessionId);
+  if (!failed) return null;
+  const hash = hashOf(call);
+  memo.set(sessionId, hash);
+  if (memo.size > MAX_SESSIONS) memo.delete(memo.keys().next().value!);
+  return previous === hash && next ? `${SAME_CALL_FAILED} ${next}` : null;
+};
+
+type Failed = { ok: false; error: string; details?: { guidance?: unknown } };
+
+const isFailure = (result: unknown): result is Failed =>
+  result !== null &&
+  typeof result === "object" &&
+  (result as { ok?: unknown }).ok === false &&
+  typeof (result as { error?: unknown }).error === "string";
+
+/** A failed tool result's corrected payload: its `Example:` or, failing that, its guidance. */
+const correctedPayload = (tool: string, result: Failed): string | null => {
+  const example = /Example: (\{.*\})\s*$/.exec(result.error)?.[1];
+  if (example) return `${tool} ${example}`;
+  const guidance = result.details?.guidance;
+  return typeof guidance === "string" && guidance ? guidance : null;
+};
+
+/**
+ * A Workit tool result, with the escalation line appended to its error when
+ * the same tool and args failed on the session's previous call too.
+ */
+export const escalateToolFailure = <T>(
+  memo: FailureMemo,
+  sessionId: string,
+  tool: string,
+  input: unknown,
+  result: T,
+): T => {
+  const failed = isFailure(result);
+  const line = record(
+    memo,
+    sessionId,
+    `tool\0${tool}\0${stable(input)}`,
+    failed,
+    failed ? correctedPayload(tool, result) : null,
+  );
+  return line && failed ? { ...result, error: `${result.error}\n${line}` } : result;
+};
+
+const WORKIT_COMMAND = /^\s*(?:[A-Za-z_][A-Za-z0-9_]*=\S*\s+)*workit\s/;
+
+const unblockOf = (output: string): string | null => {
+  const human = /^\s*unblock: (.+)$/m.exec(output)?.[1];
+  if (human) return human.trim();
+  const json = /"unblock":("(?:[^"\\]|\\.)*")/.exec(output)?.[1];
+  if (!json) return null;
+  try {
+    return JSON.parse(json) as string;
+  } catch {
+    return null;
+  }
+};
+
+/**
+ * The escalation line for a finished `workit …` shell command, or null: a
+ * failed run is one whose output carries the CLI's error envelope.
+ */
+export const repeatedCliFailure = (
+  memo: FailureMemo,
+  sessionId: string,
+  command: string,
+  output: string,
+): string | null => {
+  if (!WORKIT_COMMAND.test(command)) return null;
+  const failed = /^workit: /m.test(output) || /"ok":\s*false/.test(output);
+  return record(
+    memo,
+    sessionId,
+    `cli\0${command.trim()}`,
+    failed,
+    failed ? unblockOf(output) : null,
+  );
+};

package/src/ledger.ts

@@ -33,7 +33,8 @@
 //   `base`, the stable patch-id of `base...head` and an exact diff hash. It is
 //   `fresh` (same head; verdicts on a dirty worktree are refused, so the head
 //   is the judged tree), `carried` (new head, same patch-id AND same exact
-//   diff AND, for a pass, byte-identical own files the base left alone: a
+//   diff AND, for a pass, byte-identical own files the base left alone, or
+//   a head that is exactly the judged head cleanly rebased (cleanRebase): a
 //   rebase that only moved the base; or a trusted verdict whose
 //   follow-up change is lane none, or test-only for a unit verdict, see
 //   core/policy/carry.ts) or `stale`.
@@ -338,6 +339,32 @@ export function diffHash(cwd: string, base: string, head: string): string | null
   return `sha256:${hash.digest("hex")}`;
 }
 
+/**
+ * Whether `to` (on `toBase`) is exactly the judged `from` (on `fromBase`)
+ * rebased cleanly onto the moved base: a 3-way merge of `from` onto
+ * `merge-base(toBase, to)` with `merge-base(fromBase, from)` as the ancestor
+ * has no conflict and yields `to`'s tree. Hunks are anchored to the
+ * ancestor, so an edit moved elsewhere in a file, a conflict resolved by
+ * hand, or any other change in the branch's files makes the trees differ.
+ * False when git cannot tell (no `merge-tree --merge-base`, before 2.40).
+ */
+function cleanRebase(
+  cwd: string,
+  range: { from: string; to: string; fromBase: string; toBase: string },
+): boolean {
+  if (!Object.values(range).every(safeRef)) return false;
+  const fromFork = git(cwd, ["merge-base", range.fromBase, range.from]);
+  const toFork = git(cwd, ["merge-base", range.toBase, range.to]);
+  if (!fromFork || !toFork || fromFork === toFork) return false;
+  const merged = gitRun(
+    cwd,
+    ["merge-tree", "--write-tree", "--no-messages", `--merge-base=${fromFork}`, toFork, range.from],
+    GIT_TIMEOUTS.worktree,
+  );
+  const tree = merged.ok ? merged.stdout.split("\n")[0]?.trim() : null;
+  return Boolean(tree) && tree === git(cwd, ["rev-parse", "--verify", "-q", `${range.to}^{tree}`]);
+}
+
 // ---------------------------------------------------------------------------
 // store root (D13)
 
@@ -1124,7 +1151,9 @@ export type Reverify = { scope: "focused"; since: string; files: string[] };
 
 /** `carried (lane none since <head>)`: how a carried verdict reads in `ledger check` and `pr status`. */
 export const carryLabel = (carry: CarryNote): string =>
-  `carried (${carry.rule === "lane-none" ? "lane none" : "tests only"} since ${carry.since.slice(0, 12)})`;
+  carry.rule === "rebase"
+    ? "carried (rebase: patch unchanged)"
+    : `carried (${carry.rule === "lane-none" ? "lane none" : "tests only"} since ${carry.since.slice(0, 12)})`;
 
 export type VerdictCheck = {
   branch: string;
@@ -1516,31 +1545,49 @@ export function checkVerdicts(
   };
   // The same patch-id and diff hash are not enough to carry a pass (#334):
   // both drop hunk line numbers, so an edit moved within a file keeps them.
-  // The branch's own files must be identical blobs too (sameOwnChange). A
-  // failure keeps the looser carry: it fails closed by applying more.
-  const exactCache = new Map<ReadRow, boolean>();
-  const exactCarry = (row: ReadRow): boolean => {
-    if (FAILING.has(String(row.result))) return true;
+  // The branch's own files must be identical blobs too (sameOwnChange), or
+  // the head must be exactly the judged head cleanly rebased onto the moved
+  // base (cleanRebase): a base edit elsewhere in a file the branch touches.
+  // A failure keeps the looser carry: it fails closed by applying more.
+  // How a pass's own files match: identical blobs, a clean rebase, or neither.
+  const exactCache = new Map<ReadRow, "same" | "rebase" | null>();
+  const exactMatch = (row: ReadRow): "same" | "rebase" | null => {
     let exact = exactCache.get(row);
     if (exact === undefined) {
       const toBase = row.base ?? fallbackBase;
       const toBaseSha = toBase ? resolveCommit(cwd, toBase) : null;
       const fromBase = row.baseSha ?? toBaseSha;
-      exact = Boolean(
-        row.head &&
-        head &&
-        toBaseSha &&
-        fromBase &&
-        sameOwnChange(cwd, { from: row.head, to: head, fromBase, toBase: toBaseSha }),
-      );
+      const range =
+        row.head && head && toBaseSha && fromBase
+          ? { from: row.head, to: head, fromBase, toBase: toBaseSha }
+          : null;
+      exact = !range
+        ? null
+        : sameOwnChange(cwd, range)
+          ? "same"
+          : cleanRebase(cwd, range)
+            ? "rebase"
+            : null;
       exactCache.set(row, exact);
     }
     return exact;
   };
+  const exactCarry = (row: ReadRow): boolean =>
+    FAILING.has(String(row.result)) || exactMatch(row) !== null;
   const keyBasis = (row: ReadRow): Exclude<VerdictBasis, "none"> => {
     const basis = verdictBasis(row, { head, ...keyFor(row.base ?? fallbackBase) });
     return basis === "carried" && !exactCarry(row) ? "stale" : basis;
   };
+  /** A pass the exact keys carry only through a clean rebase (the base also edited a branch file). */
+  const rebaseNote = (row: ReadRow): CarryNote | null =>
+    row.head &&
+    head &&
+    row.head !== head &&
+    !FAILING.has(String(row.result)) &&
+    keyBasis(row) === "carried" &&
+    exactMatch(row) === "rebase"
+      ? { rule: "rebase", since: row.head, files: [] }
+      : null;
   const restacked = (row: ReadRow): boolean =>
     restackCarries(FAILING.has(String(row.result)) ? null : cwd, rows, branch, row.head, head);
   /** The follow-up carry of a verdict the exact keys and restacks do not carry. */
@@ -1646,7 +1693,7 @@ export function checkVerdicts(
       independent: independence.length === 0,
       accepted: reasons.length === 0,
       reasons,
-      carry: basis === "carried" ? carryOf(row) : null,
+      carry: basis === "carried" ? (rebaseNote(row) ?? carryOf(row)) : null,
       verdict: row,
     });
     // The author's own failure never displaces an independent pass, but it