@brainervirus/workit-core 8.22.1 → 8.22.3

package/package.json

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

package/src/core/task-contract.ts

@@ -1068,10 +1068,6 @@ export const advertisedOperationSchemas = {
 } as const;
 export type TaskStartRequest = z.infer<typeof taskOperations.start>;
 
-const compiledOperationSchemas = Object.fromEntries(
-  OPERATION_FAMILIES.map((family) => [family, z.compile(operationSchemas[family])]),
-) as typeof operationSchemas;
-
 export type Id = string;
 export type Revision = string;
 export type Digest = string;
@@ -1165,8 +1161,7 @@ export function parseOperation(family: OperationFamily, input: unknown): Result<
     (input as { schemaVersion?: unknown }).schemaVersion !== SCHEMA_VERSION
   )
     return failure("unsupported_version", "unsupported schema version", { operation: family });
-  const compiled = compiledOperationSchemas[family].safeParse(input);
-  const parsed = compiled.success ? operationSchemas[family].safeParse(input) : compiled;
+  const parsed = operationSchemas[family].safeParse(input);
   if (parsed.success) return success(null, null, parsed.data);
   const fields = parsed.error.issues.map((issue) => ({
     path: issue.code === "unrecognized_keys" ? issue.keys.join(".") : issue.path.join("."),

package/src/hooks/hosts/cursor.ts

@@ -408,6 +408,6 @@ export const cursorAdapter: HostAdapter = {
   // only), so the agent is told the id its `workit` calls should act as.
   addendum: (input) =>
     input.session.id
-      ? `<workit-session>Cursor puts no session id in the shell: prefix workit commands that record authorship with WORKIT_SESSION_ID=${input.session.id} (e.g. \`WORKIT_SESSION_ID=${input.session.id} workit git commit -m …\`). A verifier uses its own id, never this one.</workit-session>`
+      ? `<workit-session>Cursor puts no session id in the shell: start workit commands that record authorship with the global flag \`--session ${input.session.id}\` (e.g. \`workit --session ${input.session.id} git commit -m …\`; a leading env assignment can miss the \`Shell(workit)\` allowlist). A verifier uses its own id, never this one.</workit-session>`
       : null,
 };

package/src/hooks/raw-git.ts

@@ -1623,10 +1623,10 @@ const nudgeFor = (action: RawAction, host: HookInput["host"], session: string):
   switch (action.kind) {
     case "commit": {
       // Cursor's shell carries no conversation id: name it explicitly.
-      const prefix = host === "cursor" && session ? `WORKIT_SESSION_ID=${session} ` : "";
+      const workit = host === "cursor" && session ? `workit --session ${session}` : "workit";
       return action.amend
-        ? `workit: raw ${quote("git commit --amend")} is recorded for this session; for new commits prefer ${quote(`${prefix}workit git commit -m '<msg>'`)} (adds the Workit-Session trailer and checks branch and commit policy).`
-        : `workit: prefer ${quote(`${prefix}workit git commit -m '<msg>' [--all | -- <paths>]`)}: it adds the Workit-Session trailer and checks branch and commit policy.`;
+        ? `workit: raw ${quote("git commit --amend")} is recorded for this session; for new commits prefer ${quote(`${workit} git commit -m '<msg>'`)} (adds the Workit-Session trailer and checks branch and commit policy).`
+        : `workit: prefer ${quote(`${workit} git commit -m '<msg>' [--all | -- <paths>]`)}: it adds the Workit-Session trailer and checks branch and commit policy.`;
     }
     case "push":
       return action.blindForce

package/src/hooks/session-marker.ts

@@ -42,9 +42,19 @@ export const sessionMarkerFile = (
 const list = (value: unknown): string[] =>
   Array.isArray(value) ? value.filter((item): item is string => typeof item === "string") : [];
 
-export const readSessionMarker = (file: string): SessionMarker => {
+const EMPTY: SessionMarker = { nudged: [], loaded: [], raw: [], stops: [], judges: [] };
+
+const readRaw = (file: string): string => {
+  try {
+    return fs.readFileSync(file, "utf8");
+  } catch {
+    return "";
+  }
+};
+
+const parseMarker = (text: string): SessionMarker => {
   try {
-    const value = JSON.parse(fs.readFileSync(file, "utf8")) as Record<string, unknown>;
+    const value = JSON.parse(text) as Record<string, unknown>;
     return {
       nudged: list(value.nudged),
       loaded: list(value.loaded),
@@ -53,14 +63,51 @@ export const readSessionMarker = (file: string): SessionMarker => {
       judges: list(value.judges),
     };
   } catch {
-    return { nudged: [], loaded: [], raw: [], stops: [], judges: [] };
+    return { ...EMPTY };
+  }
+};
+
+export const readSessionMarker = (file: string): SessionMarker => parseMarker(readRaw(file));
+
+/** Write through a temp file in the same directory and rename: a reader never sees half a marker. */
+const writeAtomic = (file: string, marker: SessionMarker): void => {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  const temp = `${file}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
+  try {
+    fs.writeFileSync(temp, JSON.stringify(marker));
+    fs.renameSync(temp, file);
+  } catch (error) {
+    fs.rmSync(temp, { force: true });
+    throw error;
   }
 };
 
 export const writeSessionMarker = (file: string, marker: SessionMarker): void => {
   try {
-    fs.mkdirSync(path.dirname(file), { recursive: true });
-    fs.writeFileSync(file, JSON.stringify(marker));
+    writeAtomic(file, marker);
+  } catch {
+    // Fail open: without a marker a later nudge repeats.
+  }
+};
+
+/**
+ * Read-modify-write: `change` maps the marker as read to the marker to keep.
+ * Another hook's rename between the read and ours is detected (the file's
+ * text changed) and `change` runs once more on the fresh marker, so an entry
+ * of a concurrent hook is not lost. Fails open like the rest.
+ */
+export const updateSessionMarker = (
+  file: string,
+  change: (marker: SessionMarker) => SessionMarker,
+): void => {
+  try {
+    for (let attempt = 0; attempt < 2; attempt++) {
+      const before = readRaw(file);
+      const next = change(parseMarker(before));
+      if (attempt === 0 && readRaw(file) !== before) continue;
+      writeAtomic(file, next);
+      return;
+    }
   } catch {
     // Fail open: without a marker a later nudge repeats.
   }
@@ -71,7 +118,8 @@ export const trackJudge = (input: HookInput, agentId: string | null, running: bo
   const session = input.session.id;
   const file = session && agentId ? sessionMarkerFile(input, session) : null;
   if (!file || !agentId) return;
-  const marker = readSessionMarker(file);
-  const rest = marker.judges.filter((id) => id !== agentId);
-  writeSessionMarker(file, { ...marker, judges: running ? [...rest, agentId] : rest });
+  updateSessionMarker(file, (marker) => {
+    const rest = marker.judges.filter((id) => id !== agentId);
+    return { ...marker, judges: running ? [...rest, agentId] : rest };
+  });
 };

package/src/hooks/stop.ts

@@ -14,7 +14,8 @@
 //       green or merged (a PR opens without one): the author's own `--self`
 //       verdict at normal risk under `verification: self`, an accepted
 //       non-author verdict at high risk or under `verification: independent`.
-//       Not raised while a verifier or reviewer this lead started still runs.
+//       Not raised when the task's latest judgment records no behavior
+//       change at normal risk (policy/derive.ts asks for none either), nor while a verifier or reviewer this lead started still runs.
 // Each obligation blocks once per head and session (a marker keyed by kind
 // and head), not once per turn.
 // A branch that landed owes nothing: a recorded merge (`workit pr merge`, or
@@ -30,13 +31,14 @@
 import { spawnSync } from "node:child_process";
 import { resolveAutonomy } from "../autonomy";
 import { latestJudgment } from "../core/policy/derive";
+import type { Judgment } from "../core/task-contract";
 import { TaskStore } from "../core/task-store";
 import { currentBranch, pushRemoteName } from "../git/rev";
 import { checkVerdicts, readLedger, type ReadRow } from "../ledger";
 import type { HostDescriptor } from "./descriptor";
 import type { HookDecision, HookInput } from "./protocol";
 import { guardedBranch, inWorkitWorkspace } from "./raw-git";
-import { readSessionMarker, sessionMarkerFile, writeSessionMarker } from "./session-marker";
+import { readSessionMarker, sessionMarkerFile, updateSessionMarker } from "./session-marker";
 
 const NONE: HookDecision = { kind: "none" };
 
@@ -235,20 +237,20 @@ const redChecks = (
   };
 };
 
-/** Did the open task's latest judgment call this change high risk? */
-const highRisk = (cwd: string): boolean => {
+/** The open task's latest judgment (the one policy/derive.ts reads), or null when none is recorded. */
+const taskJudgment = (cwd: string): Judgment | null => {
   try {
     const store = new TaskStore(cwd);
     const listed = store.listTaskIndex();
     const key = store.currentKey();
-    if (!listed.ok || !key.ok) return false;
+    if (!listed.ok || !key.ok) return null;
     const entry = listed.data
       .filter((item) => item.key === key.data.key && item.status !== "closed")
       .toSorted((left, right) => right.updatedAt.localeCompare(left.updatedAt))[0];
     const task = entry ? store.readTask(entry.id) : null;
-    return task?.ok === true && latestJudgment(task.data)?.riskTier === "high";
+    return task?.ok === true ? latestJudgment(task.data) : null;
   } catch {
-    return false;
+    return null;
   }
 };
 
@@ -266,7 +268,12 @@ const unverified = (
 ): StopObligation | null => {
   const check = checkVerdicts(cwd, branch, all);
   if (check.accepted.accepted || check.accepted.reasons.includes("failing_verdict")) return null;
-  const independent = verification === "independent" || highRisk(cwd);
+  const judgment = taskJudgment(cwd);
+  const high = judgment?.riskTier === "high";
+  // Like policy/derive.ts: a verdict is asked for a behavior change or high
+  // risk. A recorded judgment with neither (docs only) owes none.
+  if (judgment && !judgment.behaviorChange && !high) return null;
+  const independent = verification === "independent" || high;
   if (!independent && check.review === "self-reviewed") return null;
   const has = check.review === "self-reviewed" ? "only a self verdict" : "no current verdict";
   const verifier = `${descriptor.subagents.agentPrefix}verifier`;
@@ -353,7 +360,7 @@ export function stopDecision(input: HookInput, descriptor: HostDescriptor): Hook
   const key = `${left.kind}:${left.head ?? ""}`;
   if (file && marker) {
     if (marker.stops.includes(key)) return NONE;
-    writeSessionMarker(file, { ...marker, stops: [...marker.stops, key] });
+    updateSessionMarker(file, (fresh) => ({ ...fresh, stops: [...fresh.stops, key] }));
   }
   return {
     kind: "continue",