@brainervirus/workit-cursor 8.10.0 → 8.11.0

package/dist/cursor-session-start.js

@@ -8834,7 +8834,7 @@ var PREFIXES, branchNames = (workspaceRoot) => {
     return new Set;
   return new Set((r.stdout ?? "").split(`
 `).filter(Boolean).map((ref) => ref.startsWith("refs/heads/") ? ref.slice("refs/heads/".length) : ref.slice("refs/remotes/origin/".length)));
-}, detectBranchPolicy = (workspaceRoot) => {
+}, productionBranchOf = (names) => names.has("main") ? "main" : names.has("master") ? "master" : "main", detectBranchPolicy = (workspaceRoot) => {
   const names = branchNames(workspaceRoot);
   const develop = names.has("develop");
   const main = names.has("main");
@@ -17647,10 +17647,41 @@ var withReleaseTracks = (workspaceRoot, policy) => {
       ...[...trackBranches(read.tracks), ...read.protectedBranches].map((name) => name.toLowerCase())
     ])
   };
+}, KIND_SYNONYMS, allowedKinds = (allowed) => [
+  ...new Set(allowed.map((pattern) => /^\^([\w.-]+)\\?\/\.\*\$$/u.exec(pattern.source)?.[1]?.toLowerCase()).filter((kind) => Boolean(kind)))
+], editDistance = (a, b) => {
+  const row = Array.from({ length: b.length + 1 }, (_, index) => index);
+  for (let i = 1;i <= a.length; i++) {
+    let previous = row[0];
+    row[0] = i;
+    for (let j = 1;j <= b.length; j++) {
+      const saved = row[j];
+      row[j] = Math.min(row[j] + 1, row[j - 1] + 1, previous + (a[i - 1] === b[j - 1] ? 0 : 1));
+      previous = saved;
+    }
+  }
+  return row[b.length];
+}, suggestBranchName = (name, kinds) => {
+  if (!kinds.length)
+    return null;
+  const slash = name.indexOf("/");
+  const prefix = slash > 0 ? name.slice(0, slash).toLowerCase() : "";
+  const rest = (slash > 0 ? name.slice(slash + 1) : name) || "name";
+  const synonym = KIND_SYNONYMS[prefix];
+  const near = kinds.map((kind) => ({ kind, distance: editDistance(prefix, kind) })).filter((entry) => prefix && entry.distance <= 2).toSorted((a, b) => a.distance - b.distance)[0]?.kind;
+  const kind = (synonym && kinds.includes(synonym) ? synonym : null) ?? near ?? (kinds.includes("feature") ? "feature" : kinds[0]);
+  return `${kind}/${rest}`;
+}, kindList = (kinds) => kinds.map((kind) => `${kind}/`).join(", "), aliasNote = (kinds) => {
+  const notes = [
+    ["fix", "bugfix"],
+    ["chore", "feature"]
+  ].filter(([, kind]) => kinds.includes(kind)).map(([alias, kind]) => `${alias}/ is ${kind}/`);
+  return notes.length ? ` (${notes.join(", ")})` : "";
 }, validateBranchNamePolicy = (name, policy, source) => {
   const allowed = policy.allowed.map((pattern) => `/${pattern.source}/${pattern.flags}`);
+  const kinds = allowedKinds(policy.allowed);
   if (policy.protected.has(name.toLowerCase())) {
-    const correction = `choose a non-protected branch matching one of: ${allowed.join(", ")}`;
+    const correction = kinds.length ? `choose a non-protected branch of an allowed kind (${kindList(kinds)}), e.g. ${kinds[0]}/<slug>: workit git branch --kind ${kinds[0]} --slug <slug>` : `choose a non-protected branch matching one of: ${allowed.join(", ")}`;
     return {
       ok: false,
       rule: "protected_ref",
@@ -17661,7 +17692,8 @@ var withReleaseTracks = (workspaceRoot, policy) => {
     };
   }
   if (!policy.allowed.some((pattern) => pattern.test(name))) {
-    const correction = `choose a branch matching one of: ${allowed.join(", ")}`;
+    const suggestion = suggestBranchName(name, kinds);
+    const correction = suggestion && policy.allowed.some((pattern) => pattern.test(suggestion)) ? `use ${JSON.stringify(suggestion)}; the allowed kinds are ${kindList(kinds)} (workit git branch ${suggestion})` : `choose a branch matching one of: ${allowed.join(", ")}`;
     return {
       ok: false,
       rule: "allowed_pattern",
@@ -17700,7 +17732,52 @@ var withReleaseTracks = (workspaceRoot, policy) => {
       error: `policy_unavailable: cannot validate branch ${JSON.stringify(name)} because ${error instanceof Error ? error.message : String(error)}; ${correction}`
     };
   }
-}, resolveBranchPolicyFor = (workspaceRoot, profileName) => effectiveWorkspacePolicy(workspaceRoot, "branch", profileName).branchPolicy;
+}, resolveBranchPolicyFor = (workspaceRoot, profileName) => effectiveWorkspacePolicy(workspaceRoot, "branch", profileName).branchPolicy, gitFlowOf = (root, integration) => {
+  try {
+    if (resolveBranchPolicyFor(root).preset !== "gitflow")
+      return null;
+    const selected = resolveRuntimeWorkspacePolicy(root, "branch", process.env.WORKFLOW_PROFILE?.trim() || undefined).policy;
+    const names = branchNames(root);
+    const production = productionBranchOf(names);
+    const develop = selected?.developBranch?.trim() || (integration && integration.toLowerCase() !== production ? integration : "develop");
+    return { develop, production, developExists: names.has(develop) };
+  } catch {
+    return null;
+  }
+}, releaseBranchesOf = (cwd) => {
+  try {
+    const resolved = resolveBranchPolicyFor(cwd);
+    const flow = resolved.preset === "gitflow" ? gitFlowOf(cwd) : null;
+    return {
+      preset: resolved.preset,
+      branches: flow ? [flow.production, flow.develop] : [],
+      production: flow ? flow.production : resolved.defaultTargetBranch
+    };
+  } catch {
+    return { preset: "unknown", branches: [], production: null };
+  }
+}, releaseBranch = (cwd, branch) => releaseBranchesOf(cwd).branches.some((name) => name.toLowerCase() === branch.toLowerCase()), branchGuidance = (cwd) => {
+  try {
+    const patterns = branchPolicySnapshotFor(cwd).namePolicy.allowed;
+    const kinds = allowedKinds(patterns);
+    const kindShaped = new Set(kinds.map((kind) => branchGlobPattern(`${kind}/*`).source));
+    const anyName = patterns.some((pattern) => pattern.source === "^.*$");
+    const others = patterns.filter((pattern) => !kindShaped.has(pattern.source)).map((pattern) => globOf(pattern));
+    const allowed = anyName ? "Any non-protected branch name is allowed here." : `${kinds.length ? `Allowed branch kinds here: ${kindList(kinds)}${aliasNote(kinds)}` : "Allowed branch names here:"}${others.length ? `${kinds.length ? "; also" : ""} names matching ${others.join(", ")}` : ""}; anything else is denied.`;
+    const resolved = vcsConfig("resolve", cwd);
+    const integration = resolved.ok === false ? null : String(resolved.defaultTargetBranch ?? "") || null;
+    const flow = resolved.releaseTrack?.track ? null : gitFlowOf(cwd, integration);
+    if (flow?.developExists)
+      return `${allowed} git-flow: feature/, bugfix/ and release/ start from origin/${flow.develop}, hotfix/ from origin/${flow.production}; feature/ and bugfix/ land on ${flow.develop}, release/ and hotfix/ on ${flow.production}.`;
+    const names = branchNames(cwd);
+    const configured = String(resolved.baseBranch ?? integration ?? "") || null;
+    const trunk = productionBranchOf(names);
+    const base = configured && names.has(configured) ? `Branch from origin/${configured}.` : names.has(trunk) ? `Branch from origin/${trunk}${configured ? ` (the default target ${configured} does not exist here)` : ""}.` : "No base branch exists here yet; pass the base explicitly.";
+    return `${allowed} ${base}`;
+  } catch {
+    return null;
+  }
+}, globOf = (pattern) => pattern.source.replace(/^\^|\$$/gu, "").replaceAll(".*", "*").replace(/\\(.)/gu, "$1");
 var init_branch = __esm(() => {
   init_branch_policy();
   init_commit_flavors();
@@ -17709,33 +17786,63 @@ var init_branch = __esm(() => {
   init_workspaces();
   init_vcs_config();
   init_release_tracks();
+  KIND_SYNONYMS = {
+    fix: "bugfix",
+    fixes: "bugfix",
+    bug: "bugfix",
+    bugs: "bugfix",
+    bugfixes: "bugfix",
+    feat: "feature",
+    features: "feature",
+    chore: "feature",
+    docs: "feature",
+    doc: "feature",
+    refactor: "feature",
+    test: "feature",
+    tests: "feature",
+    ci: "feature",
+    build: "feature",
+    perf: "feature",
+    style: "feature",
+    deps: "feature",
+    task: "feature",
+    enhancement: "feature",
+    hot: "hotfix",
+    hotfixes: "hotfix",
+    releases: "release",
+    rel: "release"
+  };
 });
 
-// packages/workit-core/src/core/route-intent.ts
-var shellBranchTarget = (command) => {
-  if (!command.trim() || /[\r\n;&|<>`'"$()\\*?{}~!#]/u.test(command) || command.includes("[") || command.includes("]"))
-    return null;
-  const args = command.trim().split(/\s+/u);
-  if (args[0] !== "git")
-    return null;
-  const option = args[2];
-  const target = args[1] === "switch" && ["-c", "--create", "-C", "--force-create"].includes(option ?? "") && (args.length === 4 || args.length === 5) ? args[3] : args[1] === "checkout" && ["-b", "-B"].includes(option ?? "") && (args.length === 4 || args.length === 5) ? args[3] : args[1] === "branch" && (args.length === 3 || args.length === 4) ? args[2] : null;
-  return target && !target.startsWith("-") ? target : null;
-}, shellBranchPolicyViolation = (root, command) => {
-  const target = shellBranchTarget(command);
-  return target === null ? null : validateBranchNameFor(root, target);
-};
-var init_route_intent = __esm(() => {
-  init_branch();
-});
-
-// packages/workit-core/src/hooks/policy.ts
-var shellPolicy = (cwd, command) => {
-  const policy = shellBranchPolicyViolation(cwd, command);
-  return policy && !policy.ok ? { kind: "deny", reason: `branch_policy_denied: ${policy.error}`, unblock: null } : { kind: "none" };
+// packages/workit-core/src/hooks/session-marker.ts
+import { createHash as createHash13 } from "node:crypto";
+import fs15 from "node:fs";
+import path18 from "node:path";
+var sessionMarkerFile = (input, session, store) => {
+  let dir = store;
+  if (dir === undefined) {
+    const location = resolveStore(input.cwd);
+    if (location instanceof Error || !location.shared)
+      return null;
+    dir = location.dir;
+  }
+  const name = createHash13("sha256").update(`${input.host}\x00${session}`).digest("hex").slice(0, 32);
+  return path18.join(dir, "hooks", `skills-${name}.json`);
+}, list2 = (value) => Array.isArray(value) ? value.filter((item) => typeof item === "string") : [], readSessionMarker = (file) => {
+  try {
+    const value = JSON.parse(fs15.readFileSync(file, "utf8"));
+    return { nudged: list2(value.nudged), loaded: list2(value.loaded), raw: list2(value.raw) };
+  } catch {
+    return { nudged: [], loaded: [], raw: [] };
+  }
+}, writeSessionMarker = (file, marker) => {
+  try {
+    fs15.mkdirSync(path18.dirname(file), { recursive: true });
+    fs15.writeFileSync(file, JSON.stringify(marker));
+  } catch {}
 };
-var init_policy = __esm(() => {
-  init_route_intent();
+var init_session_marker = __esm(() => {
+  init_paths();
 });
 
 // packages/workit-core/src/hooks/shell-words.ts
@@ -17859,219 +17966,12 @@ var closingQuote = (command, start, dialect) => {
   return segments;
 };
 
-// packages/workit-core/src/hooks/write-gate.ts
-import { realpathSync as realpathSync5 } from "node:fs";
-import path18 from "node:path";
-function writeGate(cwd, paths) {
-  try {
-    const gate = gateFor(cwd);
-    if (!gate || gate.blockers.length === 0)
-      return NONE2;
-    if (paths?.length && paths.every((file) => exempt(cwd, gate.root, file, gate.plans)))
-      return NONE2;
-    const reasons = gate.blockers.map((item) => `${item.ruleId}: ${item.reason}`).join("; ");
-    return {
-      kind: "deny",
-      reason: `workit before-write gate: ${reasons}. Markdown, docs/, plans/ and files outside the checkout stay writable.`,
-      unblock: gate.blockers[0].reason
-    };
-  } catch {
-    return NONE2;
-  }
-}
-var NONE2, CASE_INSENSITIVE, canonical2 = (file) => {
-  let rest = "";
-  for (let dir = path18.resolve(file);; dir = path18.dirname(dir)) {
-    try {
-      return path18.join(realpathSync5(dir), rest);
-    } catch {
-      if (path18.dirname(dir) === dir)
-        return path18.resolve(file);
-      rest = rest ? path18.join(path18.basename(dir), rest) : path18.basename(dir);
-    }
-  }
-}, exempt = (cwd, root, file, plans) => {
-  const fold = (value) => CASE_INSENSITIVE ? value.toLowerCase() : value;
-  const relative = path18.relative(fold(canonical2(root)), fold(canonical2(path18.resolve(cwd, file))));
-  if (relative.startsWith("..") || path18.isAbsolute(relative))
-    return true;
-  const posix = relative.split(path18.sep).join("/");
-  const segments = posix.split("/");
-  return /\.mdx?$/i.test(posix) || segments[0] === "docs" || segments.includes("plans") || [...plans].some((plan) => fold(plan) === posix);
-}, PREFIXES2, operands = (words) => words.filter((item) => !item.startsWith("-")), editsOf = (input) => {
-  let words = input;
-  while (words.length && (PREFIXES2.has(words[0]) || /^\w+=/.test(words[0])))
-    words = words.slice(1);
-  const [verb, ...args] = words;
-  const name = (verb?.split(/[\\/]/).at(-1) ?? "").toLowerCase();
-  if (!name || name === "workit" || name === "npx" && args.some((item) => /workit/.test(item)))
-    return [];
-  switch (name) {
-    case "touch":
-    case "mkdir":
-    case "rm":
-    case "rmdir":
-    case "tee":
-    case "mv":
-    case "truncate":
-      return operands(args);
-    case "cp":
-    case "ln":
-    case "install": {
-      const target = args.indexOf("-t");
-      if (target >= 0)
-        return args[target + 1] ? [args[target + 1]] : null;
-      const last = operands(args).at(-1);
-      return last ? [last] : null;
-    }
-    case "dd":
-      return args.filter((item) => item.startsWith("of=")).map((item) => item.slice(3));
-    case "sed":
-    case "perl": {
-      if (!args.some((item) => /^-[a-zA-Z]*i|^--in-place/.test(item)))
-        return [];
-      const scripted = args.some((item) => item === "-e" || item === "-f");
-      const files = [];
-      for (let index = 0;index < args.length; index++) {
-        if (args[index] === "-e" || args[index] === "-f")
-          index++;
-        else if (!args[index].startsWith("-"))
-          files.push(args[index]);
-      }
-      return scripted ? files : files.slice(1);
-    }
-    case "patch":
-      return null;
-    case "set-content":
-    case "add-content":
-    case "out-file":
-    case "new-item":
-    case "ni":
-    case "remove-item":
-    case "del":
-    case "copy-item":
-    case "move-item": {
-      const flag = args.findIndex((item) => /^-(?:path|filepath|literalpath|destination)$/i.test(item));
-      if (flag >= 0)
-        return args[flag + 1] ? [args[flag + 1]] : null;
-      const files = operands(args);
-      if (name === "move-item")
-        return files.length ? files : null;
-      const file = name === "copy-item" ? files.at(-1) : files[0];
-      return file ? [file] : null;
-    }
-    case "git": {
-      const sub = operands(args)[0];
-      if (sub === "apply")
-        return null;
-      if (sub === "restore" || sub === "mv" || sub === "rm")
-        return operands(args).slice(1);
-      if (sub === "checkout" && args.includes("--"))
-        return args.slice(args.indexOf("--") + 1);
-      return [];
-    }
-    default:
-      return [];
-  }
-}, shellWrites = (command) => {
-  const targets = [];
-  let unknown = false;
-  for (const segment of segmentsOf(command)) {
-    targets.push(...segment.redirects.filter((item) => !/^\/dev\/(?:null|stdout|stderr|tty)$/.test(item)));
-    const edits = editsOf(segment.words);
-    if (edits === null)
-      unknown = true;
-    else
-      targets.push(...edits);
-  }
-  if (!unknown && targets.length === 0)
-    return { writes: false, targets: null };
-  return { writes: true, targets: unknown ? null : targets };
-}, cache2, planKeyOf = (root, plans) => [...plans].map((file) => fileSignature(path18.resolve(root, file)) ?? "-").join("\x00"), gateFor = (cwd) => {
-  const store = new TaskStore(cwd);
-  const listed = store.listTaskIndex();
-  if (!listed.ok)
-    return null;
-  const key = store.currentKey();
-  if (!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];
-  if (!entry)
-    return { blockers: [], root: store.root, plans: new Set };
-  const ledger = ledgerPath(store.root);
-  const cacheKey = `${entry.id}\x00${entry.revision}\x00${ledger.ok && fileSignature(ledger.value) || "-"}`;
-  const hit = cache2.get(store.root);
-  if (hit && hit.key === cacheKey && hit.planKey === planKeyOf(store.root, hit.plans))
-    return hit;
-  const task = store.readTask(entry.id);
-  if (!task.ok)
-    return null;
-  const workspace = store.readWorkspace();
-  const plans = new Set((latestJudgment(task.data)?.refs ?? []).flatMap((ref) => ref.kind === "file" ? [ref.path] : []));
-  const blockers = writeBlockers(task.data, store.root).filter((blocker) => {
-    const requirement = task.data.policy?.requirements.find((item) => item.ruleId === blocker.ruleId && item.before === "write");
-    return !(requirement?.acceptanceAllowed && workspace.ok && workspace.data && applicableDecision(task.data, workspace.data, requirement, store.root).length > 0);
-  });
-  const gate = {
-    blockers,
-    root: store.root,
-    plans,
-    key: cacheKey,
-    planKey: planKeyOf(store.root, plans)
-  };
-  cache2.set(store.root, gate);
-  if (cache2.size > 32)
-    cache2.delete(cache2.keys().next().value);
-  return gate;
-};
-var init_write_gate = __esm(() => {
-  init_task_store();
-  init_derive();
-  init_task_evaluation();
-  init_ledger();
-  NONE2 = { kind: "none" };
-  CASE_INSENSITIVE = process.platform === "darwin" || process.platform === "win32";
-  PREFIXES2 = new Set(["sudo", "command", "env", "nohup", "time", "exec", "xargs"]);
-  cache2 = new Map;
-});
-
-// packages/workit-core/src/hooks/session-marker.ts
-import { createHash as createHash13 } from "node:crypto";
-import fs15 from "node:fs";
-import path19 from "node:path";
-var sessionMarkerFile = (input, session, store) => {
-  let dir = store;
-  if (dir === undefined) {
-    const location = resolveStore(input.cwd);
-    if (location instanceof Error || !location.shared)
-      return null;
-    dir = location.dir;
-  }
-  const name = createHash13("sha256").update(`${input.host}\x00${session}`).digest("hex").slice(0, 32);
-  return path19.join(dir, "hooks", `skills-${name}.json`);
-}, list2 = (value) => Array.isArray(value) ? value.filter((item) => typeof item === "string") : [], readSessionMarker = (file) => {
-  try {
-    const value = JSON.parse(fs15.readFileSync(file, "utf8"));
-    return { nudged: list2(value.nudged), loaded: list2(value.loaded), raw: list2(value.raw) };
-  } catch {
-    return { nudged: [], loaded: [], raw: [] };
-  }
-}, writeSessionMarker = (file, marker) => {
-  try {
-    fs15.mkdirSync(path19.dirname(file), { recursive: true });
-    fs15.writeFileSync(file, JSON.stringify(marker));
-  } catch {}
-};
-var init_session_marker = __esm(() => {
-  init_paths();
-});
-
 // packages/workit-core/src/hooks/raw-git.ts
 import { spawnSync as spawnSync11 } from "node:child_process";
 import { createHash as createHash14 } from "node:crypto";
 import fs16 from "node:fs";
 import os4 from "node:os";
-import path20 from "node:path";
+import path19 from "node:path";
 function rawInvocations(command, dialect = "posix", depth = 0) {
   const found = [];
   let dir = null;
@@ -18181,7 +18081,7 @@ function rawAction(invocation) {
 function rawGitPre(input, command, options = {}) {
   try {
     if (!mentionsRawTool(command))
-      return NONE3;
+      return NONE2;
     const dialect = dialectOf(input);
     const nudges = new Map;
     let store = null;
@@ -18189,25 +18089,36 @@ function rawGitPre(input, command, options = {}) {
       store ??= repo.location.dir;
       if (action.kind === "merge")
         return deny(refusal(action, null));
-      if (action.kind === "push")
+      if (action.kind === "push" && toPushRemote(repo, action.remote)) {
+        if (action.mirror)
+          return deny(`workit: raw ${quote("git push --mirror")} rewrites and deletes every remote ref, protected branches and tags included. Push one branch with ${quote("workit git push")}.`);
         for (const target of action.targets) {
           const branch = target ?? repo.branch;
-          if (branch && guardedBranch(repo.dir, branch) && toPushRemote(repo, action.remote))
-            return deny(refusal(action, branch));
+          if (branch && guardedBranch(repo.dir, branch))
+            return deny(refusal(action, branch, repo.dir));
         }
+        const remote = action.remote ?? pushRemoteName(repo.dir, repo.branch) ?? "origin";
+        const facts = refFacts(repo, remote);
+        const tagDeny = tagRefusal(action, facts);
+        if (tagDeny)
+          return deny(tagDeny);
+        const nameDeny = action.deletes ? null : offPolicyPush(action, repo, facts, remote);
+        if (nameDeny)
+          return deny(nameDeny);
+      }
       const nudge = nudgeFor(action, input.host, input.session.id);
       if (nudge && !nudges.has(nudgeKind(action)))
         nudges.set(nudgeKind(action), nudge);
     }
     if (options.nudge === false || !store || nudges.size === 0)
-      return NONE3;
+      return NONE2;
     if (workitInvocations(command, dialect).length > 0)
-      return NONE3;
+      return NONE2;
     const shown = unseenNudges(input, nudges, store);
     return shown.length ? { kind: "context", text: shown.join(`
-`) } : NONE3;
+`) } : NONE2;
   } catch {
-    return NONE3;
+    return NONE2;
   }
 }
 function noteRawCommit(input, command, key) {
@@ -18219,7 +18130,7 @@ function noteRawCommit(input, command, key) {
       if (action.kind !== "commit")
         continue;
       const file = markerFile(repo, input.session.id, key);
-      fs16.mkdirSync(path20.dirname(file), { recursive: true });
+      fs16.mkdirSync(path19.dirname(file), { recursive: true });
       fs16.writeFileSync(file, `${JSON.stringify({ head: headSha2(repo), at })}
 `);
     }
@@ -18246,11 +18157,11 @@ function settlePendingCommit(input) {
       settle2(input, repo, file);
   } catch {}
 }
-var NONE3, SHELLS, PREFIXES3, SCRIPT_FLAG, CD, PUSHD, POPD, GIT_VALUE_OPTIONS, isAbsolute = (value) => path20.isAbsolute(value) || /^[A-Za-z]:[\\/]/.test(value) || value.startsWith("\\\\"), joinDir = (base, next) => {
+var NONE2, SHELLS, PREFIXES2, SCRIPT_FLAG, CD, PUSHD, POPD, GIT_VALUE_OPTIONS, isAbsolute = (value) => path19.isAbsolute(value) || /^[A-Za-z]:[\\/]/.test(value) || value.startsWith("\\\\"), joinDir = (base, next) => {
   if (base === undefined || /[$`*?]/.test(next) || next === "-")
     return;
-  const expanded = next === "~" || next.startsWith("~/") ? path20.join(os4.homedir(), next.slice(1)) : next;
-  return base === null || isAbsolute(expanded) ? expanded : path20.join(base, expanded);
+  const expanded = next === "~" || next.startsWith("~/") ? path19.join(os4.homedir(), next.slice(1)) : next;
+  return base === null || isAbsolute(expanded) ? expanded : path19.join(base, expanded);
 }, cdTarget = (words) => {
   const args = words.slice(1);
   const flag = args.findIndex((word) => /^-(?:literal)?path$/i.test(word));
@@ -18265,7 +18176,7 @@ var NONE3, SHELLS, PREFIXES3, SCRIPT_FLAG, CD, PUSHD, POPD, GIT_VALUE_OPTIONS, i
       return words;
     if (/^\w+=/.test(first))
       words = words.slice(1);
-    else if (PREFIXES3.has(first)) {
+    else if (PREFIXES2.has(first)) {
       words = words.slice(1);
       while (words[0]?.startsWith("-"))
         words = words.slice(words[0] === "-u" ? 2 : 1);
@@ -18281,6 +18192,10 @@ var NONE3, SHELLS, PREFIXES3, SCRIPT_FLAG, CD, PUSHD, POPD, GIT_VALUE_OPTIONS, i
   let force = false;
   let lease = false;
   let wholesale = false;
+  let allTags = false;
+  let deletes = false;
+  let allBranches = false;
+  let mirror = false;
   let remote = null;
   const positionals = [];
   for (let index = 1;index < args.length; index++) {
@@ -18301,14 +18216,22 @@ var NONE3, SHELLS, PREFIXES3, SCRIPT_FLAG, CD, PUSHD, POPD, GIT_VALUE_OPTIONS, i
       force = true;
     else if (arg.startsWith("--force-with-lease") || arg === "--force-if-includes")
       lease = true;
-    else if (["--all", "--mirror", "--branches", "--tags"].includes(arg))
-      wholesale = true;
+    else if (arg === "--delete" || arg === "-d")
+      deletes = true;
+    else if (arg === "--tags")
+      allTags = wholesale = true;
+    else if (arg === "--all" || arg === "--branches")
+      allBranches = wholesale = true;
+    else if (arg === "--mirror")
+      mirror = wholesale = true;
     else if (!arg.startsWith("-"))
       positionals.push(arg);
   }
   const specs = remote === null ? positionals.slice(1) : positionals;
   remote ??= positionals[0] ?? null;
   const targets = [];
+  const tags = [];
+  const deleted = [];
   for (const raw of specs) {
     if (raw.startsWith("+"))
       force = true;
@@ -18317,16 +18240,29 @@ var NONE3, SHELLS, PREFIXES3, SCRIPT_FLAG, CD, PUSHD, POPD, GIT_VALUE_OPTIONS, i
     const destination = colon >= 0 ? spec.slice(colon + 1) : spec;
     if (!destination)
       continue;
-    if (destination === "HEAD")
-      targets.push(null);
-    else if (destination.startsWith("refs/heads/"))
-      targets.push(destination.slice(11));
-    else if (!destination.startsWith("refs/"))
-      targets.push(destination);
+    const name = destination === "HEAD" ? null : destination.startsWith("refs/heads/") ? destination.slice(11) : destination.startsWith("refs/") ? undefined : destination;
+    if (destination.startsWith("refs/tags/"))
+      tags.push(destination.slice(10));
+    if (name === undefined)
+      continue;
+    targets.push(name);
+    if (colon === 0 && name !== null)
+      deleted.push(name);
   }
   if (specs.length === 0 && !wholesale)
     targets.push(null);
-  return { kind: "push", targets, blindForce: force && !lease, remote };
+  return {
+    kind: "push",
+    targets,
+    blindForce: force && !lease,
+    remote,
+    ...tags.length ? { tags } : {},
+    ...allTags ? { allTags: true } : {},
+    ...deletes ? { deletes: true } : {},
+    ...deleted.length ? { deleted } : {},
+    ...allBranches ? { allBranches: true } : {},
+    ...mirror ? { mirror: true } : {}
+  };
 }, VALUE_OPTIONS, asksHelp = (invocation) => {
   const { tool, args } = invocation;
   if (args[0] === "help" || tool !== "git" && args[1] === "help")
@@ -18376,25 +18312,72 @@ var NONE3, SHELLS, PREFIXES3, SCRIPT_FLAG, CD, PUSHD, POPD, GIT_VALUE_OPTIONS, i
   if (!git || git.reftable)
     return null;
   try {
-    const head = fs16.readFileSync(path20.join(git.gitDir, "HEAD"), "utf8").trim();
+    const head = fs16.readFileSync(path19.join(git.gitDir, "HEAD"), "utf8").trim();
     if (/^[0-9a-f]{40,64}$/.test(head))
       return head;
     const ref = /^ref: (refs\/.+)$/.exec(head)?.[1];
     if (!ref)
       return null;
-    const common = path20.dirname(repo.location.dir);
+    const common = path19.dirname(repo.location.dir);
     try {
-      return fs16.readFileSync(path20.join(common, ref), "utf8").trim() || null;
+      return fs16.readFileSync(path19.join(common, ref), "utf8").trim() || null;
     } catch {}
-    const packed = fs16.readFileSync(path20.join(common, "packed-refs"), "utf8");
+    const packed = fs16.readFileSync(path19.join(common, "packed-refs"), "utf8");
     return new RegExp(`^([0-9a-f]{40,64}) ${ref.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}$`, "m").exec(packed)?.[1] ?? null;
   } catch {
     return null;
   }
-}, quote = (text) => `\`${text}\``, refusal = (action, branch) => {
+}, quote = (text) => `\`${text}\``, refusal = (action, branch, dir) => {
   if (action.kind === "merge")
     return `workit: raw ${quote(action.forge === "gh" ? "gh pr merge" : "glab mr merge")} bypasses the merge grant and the verdict gate. Run ${quote("workit pr merge")} instead (it checks both; ${quote("workit help pr")}).`;
+  const plainPush = action.kind === "push" && !action.blindForce && !action.deletes;
+  if (dir && branch && plainPush && releaseBranch(dir, branch))
+    return `workit: raw ${quote("git push")} onto ${branch}, a protected release branch, bypasses workit's protected-branch check. To finish a release or hotfix, push it with ${quote(`workit git push --release ${branch} [--release v<version>]`)}: it pushes ${branch} (fast-forward only) and the release tag, verifies the remote and records it, under the ${quote("release")} grant (if refused, ask the user to run ${quote("workit grant set <workspace> release=true")}). Feature work goes through ${quote("workit git push")} and ${quote("workit pr merge")}.`;
   return `workit: raw ${quote("git push")}${action.kind === "push" && action.blindForce ? " --force" : ""} onto ${branch}, a protected branch or the default target, bypasses workit's protected-branch check. Push your feature branch with ${quote("workit git push")} (${quote("workit git push --force-with-lease")} to rewrite it) and land it with ${quote("workit pr merge")}.`;
+}, refFacts = (repo, remote) => {
+  const facts = { heads: new Set, tags: new Set, remoteHeads: new Set };
+  const listed = spawnSync11("git", ["for-each-ref", "--format=%(refname)", "refs/heads", "refs/tags", `refs/remotes/${remote}`], { cwd: repo.dir, encoding: "utf8", timeout: 5000 });
+  const remotePrefix = `refs/remotes/${remote}/`;
+  for (const ref of (listed.stdout ?? "").split(`
+`)) {
+    if (ref.startsWith("refs/heads/"))
+      facts.heads.add(ref.slice(11));
+    else if (ref.startsWith("refs/tags/"))
+      facts.tags.add(ref.slice(10));
+    else if (ref.startsWith(remotePrefix))
+      facts.remoteHeads.add(ref.slice(remotePrefix.length));
+  }
+  return facts;
+}, isTag = (facts, name) => facts.tags.has(name) && !facts.heads.has(name), tagRefusal = (action, facts) => {
+  const tags = [
+    ...action.tags ?? [],
+    ...action.targets.filter((name) => name !== null && isTag(facts, name))
+  ];
+  if (!tags.length && !action.allTags)
+    return null;
+  const named = tags.length ? tags.join(" --release ") : "v<version>";
+  return `workit: raw ${quote(`git push${action.allTags ? " --tags" : ""}`)} of ${tags.length ? `tag ${tags.join(", ")}` : "tags"} bypasses the release grant. Push a release tag with ${quote(`workit git push --release ${named}`)} (v<version> tags whose commit the production branch already has; a tag never moves), under the ${quote("release")} grant (if refused, ask the user to run ${quote("workit grant set <workspace> release=true")}).`;
+}, remoteHas = (repo, remote, branch) => {
+  const listed = spawnSync11("git", ["ls-remote", "--heads", remote, `refs/heads/${branch}`], {
+    cwd: repo.dir,
+    encoding: "utf8",
+    timeout: 3000,
+    env: { ...process.env, GIT_TERMINAL_PROMPT: "0" }
+  });
+  return listed.status !== 0 || (listed.stdout ?? "").trim() !== "";
+}, offPolicyPush = (action, repo, facts, remote) => {
+  const names = action.allBranches ? [...facts.heads] : action.targets.map((target) => target ?? repo.branch);
+  for (const branch of names) {
+    if (!branch || action.deleted?.includes(branch) || isTag(facts, branch))
+      continue;
+    if (facts.remoteHeads.has(branch))
+      continue;
+    const check = validateBranchNameFor(repo.dir, branch);
+    if (check.ok || check.rule !== "allowed_pattern" || remoteHas(repo, remote, branch))
+      continue;
+    return `workit: raw ${quote("git push")} onto ${branch}: ${check.error}`;
+  }
+  return null;
 }, nudgeFor = (action, host, session) => {
   switch (action.kind) {
     case "commit": {
@@ -18419,7 +18402,7 @@ var NONE3, SHELLS, PREFIXES3, SCRIPT_FLAG, CD, PUSHD, POPD, GIT_VALUE_OPTIONS, i
     const action = rawAction(invocation);
     if (!action)
       continue;
-    const dir = path20.resolve(cwd, invocation.dir ?? ".");
+    const dir = path19.resolve(cwd, invocation.dir ?? ".");
     if (!repos.has(dir)) {
       const repo = repoAt(dir);
       repos.set(dir, repo && isWorkitWorkspace(repo) ? repo : null);
@@ -18446,7 +18429,7 @@ var NONE3, SHELLS, PREFIXES3, SCRIPT_FLAG, CD, PUSHD, POPD, GIT_VALUE_OPTIONS, i
       raw: [...marker.raw, ...fresh.map((kind) => agent + kind)]
     });
   return fresh.map((kind) => nudges.get(kind));
-}, deny = (reason) => ({ kind: "deny", reason, unblock: null }), NEXT_COMMAND = "next", MARKER_TTL_SECONDS = 3600, markerFile = (repo, session, key) => path20.join(repo.location.dir, "hooks", `commit-${createHash14("sha256").update(`${session}\x00${key}`).digest("hex").slice(0, 32)}.json`), callKey = (toolUseId, command) => toolUseId ?? `cmd:${createHash14("sha256").update(command).digest("hex")}`, headCommit = (dir) => {
+}, deny = (reason) => ({ kind: "deny", reason, unblock: null }), NEXT_COMMAND = "next", MARKER_TTL_SECONDS = 3600, markerFile = (repo, session, key) => path19.join(repo.location.dir, "hooks", `commit-${createHash14("sha256").update(`${session}\x00${key}`).digest("hex").slice(0, 32)}.json`), callKey = (toolUseId, command) => toolUseId ?? `cmd:${createHash14("sha256").update(command).digest("hex")}`, headCommit = (dir) => {
   const run = spawnSync11("git", [
     "log",
     "-1",
@@ -18506,9 +18489,9 @@ var init_raw_git = __esm(() => {
   init_ledger();
   init_paths();
   init_session_marker();
-  NONE3 = { kind: "none" };
+  NONE2 = { kind: "none" };
   SHELLS = new Set(["sh", "bash", "zsh", "dash", "ksh"]);
-  PREFIXES3 = new Set(["sudo", "command", "env", "nohup", "time", "exec", "nice", "&"]);
+  PREFIXES2 = new Set(["sudo", "command", "env", "nohup", "time", "exec", "nice", "&"]);
   SCRIPT_FLAG = /^-[a-zA-Z]*c[a-zA-Z]*$/;
   CD = new Set(["cd", "chdir", "set-location", "sl"]);
   PUSHD = new Set(["pushd", "push-location"]);
@@ -18566,8 +18549,298 @@ var init_raw_git = __esm(() => {
   };
 });
 
-// packages/workit-core/src/hooks/stop.ts
+// packages/workit-core/src/core/route-intent.ts
 import { spawnSync as spawnSync12 } from "node:child_process";
+import { existsSync as existsSync6 } from "node:fs";
+import path20 from "node:path";
+var UNKNOWABLE, SWITCH_CREATE, CHECKOUT_CREATE, WORKTREE_CREATE, BRANCH_NO_CREATE, BRANCH_RENAME, flagValue = (args, flags) => {
+  for (let index = 1;index < args.length; index++) {
+    const arg = args[index];
+    if (arg === "--")
+      return null;
+    if (flags.has(arg))
+      return args[index + 1] ?? null;
+    const eq = arg.indexOf("=");
+    if (arg.startsWith("--") && eq > 0 && flags.has(arg.slice(0, eq)))
+      return arg.slice(eq + 1);
+    if (!arg.startsWith("--") && arg.length > 2 && flags.has(arg.slice(0, 2)))
+      return arg.slice(2);
+  }
+  return null;
+}, WORKTREE_VALUES, worktreeTarget = (args) => {
+  const named = flagValue(args, WORKTREE_CREATE);
+  if (named !== null)
+    return named;
+  const positionals = [];
+  for (let index = 1;index < args.length; index++) {
+    const arg = args[index];
+    if (arg === "--detach" || arg === "-d")
+      return null;
+    if (WORKTREE_VALUES.has(arg))
+      index++;
+    else if (!arg.startsWith("-"))
+      positionals.push(arg);
+  }
+  if (positionals.length !== 1)
+    return null;
+  const base = positionals[0].split(/[\\/]/u).findLast(Boolean) ?? "";
+  return base && base !== "." && base !== ".." ? base : null;
+}, branchCommandTarget = (args) => {
+  let rename = false;
+  const positionals = [];
+  for (let index = 1;index < args.length; index++) {
+    const arg = args[index];
+    if (arg === "--") {
+      positionals.push(...args.slice(index + 1));
+      break;
+    }
+    const flag = arg.split("=", 1)[0];
+    if (BRANCH_NO_CREATE.has(flag))
+      return null;
+    if (BRANCH_RENAME.has(flag))
+      rename = true;
+    else if (!arg.startsWith("-"))
+      positionals.push(arg);
+  }
+  if (positionals.length < 1 || positionals.length > 2)
+    return null;
+  return rename ? positionals.at(-1) ?? null : positionals[0];
+}, gitBranchCreation = (args) => {
+  const [sub, second] = args;
+  const target = sub === "switch" ? flagValue(args, SWITCH_CREATE) : sub === "checkout" ? flagValue(args, CHECKOUT_CREATE) : sub === "branch" ? branchCommandTarget(args) : sub === "worktree" && second === "add" ? worktreeTarget(args.slice(1)) : null;
+  return target && !target.startsWith("-") && !UNKNOWABLE.test(target) ? target : null;
+}, shellBranchTargets = (command, dialect = "posix") => {
+  if (!/\bgit\b/u.test(command))
+    return [];
+  const found = [];
+  for (const invocation of rawInvocations(command, dialect)) {
+    if (invocation.tool !== "git")
+      continue;
+    const branch = gitBranchCreation(invocation.args);
+    if (branch)
+      found.push({ branch, dir: invocation.dir });
+  }
+  return found;
+}, localBranchExists = (dir, branch) => spawnSync12("git", ["show-ref", "--verify", "--quiet", `refs/heads/${branch}`], {
+  cwd: dir,
+  stdio: "ignore",
+  timeout: 5000
+}).status === 0, shellBranchPolicyViolation = (root, command, dialect = "posix") => {
+  let judged = false;
+  for (const target of shellBranchTargets(command, dialect)) {
+    if (target.dir === undefined)
+      continue;
+    const dir = target.dir === null ? root : path20.resolve(root, target.dir);
+    if (target.dir !== null && (!existsSync6(dir) || !inWorkitWorkspace(dir)))
+      continue;
+    if (localBranchExists(dir, target.branch))
+      continue;
+    judged = true;
+    const check = validateBranchNameFor(dir, target.branch);
+    if (!check.ok)
+      return check;
+  }
+  return judged ? { ok: true } : null;
+};
+var init_route_intent = __esm(() => {
+  init_raw_git();
+  init_branch();
+  UNKNOWABLE = /[$`*?[\]{}~]/u;
+  SWITCH_CREATE = new Set(["-c", "--create", "-C", "--force-create", "--orphan"]);
+  CHECKOUT_CREATE = new Set(["-b", "-B", "--orphan"]);
+  WORKTREE_CREATE = new Set(["-b", "-B"]);
+  BRANCH_NO_CREATE = new Set(["-d", "-D", "--delete", "-l", "--list", "-a", "--all", "-r", "--remotes", "--show-current"].concat(["-v", "-vv", "--verbose", "--contains", "--no-contains", "--merged", "--no-merged"]).concat(["--points-at", "--sort", "--format", "--column", "--no-column", "-u"]).concat(["--set-upstream-to", "--unset-upstream", "--edit-description", "-i", "--ignore-case"]));
+  BRANCH_RENAME = new Set(["-m", "-M", "--move", "-c", "-C", "--copy"]);
+  WORKTREE_VALUES = new Set(["--reason"]);
+});
+
+// packages/workit-core/src/hooks/policy.ts
+var shellPolicy = (cwd, command, dialect = "posix") => {
+  const policy = shellBranchPolicyViolation(cwd, command, dialect);
+  return policy && !policy.ok ? { kind: "deny", reason: `branch_policy_denied: ${policy.error}`, unblock: null } : { kind: "none" };
+};
+var init_policy = __esm(() => {
+  init_route_intent();
+});
+
+// packages/workit-core/src/hooks/write-gate.ts
+import { realpathSync as realpathSync5 } from "node:fs";
+import path21 from "node:path";
+function writeGate(cwd, paths) {
+  try {
+    const gate = gateFor(cwd);
+    if (!gate || gate.blockers.length === 0)
+      return NONE3;
+    if (paths?.length && paths.every((file) => exempt(cwd, gate.root, file, gate.plans)))
+      return NONE3;
+    const reasons = gate.blockers.map((item) => `${item.ruleId}: ${item.reason}`).join("; ");
+    return {
+      kind: "deny",
+      reason: `workit before-write gate: ${reasons}. Markdown, docs/, plans/ and files outside the checkout stay writable.`,
+      unblock: gate.blockers[0].reason
+    };
+  } catch {
+    return NONE3;
+  }
+}
+var NONE3, CASE_INSENSITIVE, canonical2 = (file) => {
+  let rest = "";
+  for (let dir = path21.resolve(file);; dir = path21.dirname(dir)) {
+    try {
+      return path21.join(realpathSync5(dir), rest);
+    } catch {
+      if (path21.dirname(dir) === dir)
+        return path21.resolve(file);
+      rest = rest ? path21.join(path21.basename(dir), rest) : path21.basename(dir);
+    }
+  }
+}, exempt = (cwd, root, file, plans) => {
+  const fold = (value) => CASE_INSENSITIVE ? value.toLowerCase() : value;
+  const relative = path21.relative(fold(canonical2(root)), fold(canonical2(path21.resolve(cwd, file))));
+  if (relative.startsWith("..") || path21.isAbsolute(relative))
+    return true;
+  const posix = relative.split(path21.sep).join("/");
+  const segments = posix.split("/");
+  return /\.mdx?$/i.test(posix) || segments[0] === "docs" || segments.includes("plans") || [...plans].some((plan) => fold(plan) === posix);
+}, PREFIXES3, operands = (words) => words.filter((item) => !item.startsWith("-")), editsOf = (input) => {
+  let words = input;
+  while (words.length && (PREFIXES3.has(words[0]) || /^\w+=/.test(words[0])))
+    words = words.slice(1);
+  const [verb, ...args] = words;
+  const name = (verb?.split(/[\\/]/).at(-1) ?? "").toLowerCase();
+  if (!name || name === "workit" || name === "npx" && args.some((item) => /workit/.test(item)))
+    return [];
+  switch (name) {
+    case "touch":
+    case "mkdir":
+    case "rm":
+    case "rmdir":
+    case "tee":
+    case "mv":
+    case "truncate":
+      return operands(args);
+    case "cp":
+    case "ln":
+    case "install": {
+      const target = args.indexOf("-t");
+      if (target >= 0)
+        return args[target + 1] ? [args[target + 1]] : null;
+      const last = operands(args).at(-1);
+      return last ? [last] : null;
+    }
+    case "dd":
+      return args.filter((item) => item.startsWith("of=")).map((item) => item.slice(3));
+    case "sed":
+    case "perl": {
+      if (!args.some((item) => /^-[a-zA-Z]*i|^--in-place/.test(item)))
+        return [];
+      const scripted = args.some((item) => item === "-e" || item === "-f");
+      const files = [];
+      for (let index = 0;index < args.length; index++) {
+        if (args[index] === "-e" || args[index] === "-f")
+          index++;
+        else if (!args[index].startsWith("-"))
+          files.push(args[index]);
+      }
+      return scripted ? files : files.slice(1);
+    }
+    case "patch":
+      return null;
+    case "set-content":
+    case "add-content":
+    case "out-file":
+    case "new-item":
+    case "ni":
+    case "remove-item":
+    case "del":
+    case "copy-item":
+    case "move-item": {
+      const flag = args.findIndex((item) => /^-(?:path|filepath|literalpath|destination)$/i.test(item));
+      if (flag >= 0)
+        return args[flag + 1] ? [args[flag + 1]] : null;
+      const files = operands(args);
+      if (name === "move-item")
+        return files.length ? files : null;
+      const file = name === "copy-item" ? files.at(-1) : files[0];
+      return file ? [file] : null;
+    }
+    case "git": {
+      const sub = operands(args)[0];
+      if (sub === "apply")
+        return null;
+      if (sub === "restore" || sub === "mv" || sub === "rm")
+        return operands(args).slice(1);
+      if (sub === "checkout" && args.includes("--"))
+        return args.slice(args.indexOf("--") + 1);
+      return [];
+    }
+    default:
+      return [];
+  }
+}, shellWrites = (command) => {
+  const targets = [];
+  let unknown = false;
+  for (const segment of segmentsOf(command)) {
+    targets.push(...segment.redirects.filter((item) => !/^\/dev\/(?:null|stdout|stderr|tty)$/.test(item)));
+    const edits = editsOf(segment.words);
+    if (edits === null)
+      unknown = true;
+    else
+      targets.push(...edits);
+  }
+  if (!unknown && targets.length === 0)
+    return { writes: false, targets: null };
+  return { writes: true, targets: unknown ? null : targets };
+}, cache2, planKeyOf = (root, plans) => [...plans].map((file) => fileSignature(path21.resolve(root, file)) ?? "-").join("\x00"), gateFor = (cwd) => {
+  const store = new TaskStore(cwd);
+  const listed = store.listTaskIndex();
+  if (!listed.ok)
+    return null;
+  const key = store.currentKey();
+  if (!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];
+  if (!entry)
+    return { blockers: [], root: store.root, plans: new Set };
+  const ledger = ledgerPath(store.root);
+  const cacheKey = `${entry.id}\x00${entry.revision}\x00${ledger.ok && fileSignature(ledger.value) || "-"}`;
+  const hit = cache2.get(store.root);
+  if (hit && hit.key === cacheKey && hit.planKey === planKeyOf(store.root, hit.plans))
+    return hit;
+  const task = store.readTask(entry.id);
+  if (!task.ok)
+    return null;
+  const workspace = store.readWorkspace();
+  const plans = new Set((latestJudgment(task.data)?.refs ?? []).flatMap((ref) => ref.kind === "file" ? [ref.path] : []));
+  const blockers = writeBlockers(task.data, store.root).filter((blocker) => {
+    const requirement = task.data.policy?.requirements.find((item) => item.ruleId === blocker.ruleId && item.before === "write");
+    return !(requirement?.acceptanceAllowed && workspace.ok && workspace.data && applicableDecision(task.data, workspace.data, requirement, store.root).length > 0);
+  });
+  const gate = {
+    blockers,
+    root: store.root,
+    plans,
+    key: cacheKey,
+    planKey: planKeyOf(store.root, plans)
+  };
+  cache2.set(store.root, gate);
+  if (cache2.size > 32)
+    cache2.delete(cache2.keys().next().value);
+  return gate;
+};
+var init_write_gate = __esm(() => {
+  init_task_store();
+  init_derive();
+  init_task_evaluation();
+  init_ledger();
+  NONE3 = { kind: "none" };
+  CASE_INSENSITIVE = process.platform === "darwin" || process.platform === "win32";
+  PREFIXES3 = new Set(["sudo", "command", "env", "nohup", "time", "exec", "xargs"]);
+  cache2 = new Map;
+});
+
+// packages/workit-core/src/hooks/stop.ts
+import { spawnSync as spawnSync13 } from "node:child_process";
 function stopObligation(input, descriptor) {
   try {
     const session = input.session.id;
@@ -18631,7 +18904,7 @@ var NONE4, QUESTION, OFFER, YES_NO, LIST_ITEM, asksUser = (message) => {
 `);
   return QUESTION.test(tail) || OFFER.test(tail) || YES_NO.test(tail);
 }, short = (sha) => (sha ?? "?").slice(0, 12), gitList = (cwd, args) => {
-  const run = spawnSync12("git", args, {
+  const run = spawnSync13("git", args, {
     cwd,
     encoding: "utf8",
     timeout: 3000,
@@ -18941,10 +19214,10 @@ var init_skill_nudge = __esm(() => {
 });
 
 // packages/workit-core/src/hooks/hosts/fields.ts
-import { existsSync as existsSync6, realpathSync as realpathSync6, statSync as statSync2 } from "node:fs";
-import path21 from "node:path";
+import { existsSync as existsSync7, realpathSync as realpathSync6, statSync as statSync2 } from "node:fs";
+import path22 from "node:path";
 var isRecord4 = (value) => value !== null && typeof value === "object" && !Array.isArray(value), nonEmpty2 = (value) => typeof value === "string" && value.trim() !== "", optionalText = (value) => typeof value === "string" ? value : null, existingDirectory = (value) => {
-  if (!nonEmpty2(value) || !path21.isAbsolute(value) || !existsSync6(value))
+  if (!nonEmpty2(value) || !path22.isAbsolute(value) || !existsSync7(value))
     return null;
   try {
     return statSync2(value).isDirectory() ? realpathSync6(value) : null;
@@ -19040,7 +19313,7 @@ function handleHook(input, deps) {
       if (skillRead)
         recordSkillLoad(input, skillRead, "read");
       const canDeny = usable2(descriptor.shellPolicy.deny);
-      const policy = canDeny ? shellPolicy(input.cwd, event.command) : NONE5;
+      const policy = canDeny ? shellPolicy(input.cwd, event.command, event.dialect) : NONE5;
       if (policy.kind !== "none")
         return policy;
       const postTool = usable2(descriptor.events["shell.post"].support);
@@ -19094,13 +19367,14 @@ var usable2 = (value) => value === "native" || value === "partial", NONE5, resen
   const role = workitRole(descriptor, event.agentType);
   const who = `${descriptor.label} subagent ${event.agentId} (${event.agentType})`;
   const isolated = descriptor.subagents.worktreeIsolation === "native" && (role === "implementer" || CLAUDE_WORKTREE.test(input.cwd));
+  const guide = role === "implementer" ? branchGuidance(input.cwd) : null;
   if (role === "implementer" && isolated)
-    return `Workit observed ${who} working in its own git worktree: it may edit and commit there, within its brief's scope. ${ISOLATED_GIT} Use a policy-compliant branch (e.g. feature/<slug>); branch policy hooks still deny protected or non-compliant branches. Never record a verdict on your own work. Never push, open a PR, or merge unless the brief asks for it.`;
+    return `Workit observed ${who} working in its own git worktree: it may edit and commit there, within its brief's scope. ${ISOLATED_GIT} Plain git is expected here, and the branch name is still policy-checked: a raw \`git switch -c\`, \`git checkout -b\`, \`git branch\` or \`git worktree add -b\` onto a protected or non-compliant name is denied, so use a policy-compliant branch.${guide ? ` ${guide}` : " (e.g. feature/<slug>)"} Never record a verdict on your own work. Never push, open a PR, or merge unless the brief asks for it.`;
   if (isolated)
     return `${ISOLATED_GIT}
 ${subagentStartText({ ...input, cwd: "" }, descriptor, event)}`;
   if (role === "implementer")
-    return `Workit observed ${who} as an implementer: it edits and commits only in its own git worktree (the lead makes one with \`workit fanout worktree create <slice>\`), never in the lead's checkout, within its brief's scope. Before the first commit, switch to a policy-compliant branch with \`workit git branch <branch> --base <base>\` (e.g. feature/<slug>); branch policy hooks still deny protected or non-compliant branches. Never record a verdict on your own work. Never push, open a PR, or merge unless the brief asks for it.`;
+    return `Workit observed ${who} as an implementer: it edits and commits only in its own git worktree (the lead makes one with \`workit fanout worktree create <slice>\`), never in the lead's checkout, within its brief's scope. Before the first commit, switch to a policy-compliant branch with \`workit git branch <branch> --base <base>\` (or \`--kind <kind> --slug <slug>\`, which picks the base); branch policy hooks still deny protected or non-compliant branches, raw git included.${guide ? ` ${guide}` : " (e.g. feature/<slug>)"} Never record a verdict on your own work. Never push, open a PR, or merge unless the brief asks for it.`;
   const readOnly = `Workit observed ${who} as read-only/agent-guided.`;
   if (role !== "judge" || !event.agentId)
     return readOnly;
@@ -19138,6 +19412,7 @@ ${subagentStartText({ ...input, cwd: "" }, descriptor, event)}`;
 };
 var init_handle = __esm(() => {
   init_context();
+  init_branch();
   init_host_session();
   init_policy();
   init_raw_git();
@@ -19682,7 +19957,7 @@ var init_codex = __esm(() => {
 
 // packages/workit-core/src/hooks/hosts/cursor.ts
 import fs17 from "node:fs";
-import path22 from "node:path";
+import path23 from "node:path";
 var undocumented, none, CURSOR_DESCRIPTOR, EVENTS3, parseCursorHookInput = (value) => {
   if (!isRecord4(value) || !Object.hasOwn(EVENTS3, String(value.hook_event_name)))
     return { ok: false, error: "hook_event_name is required" };
@@ -19763,7 +20038,7 @@ var undocumented, none, CURSOR_DESCRIPTOR, EVENTS3, parseCursorHookInput = (valu
       };
   }
 }, TRANSCRIPT_TAIL_BYTES, lastAssistantText = (file) => {
-  if (!file || !path22.isAbsolute(file))
+  if (!file || !path23.isAbsolute(file))
     return null;
   try {
     const size = fs17.statSync(file).size;
@@ -19799,7 +20074,7 @@ var undocumented, none, CURSOR_DESCRIPTOR, EVENTS3, parseCursorHookInput = (valu
   } catch {
     return null;
   }
-}, within = (root, dir) => dir === root || dir.startsWith(root.endsWith(path22.sep) ? root : `${root}${path22.sep}`), hookCwd = (input) => {
+}, within = (root, dir) => dir === root || dir.startsWith(root.endsWith(path23.sep) ? root : `${root}${path23.sep}`), hookCwd = (input) => {
   const cwd = existingDirectory(input.cwd);
   if (cwd && input.hook_event_name === "beforeShellExecution")
     return cwd;