@brainervirus/workit-core 8.12.0 → 8.12.2

package/package.json

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

package/src/autonomy.ts

@@ -14,7 +14,7 @@
 //   a process that drives a pseudo-terminal or edits the file directly can
 //   still defeat it; the host's permission prompt is the hard boundary.
 // - `release` gates `workit git push --release`: pushing the git-flow
-//   production and develop branches (fast-forward only) and `v*` tags whose
+//   production and develop branches (fast-forward only) and release tags (`v*` or git-flow's prefix) whose
 //   commit already landed (a tag never moves). Outside git-flow it pushes
 //   tags only. It needs `push` too.
 // - Defaults (D4) when a kind is absent: push, pr and rerun are allowed;

package/src/git/ops.ts

@@ -1138,12 +1138,22 @@ export type ReleasePushPlan = Omit<PushPlan, "branch" | "sha"> & {
   production: string | null;
 };
 
-/** A release tag: `v` and a digit (`v4.1.0`, `v2`). */
-const RELEASE_TAG = /^v\d/u;
+/**
+ * The release tag prefix: git-flow's own `gitflow.prefix.versiontag` when the
+ * repository sets it (an empty value means bare `4.1.0` tags), else `v`.
+ */
+const releaseTagPrefix = (cwd: string): string => {
+  const configured = git(cwd, ["config", "--get", "gitflow.prefix.versiontag"]);
+  return configured.ok ? configured.stdout.trim() : "v";
+};
+
+/** A release tag: the prefix and a digit (`v4.1.0`, `v2`, or `4.1.0` with an empty prefix). */
+const isReleaseTag = (name: string, prefix: string): boolean =>
+  name.startsWith(prefix) && /^\d/u.test(name.slice(prefix.length));
 
 /**
  * What `workit git push --release` may push: the git-flow production and
- * develop branches and `v*` tags, nothing else, each by its local ref. Everything else stays on the feature-branch
+ * develop branches and release tags (`v*`, or git-flow's configured prefix), nothing else, each by its local ref. Everything else stays on the feature-branch
  * path (`workit git push`, `workit pr create`).
  */
 export function releasePushPreflight(
@@ -1172,11 +1182,12 @@ export function releasePushPreflight(
         `workit git push --release refs/heads/${raw}  # or refs/tags/${raw}`,
       );
     if (tag) {
-      if (!RELEASE_TAG.test(tagName))
+      const prefix = releaseTagPrefix(cwd);
+      if (!isReleaseTag(tagName, prefix))
         return failure(
           "blocked",
-          `release_push_refused: tag ${tagName} is not a release tag (v<version>)`,
-          "git tag -a v<version> -m <message>  # then: workit git push --release v<version>",
+          `release_push_refused: tag ${tagName} is not a release tag (${prefix}<version>, from ${prefix === "v" ? "the default" : "gitflow.prefix.versiontag"})`,
+          `git tag -a ${prefix}<version> -m <message>  # then: workit git push --release ${prefix}<version>`,
         );
       refs.push({ kind: "tag", name: tagName, ref: `refs/tags/${tagName}`, sha: tag });
       continue;

package/src/host-session.ts

@@ -10,6 +10,7 @@
 import { createHash } from "node:crypto";
 import fs from "node:fs";
 import path from "node:path";
+import { resolveStateDir } from "./core/logger";
 import { resolveStore } from "./store/paths";
 
 export type HostSession = { host: string | null; session: string | null };
@@ -80,36 +81,84 @@ export function realHostSession(env: NodeJS.ProcessEnv): RealSession {
 }
 
 // Ids a SubagentStart hook gave a lead's subagents (`<lead>:<agent id>`): one
-// empty file per id under `<store>/hooks/issued/<lead hash>/`, so concurrent
+// empty file per id under `<state>/issued/<lead hash>/`, so concurrent
 // hooks never lose each other's write, bounded per lead.
 const ISSUED_PER_LEAD = 64;
 
 /**
  * Written into each issued-id file. A hook bundle that contains this string
- * records issued ids; `workit doctor` looks for it in the installed Claude
+ * records issued ids per lead in the user's state dir (`/2`; `/1` hooks of
+ * 8.10-8.12 wrote them per repository, which breaks cross-repo verdicts); `workit doctor` looks for it in the installed Claude
  * Code and Codex hooks to catch a plugin older than the CLI.
  */
-export const ISSUED_SESSIONS_MARKER = "workit-issued-sessions/1";
+export const ISSUED_SESSIONS_MARKER = "workit-issued-sessions/2";
 
 const hash = (value: string): string =>
   createHash("sha256").update(value).digest("hex").slice(0, 32);
 
-const issuedRoot = (cwd: string): string | null => {
-  const location = resolveStore(cwd);
-  return location instanceof Error ? null : path.join(location.dir, "hooks", "issued");
+// Issued ids live in the per-user state dir, keyed by lead session: a lead
+// started in one repository delegates review of others, and the verifier
+// records its verdict from whichever repository it reviews (#294).
+const userIssuedRoot = (): string => path.join(resolveStateDir(), "issued");
+
+/**
+ * Hooks of 8.10-8.12 wrote issued ids into `<store>/hooks/issued` of the
+ * lead's repository. Move them into the per-user registry file by file
+ * (copy, then unlink: an id an old hook writes meanwhile stays for the next
+ * read) and drop the emptied directories. Each lead migrates on its own, so
+ * one bad entry never strands the rest. Fails open.
+ */
+function migrateRepoIssued(cwd: string | undefined): void {
+  if (cwd === undefined) return;
+  let old: string;
+  try {
+    const location = resolveStore(cwd);
+    if (location instanceof Error) return;
+    old = path.join(location.dir, "hooks", "issued");
+    if (!fs.existsSync(old)) return;
+  } catch {
+    return;
+  }
+  for (const lead of safeList(old)) {
+    try {
+      const from = path.join(old, lead);
+      if (!fs.statSync(from).isDirectory()) continue;
+      const to = path.join(userIssuedRoot(), lead);
+      fs.mkdirSync(to, { recursive: true, mode: 0o700 });
+      for (const id of fs.readdirSync(from)) {
+        fs.copyFileSync(path.join(from, id), path.join(to, id));
+        fs.rmSync(path.join(from, id), { force: true });
+      }
+      removeIfEmpty(from);
+    } catch {
+      // Fail open: this lead's ids stay for the next read.
+    }
+  }
+  removeIfEmpty(old);
+}
+
+const safeList = (dir: string): string[] => {
+  try {
+    return fs.readdirSync(dir);
+  } catch {
+    return [];
+  }
 };
 
-const issuedDir = (cwd: string, lead: string): string | null => {
-  const root = issuedRoot(cwd);
-  return root === null ? null : path.join(root, hash(lead));
+const removeIfEmpty = (dir: string): void => {
+  try {
+    fs.rmdirSync(dir);
+  } catch {
+    // Not empty (a concurrent old hook wrote) or already gone.
+  }
 };
 
-/** No hook in this workspace has ever recorded an issued id (an older plugin hook, most likely). */
-const noIssuedRecord = (cwd: string | undefined): boolean => {
+/** This lead's hooks never recorded an issued id (an older plugin hook, most likely). */
+const noIssuedRecord = (cwd: string | undefined, lead: string): boolean => {
   if (cwd === undefined) return false;
   try {
-    const root = issuedRoot(cwd);
-    return root !== null && !fs.existsSync(root);
+    migrateRepoIssued(cwd);
+    return !fs.existsSync(path.join(userIssuedRoot(), hash(lead)));
   } catch {
     return false;
   }
@@ -124,9 +173,9 @@ const PLUGIN_UPDATE: Readonly<Record<string, string>> = {
 /** Remember that a SubagentStart hook issued `issued` to a subagent of `lead`. Fails open. */
 export function recordIssuedSession(cwd: string, lead: string, issued: string): void {
   try {
-    const dir = issuedDir(cwd, lead);
-    if (!dir) return;
-    fs.mkdirSync(dir, { recursive: true });
+    migrateRepoIssued(cwd);
+    const dir = path.join(userIssuedRoot(), hash(lead));
+    fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
     const own = hash(issued);
     fs.writeFileSync(path.join(dir, own), ISSUED_SESSIONS_MARKER);
     const entries = fs.readdirSync(dir);
@@ -144,10 +193,9 @@ export function recordIssuedSession(cwd: string, lead: string, issued: string):
 }
 
 const wasIssued = (cwd: string | undefined, lead: string, claimed: string): boolean => {
-  if (cwd === undefined) return false;
+  migrateRepoIssued(cwd);
   try {
-    const dir = issuedDir(cwd, lead);
-    return dir !== null && fs.existsSync(path.join(dir, hash(claimed)));
+    return fs.existsSync(path.join(userIssuedRoot(), hash(lead), hash(claimed)));
   } catch {
     return false;
   }
@@ -220,9 +268,9 @@ export function sessionClaimRefusal(
   const error = `forged_session: ${claimed} is neither this shell's session (${real.session}) nor an id its host issued to a child of it`;
   // A well-formed subagent id, but no hook here ever recorded one: the hook
   // most likely predates this CLI (CLI and plugin update separately).
-  if (issuedClaim && noIssuedRecord(cwd) && host !== null && PLUGIN_UPDATE[host])
+  if (issuedClaim && noIssuedRecord(cwd, leadOf(claimed)) && host !== null && PLUGIN_UPDATE[host])
     return {
-      error: `${error}; no SubagentStart hook in this workspace has recorded an issued id`,
+      error: `${error}; no SubagentStart hook has recorded an issued id for this lead`,
       unblock: `the workit plugin hook is probably older than this CLI and does not record the ids it issues: update the plugin (${PLUGIN_UPDATE[host]}), then relaunch the verifier so its SubagentStart runs the new hook (workit doctor checks this as hook_issued_sessions)`,
     };
   const ownChildShell = host !== null && OWN_CHILD_SHELL.has(host);