@brainervirus/workit-core 7.0.0 → 7.1.0

package/package.json

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

package/src/core/branch.ts

@@ -5,6 +5,7 @@ import path from "node:path";
 import { matchCommitFlavor } from "./commit-flavors";
 import { gitContext } from "./git";
 import {
+  branchGlobPattern,
   readConfig,
   resolveBranchPolicy as resolveConfiguredBranchPolicy,
   resolveCommitPolicy as resolveConfiguredCommitPolicy,
@@ -15,6 +16,47 @@ import {
   type WorkspaceCommitPolicy,
 } from "./workspaces";
 import { vcsCliIdentity, vcsConfig } from "./vcs-config";
+import {
+  ReleaseTrackError,
+  namingGlob,
+  trackBranches,
+  workspaceReleaseTracks,
+} from "./release-tracks";
+
+/**
+ * Release tracks extend the branch policy: every track's long-lived branches
+ * are protected (the union across tracks plus the explicit protected list),
+ * and the tracks' naming templates are allowed branch patterns. A track read
+ * that must fail closed (a `critical` field) throws, so callers block.
+ */
+const withReleaseTracks = (
+  workspaceRoot: string,
+  policy: ReturnType<typeof resolveConfiguredBranchPolicy>,
+): ReturnType<typeof resolveConfiguredBranchPolicy> => {
+  const read = workspaceReleaseTracks(workspaceRoot);
+  if (read.error) throw new ReleaseTrackError(read.error);
+  if (read.tracks.length === 0 && read.protectedBranches.length === 0) return policy;
+  const known = new Set(policy.allowed.map((pattern) => pattern.source));
+  const allowed = [...policy.allowed];
+  for (const glob of read.tracks.flatMap((track) => Object.values(track.naming).map(namingGlob))) {
+    const pattern = branchGlobPattern(glob);
+    if (!known.has(pattern.source)) {
+      known.add(pattern.source);
+      allowed.push(pattern);
+    }
+  }
+  return {
+    ...policy,
+    allowed,
+    protected: new Set([
+      ...policy.protected,
+      // Fail-safe: every branch any track entry names, including dropped ones.
+      ...[...trackBranches(read.tracks), ...read.protectedBranches].map((name) =>
+        name.toLowerCase(),
+      ),
+    ]),
+  };
+};
 
 function effectiveWorkspacePolicy(
   workspaceRoot: string,
@@ -53,9 +95,12 @@ function effectiveWorkspacePolicy(
   const config = readConfig();
   return kind === "branch"
     ? {
-        branchPolicy: resolveConfiguredBranchPolicy(
-          config,
-          selected.policy ? { branchPolicy: selected.policy as WorkspaceBranchPolicy } : null,
+        branchPolicy: withReleaseTracks(
+          workspaceRoot,
+          resolveConfiguredBranchPolicy(
+            config,
+            selected.policy ? { branchPolicy: selected.policy as WorkspaceBranchPolicy } : null,
+          ),
         ),
         provenance: { branchPolicy: selected.source },
       }
@@ -262,10 +307,16 @@ export const verifyPushIdentity = (
   return { ok: true };
 };
 // RL-01: malformed vcs.json blocks branch resolution with an exact-path error.
-const baseBranch = (cwd: string): { base: string } | { error: string } => {
+// With release tracks, the base is the resolved track's base branch.
+const baseBranch = (cwd: string): { base: string; trackBranches: string[] } | { error: string } => {
   const resolved = vcsConfig("resolve", cwd);
   if (resolved.ok === false) return { error: String(resolved.error) };
-  return { base: String(resolved.defaultTargetBranch ?? "develop") };
+  // Creating a branch on an undetermined release line would guess the base.
+  if (resolved.releaseTrack?.blocking) return { error: String(resolved.releaseTrack.blocking) };
+  return {
+    base: String(resolved.baseBranch ?? resolved.defaultTargetBranch ?? "develop"),
+    trackBranches: resolved.releaseTrack ? trackBranches(resolved.releaseTrack.tracks) : [],
+  };
 };
 const DECLARE_RE = /^\s*\*+Branch:\*+\s*`?([^`\s|]+)`?\s*$/gim;
 const USE_CURRENT_RE = /^\s*\*+Branch:\*+\s*use-current\s*$/im;
@@ -407,7 +458,13 @@ export const docsBranch = ({
   if ("error" in baseResolved) return { error: baseResolved.error };
   const base = baseResolved.base;
 
-  if (current === base || current === "main" || current === "master" || current === "develop") {
+  if (
+    current === base ||
+    current === "main" ||
+    current === "master" ||
+    current === "develop" ||
+    baseResolved.trackBranches.includes(current)
+  ) {
     let slug = "";
     if (plan_path) {
       const plan = path.isAbsolute(plan_path) ? plan_path : path.join(cwd, plan_path);

package/src/core/config.ts

@@ -287,6 +287,14 @@ export const describeConfigSource = (
   }
 };
 
+/** The global vcs.json path (WORKFLOW_VCS_CONFIG overrides it). */
+export const vcsConfigPath = (): string =>
+  process.env.WORKFLOW_VCS_CONFIG ?? path.join(configDir(), "vcs.json");
+
+/** An allowed-branch glob (`feature/*`) as a case-insensitive whole-name RegExp. */
+export const branchGlobPattern = (glob: string): RegExp =>
+  new RegExp(`^${glob.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*")}$`, "i");
+
 export const resolveBranchPolicy = (
   config: ToolkitConfig,
   workspace?: { branchPolicy?: Record<string, any> } | null,
@@ -315,9 +323,7 @@ export const resolveBranchPolicy = (
     },
     config,
   );
-  const allowed = merged.allowed.map(
-    (p) => new RegExp(`^${p.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*")}$`, "i"),
-  );
+  const allowed = merged.allowed.map(branchGlobPattern);
   return {
     preset,
     allowed,

package/src/core/pr-create.ts

@@ -231,9 +231,14 @@ export function prCreate(env: NodeJS.ProcessEnv, cwd: string): Record<string, an
 
   // The caller selects the target; GitHub/GitLab enforce their own protections.
   const targetOverride = env.WF_PR_TARGET;
-  const resolvedDefault = String(
-    cfg.defaultTargetBranch ?? policy.defaultTargetBranch ?? "develop",
-  );
+  let resolvedDefault = String(cfg.defaultTargetBranch ?? policy.defaultTargetBranch ?? "develop");
+  if (!targetOverride) {
+    // Release tracks resolve in resolve mode: the target is the branch's line.
+    const resolved = vcsConfig("resolve", root);
+    if (resolved.ok === false) return { error: String(resolved.error) };
+    if (resolved.releaseTrack?.blocking) return { error: String(resolved.releaseTrack.blocking) };
+    resolvedDefault = String(resolved.defaultTargetBranch ?? resolvedDefault);
+  }
   const target = targetOverride || resolvedDefault;
   const title = String(env.WF_PR_TITLE ?? "");
   const br = spawnSync("git", ["rev-parse", "--abbrev-ref", "HEAD"], {