@brainervirus/workit-cursor 8.28.0 → 8.29.0

package/.cursor-plugin/plugin.json

@@ -2,7 +2,7 @@
   "name": "workit",
   "displayName": "Workit",
   "description": "Adaptive Workit workflow with shared MCP tools and native Cursor hooks",
-  "version": "8.28.0",
+  "version": "8.29.0",
   "author": {
     "name": "Cristhofer Pincetti"
   },

package/dist/cursor-session-start.js

@@ -9739,11 +9739,15 @@ var withReleaseTracks = (workspaceRoot, policy) => {
     source,
     fingerprint
   };
+}, rethrowRuntimeBug = (error) => {
+  if (error instanceof TypeError || error instanceof ReferenceError)
+    throw error;
 }, validateBranchNameFor = (workspaceRoot, name) => {
   try {
     const resolved = branchPolicySnapshotFor(workspaceRoot);
     return validateBranchNamePolicy(name, resolved.namePolicy, resolved.source);
   } catch (error) {
+    rethrowRuntimeBug(error);
     const correction = "repair or select a valid workspace policy before creating a branch";
     return {
       ok: false,
@@ -11523,7 +11527,7 @@ var str2 = (d, values) => ({
   description: typeof description === "string" ? description : "",
   paths: ["."],
   exclusions: []
-}), LISTS, ENVELOPE;
+}), LISTS, ENVELOPE, NOT_FLAT;
 var init_operation_input = __esm(() => {
   init_task_contract();
   scopeFields = {
@@ -11645,6 +11649,7 @@ var init_operation_input = __esm(() => {
     "expectedWorkspaceRevision",
     "judgment"
   ]);
+  NOT_FLAT = new Set(["schemaVersion", "action", "workspaceId"]);
 });
 
 // packages/workit-core/src/core/policy/judgment.ts
@@ -14806,9 +14811,22 @@ function detectedChecks(root) {
     add(plain("test", ["make", "test"]));
   return checks;
 }
+function configFileFor(root) {
+  const own = checksConfigFile(root);
+  if (fs13.existsSync(own))
+    return own;
+  const common = git4(root, ["rev-parse", "--path-format=absolute", "--git-common-dir"]);
+  if (!common || path18.basename(common) !== ".git")
+    return own;
+  const main = path18.dirname(common);
+  if (path18.resolve(main) === path18.resolve(root))
+    return own;
+  const shared = checksConfigFile(main);
+  return fs13.existsSync(shared) ? shared : own;
+}
 function loadCheckConfig(cwd) {
   const root = checkRoot(cwd);
-  const file = checksConfigFile(root);
+  const file = configFileFor(root);
   const legacy = path18.basename(file) === LEGACY_CHECKS_FILE;
   const label = legacy ? LEGACY_CHECKS_FILE : CHECKS_FILE;
   const note = legacy ? {

package/dist/mcp-server.js

@@ -15951,8 +15951,9 @@ function flatOperationJsonSchema(family, options = {}) {
   };
   const properties = { action: { type: "string", enum: actions } };
   const readField = (name) => name === "taskId" || (family === "task" ? READ_TASK_FIELDS.has(name) : family === "policy");
+  const taken = (name) => family === "policy" || actions.some((action) => actionKeys(family, action)?.accepted.has(name));
   for (const [name, field] of Object.entries({ ...COMMON, ...spec.fields }))
-    if (options.readOnly ? readField(name) : !(family === "state" && name === "expectedRevision"))
+    if (options.readOnly ? readField(name) : taken(name))
       properties[name] = property(field);
   return {
     $schema: "https://json-schema.org/draft/2020-12/schema",
@@ -16194,6 +16195,98 @@ function normalizeOperationInput(family, input, host) {
       request[key] = strings(request[key]);
   return request;
 }
+var defOf = (node) => node._zod.def;
+var unwrap = (node) => {
+  let inner = node;
+  while (["optional", "nullable"].includes(defOf(inner).type) && defOf(inner).innerType)
+    inner = defOf(inner).innerType;
+  return inner;
+};
+var FLAT_NAME = {
+  authorityRefs: "refs",
+  contentRefs: "refs",
+  statedChoice: "choice",
+  reviewContext: "reviewSession"
+};
+var NOT_FLAT = new Set(["schemaVersion", "action", "workspaceId"]);
+function actionKeys(family, action) {
+  const options = advertisedOperationSchemas[family].options;
+  const option = options.find((item) => {
+    const literal = defOf(item).shape?.action;
+    return literal._zod.def.values.includes(action);
+  });
+  if (!option)
+    return null;
+  const out = { accepted: new Set, required: [] };
+  const walk = (shape, nested) => {
+    for (const [key, node] of Object.entries(shape)) {
+      if (NOT_FLAT.has(key) || nested && key === "taskId")
+        continue;
+      const inner = unwrap(node);
+      const type = defOf(inner).type;
+      const needed = !["optional", "nullable"].includes(defOf(node).type);
+      if (key === "scope")
+        for (const name of ["scope", "paths", "exclusions"])
+          out.accepted.add(name);
+      else if (type === "object" && key !== "bundle" && !(key in FLAT_NAME)) {
+        out.accepted.add(key);
+        walk(defOf(inner).shape, true);
+      } else {
+        const name = FLAT_NAME[key] ?? key;
+        out.accepted.add(name);
+        if (needed && type !== "array" && type !== "record" && !out.required.includes(name))
+          out.required.push(name);
+      }
+    }
+  };
+  walk(defOf(option).shape, false);
+  return out;
+}
+function exampleOperation(family, action) {
+  const keys = actionKeys(family, action);
+  const example = { action };
+  for (const name of keys?.required ?? [])
+    example[name] = FLAT[family].fields[name]?.enum?.[0] ?? `<${name}>`;
+  if (family === "policy" && !keys?.required.length && action !== "explain")
+    example.riskTier = "normal";
+  return example;
+}
+var oneOf = (values) => values.join(" | ");
+function invalidOperation(family, input, error) {
+  const request = isObject2(input) ? input : {};
+  const action = typeof request.action === "string" ? request.action : "";
+  const actions = OPERATION_ACTIONS[family];
+  if (!actions.includes(action))
+    return failure2("invalid_input", `${family}: action must be one of ${oneOf(actions)}`, {
+      fields: [{ path: "action", reason: `got ${JSON.stringify(request.action ?? null)}` }]
+    });
+  const own = actionKeys(family, action);
+  const fields = [];
+  const sentence = [];
+  for (const issue of error.issues) {
+    if (issue.code === "unrecognized_keys") {
+      for (const key of issue.keys) {
+        const home = actions.find((other) => other !== action && actionKeys(family, other).accepted.has(key));
+        const reason = home ? `${key} belongs to action: ${home}` : `${key} is not a field of ${family} ${action}; it takes ${[...own.accepted].join(", ")}`;
+        fields.push({ path: key, reason });
+        sentence.push(reason);
+      }
+      continue;
+    }
+    const last = String(issue.path.at(-1) ?? "");
+    const name = Object.entries(FLAT_NAME).find(([contract]) => contract === last)?.[1] ?? last;
+    const missing = issue.code === "invalid_type" && /received undefined/.test(issue.message);
+    const absent = own.required.filter((key) => !(key in request));
+    const needs = missing && issue.path.length === 1 && absent.length ? absent.join(", ") : name;
+    const reason = missing ? `${family} ${action} requires ${needs}` : `${name}: ${issue.message}`;
+    fields.push({ path: issue.path.join("."), reason });
+    sentence.push(reason);
+  }
+  const example = JSON.stringify(exampleOperation(family, action));
+  return failure2("invalid_input", `${[...new Set(sentence)].join("; ")}. Example: ${example}`, {
+    fields
+  });
+}
 function parseAdvertisedOperation(family, input, host) {
   const request = normalizeOperationInput(family, input, host);
   if (isObject2(request) && request.schemaVersion !== SCHEMA_VERSION)
@@ -16201,12 +16294,7 @@ function parseAdvertisedOperation(family, input, host) {
   const parsed = advertisedOperationSchemas[family].safeParse(request);
   if (parsed.success)
     return success(null, null, request);
-  return failure2("invalid_input", "operation input is invalid", {
-    fields: parsed.error.issues.map((issue) => ({
-      path: issue.code === "unrecognized_keys" ? issue.keys.join(".") : issue.path.join("."),
-      reason: issue.message
-    }))
-  });
+  return invalidOperation(family, request, parsed.error);
 }
 // packages/workit-core/src/core/task-store.ts
 import { createHash as createHash8, randomUUID as randomUUID3 } from "node:crypto";
@@ -21557,9 +21645,22 @@ function detectedChecks(root) {
   return checks;
 }
 var GATES = ["testing", "verification"];
+function configFileFor(root) {
+  const own = checksConfigFile(root);
+  if (fs11.existsSync(own))
+    return own;
+  const common = git3(root, ["rev-parse", "--path-format=absolute", "--git-common-dir"]);
+  if (!common || path13.basename(common) !== ".git")
+    return own;
+  const main = path13.dirname(common);
+  if (path13.resolve(main) === path13.resolve(root))
+    return own;
+  const shared = checksConfigFile(main);
+  return fs11.existsSync(shared) ? shared : own;
+}
 function loadCheckConfig(cwd) {
   const root = checkRoot(cwd);
-  const file = checksConfigFile(root);
+  const file = configFileFor(root);
   const legacy = path13.basename(file) === LEGACY_CHECKS_FILE;
   const label = legacy ? LEGACY_CHECKS_FILE : CHECKS_FILE;
   const note = legacy ? {

package/dist/workit-hook.js

@@ -9728,11 +9728,16 @@ var branchPolicySnapshotFor = (workspaceRoot) => {
     fingerprint
   };
 };
+var rethrowRuntimeBug = (error) => {
+  if (error instanceof TypeError || error instanceof ReferenceError)
+    throw error;
+};
 var validateBranchNameFor = (workspaceRoot, name) => {
   try {
     const resolved = branchPolicySnapshotFor(workspaceRoot);
     return validateBranchNamePolicy(name, resolved.namePolicy, resolved.source);
   } catch (error) {
+    rethrowRuntimeBug(error);
     const correction = "repair or select a valid workspace policy before creating a branch";
     return {
       ok: false,
@@ -11636,6 +11641,7 @@ function normalizeOperationInput(family, input, host) {
       request[key] = strings(request[key]);
   return request;
 }
+var NOT_FLAT = new Set(["schemaVersion", "action", "workspaceId"]);
 
 // packages/workit-core/src/core/policy/judgment.ts
 var isObject3 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
@@ -14847,9 +14853,22 @@ function detectedChecks(root) {
   return checks;
 }
 var GATES = ["testing", "verification"];
+function configFileFor(root) {
+  const own = checksConfigFile(root);
+  if (fs13.existsSync(own))
+    return own;
+  const common = git4(root, ["rev-parse", "--path-format=absolute", "--git-common-dir"]);
+  if (!common || path18.basename(common) !== ".git")
+    return own;
+  const main = path18.dirname(common);
+  if (path18.resolve(main) === path18.resolve(root))
+    return own;
+  const shared = checksConfigFile(main);
+  return fs13.existsSync(shared) ? shared : own;
+}
 function loadCheckConfig(cwd) {
   const root = checkRoot(cwd);
-  const file = checksConfigFile(root);
+  const file = configFileFor(root);
   const legacy = path18.basename(file) === LEGACY_CHECKS_FILE;
   const label = legacy ? LEGACY_CHECKS_FILE : CHECKS_FILE;
   const note = legacy ? {

package/hooks/launch.mjs

@@ -15,6 +15,7 @@
 // failure, npx network error, timeout, a crash) prints `{}`, exits 0 and
 // writes one `[workit] Cursor hook unavailable: …` line on stderr. Only a
 // policy deny from the hook itself (exit 2 with Cursor's deny JSON) blocks.
+import { readFileSync } from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import {
@@ -25,6 +26,35 @@ import {
 
 const pluginRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
 
+// A Node below this package's own engines minimum cannot run the bundled hook:
+// fail open with one clear line. WORKIT_HOOK_NODE_VERSION stands in for
+// process.versions.node (tests). An unreadable minimum never blocks.
+const nodeFloorMessage = () => {
+  try {
+    const found = process.env.WORKIT_HOOK_NODE_VERSION || process.versions.node;
+    const range = JSON.parse(readFileSync(path.join(pluginRoot, "package.json"), "utf8")).engines
+      ?.node;
+    const min = /^>=\s*(\d+)(?:\.(\d+))?(?:\.(\d+))?/.exec(String(range ?? ""));
+    if (!min) return null;
+    const need = [min[1], min[2] ?? 0, min[3] ?? 0].map(Number);
+    const have = String(found).replace(/^v/, "").split(".").map(Number);
+    for (let i = 0; i < 3; i++) {
+      const a = have[i] ?? 0;
+      if (Number.isNaN(a)) return null;
+      if (a !== need[i]) return a < need[i] ? `needs Node ${range}, found ${found}` : null;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+};
+const tooOld = nodeFloorMessage();
+if (tooOld && process.argv[2] !== "--probe") {
+  process.stderr.write(`[workit] Cursor hook unavailable: ${tooOld}\n`);
+  process.stdout.write("{}\n");
+  process.exit(0);
+}
+
 // `--probe <bin>` (for `workit doctor`): run one no-op preCompact through
 // the candidate Cursor would use and print which one it was and how it went.
 if (process.argv[2] === "--probe") {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brainervirus/workit-cursor",
-  "version": "8.28.0",
+  "version": "8.29.0",
   "private": false,
   "description": "Workit Cursor plugin — shared MCP transport, native hooks, and sixteen method skills",
   "keywords": [
@@ -46,8 +46,8 @@
     "build": "bun scripts/build.ts"
   },
   "devDependencies": {
-    "@brainervirus/workit-core": "^8.28.0",
-    "@brainervirus/workit-mcp": "^8.28.0"
+    "@brainervirus/workit-core": "^8.29.0",
+    "@brainervirus/workit-mcp": "^8.29.0"
   },
   "engines": {
     "node": ">=24"