@brainervirus/workit-core 8.32.0 → 8.34.0

package/package.json

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

package/src/core/operation-input.ts

@@ -567,10 +567,16 @@ function invalidOperation(
   const request = isObject(input) ? input : {};
   const action = typeof request.action === "string" ? request.action : "";
   const actions = OPERATION_ACTIONS[family];
-  if (!actions.includes(action))
-    return failure("invalid_input", `${family}: action must be one of ${oneOf(actions)}`, {
-      fields: [{ path: "action", reason: `got ${JSON.stringify(request.action ?? null)}` }],
-    });
+  if (!actions.includes(action)) {
+    // The family's read (list, else the first action) is the safe corrected call.
+    const common = actions.find((name) => READ_ONLY_ACTIONS.has(name)) ?? actions[0];
+    const example = JSON.stringify(exampleOperation(family, common));
+    return failure(
+      "invalid_input",
+      `${family}: action must be one of ${oneOf(actions)}. Example: ${example}`,
+      { fields: [{ path: "action", reason: `got ${JSON.stringify(request.action ?? null)}` }] },
+    );
+  }
   const own = actionKeys(family, action)!;
   const fields: { path: string; reason: string }[] = [];
   const sentence: string[] = [];

package/src/hooks/handle.ts

@@ -30,7 +30,8 @@ import {
 } from "./skill-nudge";
 import { spawnDecision } from "./spawn-gate";
 import { seedStanding, standingDelta } from "./standing";
-import { trackJudge } from "./session-marker";
+import { modelSwitchedOnDisk, trackJudge } from "./session-marker";
+import { invariantBootstrap } from "../core/methods";
 import { stopDecision } from "./stop";
 import { liveOwner } from "../core/live-session";
 import { liveTargets, shellGate, writeGate } from "./write-gate";
@@ -166,7 +167,12 @@ function decide(input: HookInput, deps: HookDeps): HookDecision {
     case "context.turn": {
       if (!usable(descriptor.context.perTurn)) return NONE;
       const current = turnContextText(input, descriptor);
-      const text = resendsOnChange(descriptor) ? changedTurnContext(input, current) : current;
+      const turn = resendsOnChange(descriptor) ? changedTurnContext(input, current) : current;
+      // A model switch (#435): the compact contract again, once.
+      const text =
+        input.model && modelSwitchedOnDisk(input)
+          ? [invariantBootstrap(), turn].filter(Boolean).join("\n")
+          : turn;
       return withContextLine(
         text ? { kind: "context", text } : NONE,
         promptNudge(input, event.prompt),

package/src/hooks/hook-runs.ts

@@ -0,0 +1,96 @@
+// A tiny record of which hook events each host ran (#433): without it "zero
+// hook events" cannot tell a host that never fires its hooks from one that
+// fires them silently. One small file per host and native event in the state
+// dir (`hook-runs/<host>__<event>.json`: last seen time and a count), written
+// best effort: one read and one atomic-enough write, no spawn, and a
+// read-only state dir never changes the hook's answer. `workit doctor`
+// (`hook_runs`) reads it. Light imports only: the Codex launcher's quiet path
+// calls it before the runtime loads.
+import { mkdirSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { stateDir } from "../core/heavy-words";
+
+export const HOOK_RUNS_DIR = "hook-runs";
+
+export type HookRun = {
+  host: string;
+  event: string;
+  at: string;
+  count: number;
+};
+
+const safe = (part: string): string => part.replace(/[^A-Za-z0-9_.-]/g, "-").slice(0, 64);
+
+const runFile = (dir: string, host: string, event: string): string =>
+  path.join(dir, HOOK_RUNS_DIR, `${safe(host)}__${safe(event)}.json`);
+
+/** Counts one run of the native `event` on `host`; never throws. */
+export const recordHookRun = (
+  host: string,
+  event: string | null | undefined,
+  env: NodeJS.ProcessEnv = process.env,
+  now: () => number = Date.now,
+): void => {
+  if (!event) return;
+  try {
+    const dir = stateDir(env);
+    const file = runFile(dir, host, event);
+    let count = 0;
+    try {
+      const previous = JSON.parse(readFileSync(file, "utf8")) as {
+        count?: unknown;
+      };
+      if (typeof previous.count === "number" && Number.isFinite(previous.count))
+        count = previous.count;
+    } catch {
+      // First run, or a torn file: start again.
+    }
+    const row: HookRun = {
+      host,
+      event,
+      at: new Date(now()).toISOString(),
+      count: count + 1,
+    };
+    try {
+      writeFileSync(file, JSON.stringify(row));
+    } catch {
+      mkdirSync(path.dirname(file), { recursive: true });
+      writeFileSync(file, JSON.stringify(row));
+    }
+  } catch {
+    // The hook still answers the host; only the doctor line is lost.
+  }
+};
+
+/** Every recorded run under `stateDir`; unreadable or malformed files are skipped. */
+export const readHookRuns = (dir: string): HookRun[] => {
+  const runs: HookRun[] = [];
+  let names: string[] = [];
+  try {
+    names = readdirSync(path.join(dir, HOOK_RUNS_DIR));
+  } catch {
+    return runs;
+  }
+  for (const name of names) {
+    try {
+      const row = JSON.parse(
+        readFileSync(path.join(dir, HOOK_RUNS_DIR, name), "utf8"),
+      ) as Partial<HookRun>;
+      if (
+        typeof row.host === "string" &&
+        typeof row.event === "string" &&
+        typeof row.at === "string" &&
+        typeof row.count === "number"
+      )
+        runs.push({
+          host: row.host,
+          event: row.event,
+          at: row.at,
+          count: row.count,
+        });
+    } catch {
+      // Not a run record.
+    }
+  }
+  return runs;
+};

package/src/hooks/hosts/codex.ts

@@ -361,6 +361,7 @@ export const codexAdapter: HostAdapter = {
         },
         permissionMode: input.permission_mode,
         transcriptPath: input.transcript_path,
+        model: input.model,
         event: protocolEvent(input),
       },
     };

package/src/hooks/protocol.ts

@@ -90,6 +90,8 @@ export type HookInput = {
   session: Session;
   permissionMode: string | null;
   transcriptPath: string | null;
+  /** The host's current model, where every hook input carries it (Codex). */
+  model?: string | null;
   event: HookEvent;
 };
 

package/src/hooks/run.ts

@@ -11,6 +11,7 @@ import {
 import { claudeCodeAdapter } from "./hosts/claude-code";
 import { codexAdapter } from "./hosts/codex";
 import { cursorAdapter } from "./hosts/cursor";
+import { recordHookRun } from "./hook-runs";
 import type { HostAdapter, HostId } from "./protocol";
 
 type ProcessHost = Exclude<HostId, "opencode" | "pi">;
@@ -44,6 +45,12 @@ export async function runHookProcess(
   } catch {
     raw = undefined;
   }
+  const native = (raw as { hook_event_name?: unknown } | null | undefined)?.hook_event_name;
+  recordHookRun(
+    typeof host === "string" ? host : adapter.descriptor.host,
+    typeof native === "string" ? native : null,
+    env,
+  );
   const result =
     text === null
       ? skippedHook(adapter, undefined, env, budget, "input")

package/src/hooks/session-marker.ts

@@ -17,6 +17,8 @@ export type SessionMarker = {
   stops: string[];
   /** Verifier and reviewer subagents of this lead that started and have not stopped. */
   judges: string[];
+  /** The last model the session reported (Codex #435): a change re-sends the contract. */
+  model: string | null;
 };
 
 /**
@@ -42,7 +44,14 @@ export const sessionMarkerFile = (
 const list = (value: unknown): string[] =>
   Array.isArray(value) ? value.filter((item): item is string => typeof item === "string") : [];
 
-const EMPTY: SessionMarker = { nudged: [], loaded: [], raw: [], stops: [], judges: [] };
+const EMPTY: SessionMarker = {
+  nudged: [],
+  loaded: [],
+  raw: [],
+  stops: [],
+  judges: [],
+  model: null,
+};
 
 const readRaw = (file: string): string => {
   try {
@@ -61,6 +70,7 @@ const parseMarker = (text: string): SessionMarker => {
       raw: list(value.raw),
       stops: list(value.stops),
       judges: list(value.judges),
+      model: typeof value.model === "string" ? value.model : null,
     };
   } catch {
     return { ...EMPTY };
@@ -123,3 +133,19 @@ export const trackJudge = (input: HookInput, agentId: string | null, running: bo
     return { ...marker, judges: running ? [...rest, agentId] : rest };
   });
 };
+
+/**
+ * Record the session's model and say whether it differs from the last one
+ * recorded (the hook is a fresh process each time). The first model is a
+ * start, not a switch. Fails open: no store or no model reads as no switch.
+ */
+export const modelSwitchedOnDisk = (input: HookInput): boolean => {
+  const session = input.session.id;
+  const model = input.model;
+  const file = session && model ? sessionMarkerFile(input, session) : null;
+  if (!file || !model) return false;
+  const previous = readSessionMarker(file).model;
+  if (previous === model) return false;
+  updateSessionMarker(file, (marker) => ({ ...marker, model }));
+  return previous !== null;
+};