@brainervirus/workit-cursor 8.24.0 → 8.25.0

package/dist/workit-hook.js

@@ -6903,6 +6903,26 @@ function resolveRef(cwd, ref) {
     return null;
   return line(git(cwd, ["rev-parse", "--verify", "-q", `${ref}^{commit}`]));
 }
+function originHeadRef(cwd) {
+  return line(git(cwd, ["symbolic-ref", "-q", "--short", "refs/remotes/origin/HEAD"]));
+}
+function ownChangeDrift(cwd, range) {
+  const before = diffRaw(cwd, range.fromFork, range.from);
+  const after = diffRaw(cwd, range.toFork, range.to);
+  if (!before || !after)
+    return null;
+  const judged = new Map(before.map((entry) => [entry.path, entry]));
+  const current = new Map(after.map((entry) => [entry.path, entry]));
+  const same = (a, b) => a !== undefined && b !== undefined && a.oldMode === b.oldMode && a.oldBlob === b.oldBlob && a.newMode === b.newMode && a.newBlob === b.newBlob;
+  return [...new Set([...judged.keys(), ...current.keys()])].filter((file) => !same(judged.get(file), current.get(file))).toSorted();
+}
+function sameOwnChange(cwd, range) {
+  const fromFork = mergeBase(cwd, range.fromBase, range.from);
+  const toFork = mergeBase(cwd, range.toBase, range.to);
+  if (!fromFork || !toFork)
+    return false;
+  return ownChangeDrift(cwd, { from: range.from, to: range.to, fromFork, toFork })?.length === 0;
+}
 var LANE_DIFF = [
   "-c",
   "core.quotePath=false",
@@ -7045,7 +7065,7 @@ function pushRemoteName(cwd, branch) {
 import { spawnSync as spawnSync8 } from "node:child_process";
 import { createHash as createHash9, randomBytes as randomBytes2 } from "node:crypto";
 import fs7 from "node:fs";
-import path9 from "node:path";
+import path10 from "node:path";
 
 // packages/workit-core/src/core/store-lock.ts
 import { spawnSync as spawnSync3 } from "node:child_process";
@@ -7471,6 +7491,10 @@ var clearAbandonedReclaimGuard = (lockPath, nowMs = Date.now()) => {
   }
 };
 
+// packages/workit-core/src/core/policy/lane.ts
+import { existsSync as existsSync2, readFileSync as readFileSync3 } from "node:fs";
+import path6 from "node:path";
+
 // packages/workit-core/src/core/vcs-config.ts
 import fs4 from "node:fs";
 import path5 from "node:path";
@@ -8790,2058 +8814,2165 @@ function vcsConfig(mode, cwd, options = {}) {
   return out;
 }
 
-// packages/workit-core/src/host-session.ts
-import { createHash as createHash7, randomBytes, timingSafeEqual } from "node:crypto";
-import fs5 from "node:fs";
-import path7 from "node:path";
-
-// packages/workit-core/src/core/branch.ts
-import { createHash as createHash6 } from "node:crypto";
-var withReleaseTracks = (workspaceRoot, policy) => {
-  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);
-    }
+// packages/workit-core/src/git/default-base.ts
+var safeRef = (value) => value.length > 0 && !value.startsWith("-");
+var trackTrunk = (cwd) => {
+  try {
+    const resolved = vcsConfig("resolve", cwd);
+    if (resolved.ok === false || !resolved.releaseTrack || resolved.releaseTrack.blocking)
+      return null;
+    const target = String(resolved.defaultTargetBranch ?? "").trim();
+    return target && safeRef(target) ? target : null;
+  } catch {
+    return null;
   }
-  return {
-    ...policy,
-    allowed,
-    protected: new Set([
-      ...policy.protected,
-      ...[...trackBranches(read.tracks), ...read.protectedBranches].map((name) => name.toLowerCase())
-    ])
-  };
 };
-function effectiveWorkspacePolicy(workspaceRoot, kind, profileName) {
-  const selected = resolveRuntimeWorkspacePolicy(workspaceRoot, kind, profileName?.trim() || process.env.WORKFLOW_PROFILE?.trim() || undefined);
-  const config = readConfig();
-  return kind === "branch" ? {
-    branchPolicy: withReleaseTracks(workspaceRoot, resolveBranchPolicy(config, selected.policy ? { branchPolicy: selected.policy } : null, () => repoBranchPreset(workspaceRoot))),
-    provenance: { branchPolicy: selected.source }
-  } : {
-    commitPolicy: resolveCommitPolicy(config, selected.policy ? { commitPolicy: selected.policy } : null),
-    provenance: { commitPolicy: selected.source }
-  };
+function defaultBase(cwd) {
+  const trunk = trackTrunk(cwd);
+  if (trunk) {
+    for (const candidate of [`origin/${trunk}`, trunk])
+      if (resolveRef(cwd, candidate))
+        return candidate;
+  }
+  const originHead = originHeadRef(cwd);
+  if (originHead && resolveRef(cwd, originHead))
+    return originHead;
+  for (const candidate of [
+    "origin/main",
+    "origin/master",
+    "main",
+    "master",
+    "origin/develop",
+    "develop"
+  ])
+    if (resolveRef(cwd, candidate))
+      return candidate;
+  return null;
 }
-var 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"
-};
-var allowedKinds = (allowed) => [
-  ...new Set(allowed.map((pattern) => /^\^([\w.-]+)\\?\/\.\*\$$/u.exec(pattern.source)?.[1]?.toLowerCase()).filter((kind) => Boolean(kind)))
-];
-var 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;
-    }
+
+// packages/workit-core/src/core/policy/attributes.ts
+function patternRegex(dir, pattern) {
+  if (!pattern || pattern.endsWith("/") || pattern.startsWith('"') || pattern.startsWith("!"))
+    return null;
+  const anchored = pattern.includes("/");
+  const body = pattern.replace(/^\//u, "");
+  let source = "";
+  for (let index = 0;index < body.length; index += 1) {
+    const char = body[index];
+    if (char === "*" && body[index + 1] === "*") {
+      const slash = body[index + 2] === "/";
+      source += slash ? "(?:.*/)?" : ".*";
+      index += slash ? 2 : 1;
+    } else if (char === "*")
+      source += "[^/]*";
+    else if (char === "?")
+      source += "[^/]";
+    else if (char === "[") {
+      const end = body.indexOf("]", index + 2);
+      if (end < 0)
+        return null;
+      const set = body.slice(index + 1, end).replace(/^!/u, "^").replace(/\\/gu, "\\\\");
+      source += `[${set}]`;
+      index = end;
+    } else if (char === "\\" && index + 1 < body.length) {
+      source += body[index + 1].replace(/[.*+?^${}()|[\]\\/]/gu, "\\$&");
+      index += 1;
+    } else
+      source += char.replace(/[.*+?^${}()|[\]\\/]/gu, "\\$&");
   }
-  return row[b.length];
-};
-var suggestBranchName = (name, kinds) => {
-  if (!kinds.length)
+  const prefix = dir ? `${dir.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&")}/` : "";
+  try {
+    return new RegExp(anchored ? `^${prefix}${source}$` : `^${prefix}(?:.*/)?${source}$`, "u");
+  } catch {
     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}`;
-};
-var kindList = (kinds) => kinds.map((kind) => `${kind}/`).join(", ");
-var aliasNote = (kinds) => {
-  const notes = [
-    ["fix", "bugfix"],
-    ["chore", "feature"]
-  ].filter(([, kind]) => kinds.includes(kind)).map(([alias, kind]) => `${alias}/ is ${kind}/`);
-  return notes.length ? ` (${notes.join(", ")})` : "";
-};
-var 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 = 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",
-      source,
-      attempted: name,
-      correction,
-      error: `protected_ref: branch ${JSON.stringify(name)} is protected by ${source}; ${correction}`
-    };
   }
-  if (!policy.allowed.some((pattern) => pattern.test(name))) {
-    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",
-      source,
-      attempted: name,
-      correction,
-      error: `allowed_pattern: branch ${JSON.stringify(name)} violates ${source} policy; ${correction}`
-    };
+}
+function rulesOf(dir, text) {
+  const out = [];
+  for (const raw of text.split(`
+`)) {
+    const line = raw.trim();
+    if (!line || line.startsWith("#") || line.startsWith("[attr]"))
+      continue;
+    const [pattern, ...attributes] = line.split(/\s+/u);
+    let generated = null;
+    for (const attribute of attributes) {
+      if (attribute === "linguist-generated" || attribute === "linguist-generated=true")
+        generated = true;
+      else if (attribute === "-linguist-generated" || attribute === "!linguist-generated" || attribute.startsWith("linguist-generated="))
+        generated = false;
+    }
+    if (generated === null)
+      continue;
+    const regex = patternRegex(dir, pattern);
+    if (regex)
+      out.push({ regex, generated });
   }
-  return { ok: true };
-};
-var branchPolicySnapshotFor = (workspaceRoot) => {
-  const resolved = effectiveWorkspacePolicy(workspaceRoot, "branch");
-  const branchPolicy = resolved.branchPolicy;
-  const source = resolved.provenance.branchPolicy;
-  const allowed = branchPolicy.allowed.map((pattern) => `${pattern.source}/${pattern.flags}`).toSorted();
-  const protectedRefs = [...branchPolicy.protected].map((name) => name.toLowerCase()).toSorted();
-  const fingerprint = createHash6("sha256").update(JSON.stringify({ allowed, protectedRefs, source })).digest("hex");
-  return {
-    branchPolicy,
-    namePolicy: { allowed: branchPolicy.allowed, protected: branchPolicy.protected },
-    source,
-    fingerprint
-  };
-};
-var validateBranchNameFor = (workspaceRoot, name) => {
-  try {
-    const resolved = branchPolicySnapshotFor(workspaceRoot);
-    return validateBranchNamePolicy(name, resolved.namePolicy, resolved.source);
-  } catch (error) {
-    const correction = "repair or select a valid workspace policy before creating a branch";
+  return out;
+}
+function generatedByAttributes(files, paths) {
+  const rules = [...files].map(([file, text]) => {
+    const dir = file.includes("/") ? file.slice(0, file.lastIndexOf("/")) : "";
     return {
-      ok: false,
-      rule: "policy_unavailable",
-      source: "workspaces.json",
-      attempted: name,
-      correction,
-      error: `policy_unavailable: cannot validate branch ${JSON.stringify(name)} because ${error instanceof Error ? error.message : String(error)}; ${correction}`
+      depth: dir ? dir.split("/").length : 0,
+      rules: rulesOf(dir, text)
     };
+  }).toSorted((left, right) => left.depth - right.depth).flatMap((entry) => entry.rules);
+  const out = new Set;
+  for (const file of paths) {
+    const last = rules.findLast((rule) => rule.regex.test(file));
+    if (last?.generated)
+      out.add(file);
   }
-};
-var resolveBranchPolicyFor = (workspaceRoot, profileName) => effectiveWorkspacePolicy(workspaceRoot, "branch", profileName).branchPolicy;
-var 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;
-  }
-};
-var 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 };
-  }
-};
-var releaseBranch = (cwd, branch) => releaseBranchesOf(cwd).branches.some((name) => name.toLowerCase() === branch.toLowerCase());
-var 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;
-  }
-};
-var globOf = (pattern) => pattern.source.replace(/^\^|\$$/gu, "").replaceAll(".*", "*").replace(/\\(.)/gu, "$1");
-var policy = (root) => resolveBranchPolicyFor(root);
-var isProtected = (root, name) => policy(root).protected.has(name.toLowerCase());
-var isProtectedTarget = (root, name) => {
-  try {
-    return isProtected(root, name);
-  } catch {
-    return true;
-  }
-};
+  return out;
+}
 
-// packages/workit-core/src/core/logger.ts
-import os3 from "node:os";
-import path6 from "node:path";
-var SENSITIVE_WORDS = new Set([
-  "token",
-  "secret",
-  "password",
-  "passwd",
-  "authorization",
-  "credential",
-  "credentials",
-  "cookie",
-  "api",
-  "apikey",
-  "apitoken",
-  "accesstoken",
-  "clientsecret",
-  "refreshtoken",
-  "key",
-  "bearer",
-  "prompt",
-  "message",
-  "messages",
-  "content",
-  "body",
-  "args",
-  "argument",
-  "result",
-  "results",
-  "output",
-  "issue",
-  "description",
-  "summary",
-  "payload",
-  "script",
-  "command",
-  "text",
-  "query"
+// packages/workit-core/src/core/policy/substance.ts
+var SLASH_BLOCK = [["/*", "*/"]];
+var C_LIKE = { line: ["//"], block: SLASH_BLOCK, quotes: `"'` };
+var SYNTAXES = Object.fromEntries([
+  ...["ts", "mts", "cts", "js", "mjs", "cjs"].map((ext) => [ext, { ...C_LIKE, js: true }]),
+  ...["java", "kt", "kts", "scala", "swift", "dart", "groovy"].map((ext) => [
+    ext,
+    { ...C_LIKE, triple: true }
+  ]),
+  ["go", { ...C_LIKE, rawBacktick: true }],
+  ...["css", "scss", "less"].map((ext) => [
+    ext,
+    { line: [], block: SLASH_BLOCK, quotes: `"'`, cssUrl: true }
+  ]),
+  ...["py", "pyi"].map((ext) => [
+    ext,
+    { line: ["#"], block: [], quotes: `"'`, triple: true, indented: true, fstring: true }
+  ]),
+  ["toml", { line: ["#"], block: [], quotes: `"`, literal: "'", triple: true }],
+  ...["html", "htm", "xml", "svg", "xhtml"].map((ext) => [
+    ext,
+    { line: [], block: [["<!--", "-->"]], quotes: "", indented: true }
+  ])
 ]);
-var STACK_WORDS = new Set(["stack", "stacktrace", "trace"]);
-var escapeRegExp2 = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-var resolveStateDir = () => {
-  const override = process.env.WORKFLOW_TOOLKIT_STATE;
-  if (override)
-    return override;
-  const home = os3.homedir();
-  if (process.env.XDG_STATE_HOME)
-    return path6.join(process.env.XDG_STATE_HOME, "workit");
-  switch (os3.platform()) {
-    case "darwin":
-      return path6.join(home, "Library", "Application Support", "workit");
-    case "win32":
-      return path6.join(process.env.LOCALAPPDATA ?? path6.join(home, "AppData", "Local"), "workit");
-    default:
-      return path6.join(process.env.HOME ?? home, ".local", "state", "workit");
-  }
+var DIRECTIVE = /@ts-|eslint|prettier|biome|oxlint|istanbul|\bc8\b|\bv8\b|@jsx|@flow|@vite|webpack|__PURE__|__NO_SIDE_EFFECTS__|source(?:Mapping)?URL|^\/\s*<|go:|\+build|nolint|noqa|type:|pyright|mypy|pylint|pragma|coding[:=]|fmt:|NOSONAR|@license|@preserve|@refresh|environment|language=|cython|ruff|isort|deno-|@vitest|@jest|swiftlint|ktlint|checkstyle|suppress|nullable|#(?:end)?region/iu;
+var extensionOf = (file) => {
+  const name = file.slice(file.lastIndexOf("/") + 1);
+  const dot = name.lastIndexOf(".");
+  return dot > 0 ? name.slice(dot + 1).toLowerCase() : "";
 };
-var homePattern = new RegExp(`${escapeRegExp2(os3.homedir())}(?=[/\\\\]|$)|\\$HOME(?=[/\\\\]|$)`, "g");
-
-// packages/workit-core/src/host-session.ts
-var HOST_SESSION_VARS = [
-  ["OPENCODE_SESSION_ID", () => "opencode"],
-  ["PI_SESSION_ID", () => "pi"],
-  [
-    "CODEX_THREAD_ID",
-    (env) => env.CODEX_INTERNAL_ORIGINATOR_OVERRIDE === "Codex Desktop" || env.CODEX_ELECTRON_RESOURCES_PATH ? "codex_desktop" : "codex_cli"
-  ]
-];
-var family = (host) => host?.replace(/_(?:cli|desktop)$/, "") ?? null;
-function hostSessionFromEnv(env) {
-  const value = (key) => env[key]?.trim() || null;
-  let inner = null;
-  for (const [key, host] of HOST_SESSION_VARS) {
-    const session = value(key);
-    if (session) {
-      inner = { host: host(env), session };
-      break;
-    }
-  }
-  const declared = value("WORKIT_HOST");
-  if (env.WORKIT_SESSION_ID !== undefined) {
-    const inherited = inner !== null && declared !== null && family(declared) !== family(inner.host);
-    if (!inherited)
-      return { host: declared, session: value("WORKIT_SESSION_ID") };
-  }
-  return inner ? { host: inner.host, session: inner.session } : { host: declared, session: null };
+var CI_PATH = /^\.github\/|(?:^|\/)(?:\.gitlab-ci\.ya?ml|Jenkinsfile|azure-pipelines\.ya?ml|\.pre-commit-config\.ya?ml|\.circleci\/.*)$/u;
+var syntaxOf = (file) => CI_PATH.test(file) ? null : SYNTAXES[extensionOf(file)] ?? null;
+var SPACE = /[ \t\r\f\v]/u;
+var WORD = /[\w$]/u;
+var NO_SPACE_AFTER = "([{,;";
+var NO_SPACE_BEFORE = ")]},;";
+var REGEX_AFTER = "(,=:[!&|?{};+-*%<>~^";
+var REGEX_KEYWORDS = new Set([
+  "return",
+  "typeof",
+  "instanceof",
+  "case",
+  "do",
+  "else",
+  "in",
+  "of",
+  "new",
+  "delete",
+  "void",
+  "throw",
+  "yield",
+  "await"
+]);
+function substanceOf(file, text) {
+  const syntax = syntaxOf(file);
+  if (!syntax)
+    return plainSubstance(text);
+  const markup = syntax.block.some(([open]) => open === "<!--");
+  if (markup && (/<(?:script|style)\b|<!\[CDATA\[|<\?/iu.test(text) || /[^>\s][ \t]*<!--/u.test(text)))
+    return plainSubstance(text);
+  return lex(syntax, text);
 }
-var ISSUED_PER_LEAD = 64;
-var ISSUED_SESSIONS_MARKER = "workit-issued-sessions/3";
-var hash = (value) => createHash7("sha256").update(value).digest("hex").slice(0, 32);
-var userIssuedRoot = () => path7.join(resolveStateDir(), "issued");
-var userTokenRoot = () => path7.join(resolveStateDir(), "issued-tokens");
-function migrateRepoIssued(cwd) {
-  if (cwd === undefined)
-    return;
-  let old;
-  try {
-    const location = resolveStore(cwd);
-    if (location instanceof Error)
-      return;
-    old = path7.join(location.dir, "hooks", "issued");
-    if (!fs5.existsSync(old))
-      return;
-  } catch {
-    return;
-  }
-  for (const lead of safeList(old)) {
-    try {
-      const from = path7.join(old, lead);
-      if (!fs5.statSync(from).isDirectory())
-        continue;
-      const to = path7.join(userIssuedRoot(), lead);
-      fs5.mkdirSync(to, { recursive: true, mode: 448 });
-      for (const id of fs5.readdirSync(from)) {
-        try {
-          fs5.copyFileSync(path7.join(from, id), path7.join(to, id), fs5.constants.COPYFILE_EXCL);
-        } catch (error) {
-          if (error.code !== "EEXIST")
-            throw error;
-        }
-        fs5.rmSync(path7.join(from, id), { force: true });
-      }
-      removeIfEmpty(from);
-    } catch {}
-  }
-  removeIfEmpty(old);
+function plainSubstance(text) {
+  return text.split(`
+`).map((line) => line.replace(/[ \t\r\f\v]+$/u, "")).filter(Boolean).join(`
+`);
 }
-var safeList = (dir) => {
-  try {
-    return fs5.readdirSync(dir);
-  } catch {
-    return [];
+function lex(syntax, text) {
+  const collapse = !syntax.indented;
+  let out = "";
+  let lineStart = 0;
+  let kept = 0;
+  let pendingSpace = false;
+  const frames = [{ kind: "code", braces: 0 }];
+  let index = 0;
+  if (text.startsWith("#!")) {
+    const end = text.indexOf(`
+`);
+    out = end < 0 ? text : text.slice(0, end);
+    kept = out.length;
+    index = end < 0 ? text.length : end;
   }
-};
-var removeIfEmpty = (dir) => {
-  try {
-    fs5.rmdirSync(dir);
-  } catch {}
-};
-var tokenHash = (token) => createHash7("sha256").update(token).digest("hex");
-function recordIssuedSession(cwd, lead, issued) {
-  const token = randomBytes(18).toString("hex");
+  const emitCode = (chunk) => {
+    if (collapse && pendingSpace && out.length > lineStart) {
+      const before = out[out.length - 1];
+      if (!NO_SPACE_AFTER.includes(before) && !NO_SPACE_BEFORE.includes(chunk[0]))
+        out += " ";
+    }
+    pendingSpace = false;
+    out += chunk;
+  };
+  const emitVerbatim = (chunk) => {
+    emitCode(chunk);
+    kept = out.length;
+  };
+  const newline = () => {
+    if (!collapse) {
+      let end = out.length;
+      while (end > Math.max(lineStart, kept) && SPACE.test(out[end - 1]))
+        end -= 1;
+      out = out.slice(0, end);
+    }
+    pendingSpace = false;
+    if (out.length > lineStart) {
+      out += `
+`;
+      lineStart = out.length;
+    }
+  };
+  const regexAllowed = () => {
+    let end = out.length;
+    while (end > 0 && /\s/u.test(out[end - 1]))
+      end -= 1;
+    if (end === 0 || REGEX_AFTER.includes(out[end - 1]))
+      return true;
+    let start = end;
+    while (start > 0 && WORD.test(out[start - 1]))
+      start -= 1;
+    return REGEX_KEYWORDS.has(out.slice(start, end));
+  };
+  const scanString = (quote, escapes, multiline) => {
+    const prefix = text.slice(Math.max(0, index - 2), index).match(/[a-z]*$/iu)?.[0] ?? "";
+    const fstring = syntax.fstring === true && /f/iu.test(prefix);
+    let end = index + quote.length;
+    while (end < text.length) {
+      const char = text[end];
+      if (escapes && char === "\\") {
+        end += 2;
+        continue;
+      }
+      if (text.startsWith(quote, end)) {
+        if (fstring && unbalanced(text.slice(index + quote.length, end)))
+          return false;
+        emitVerbatim(text.slice(index, end + quote.length));
+        index = end + quote.length;
+        return true;
+      }
+      if (char === `
+` && !multiline)
+        return false;
+      end += 1;
+    }
+    return false;
+  };
+  while (index < text.length) {
+    const frame = frames[frames.length - 1];
+    const char = text[index];
+    if (frame.kind === "template") {
+      if (char === "\\") {
+        emitVerbatim(text.slice(index, index + 2));
+        index += 2;
+      } else if (char === "`") {
+        emitVerbatim(char);
+        frames.pop();
+        index += 1;
+      } else if (text.startsWith("${", index)) {
+        emitVerbatim("${");
+        frames.push({ kind: "code", braces: 0 });
+        index += 2;
+      } else {
+        out += char;
+        kept = out.length;
+        index += 1;
+      }
+      continue;
+    }
+    if (char === `
+`) {
+      newline();
+      index += 1;
+      continue;
+    }
+    if (SPACE.test(char)) {
+      if (collapse)
+        pendingSpace = true;
+      else
+        out += char;
+      index += 1;
+      continue;
+    }
+    const lineOpener = syntax.line.find((opener) => text.startsWith(opener, index));
+    if (lineOpener) {
+      const end = text.indexOf(`
+`, index);
+      const comment = text.slice(index, end < 0 ? text.length : end);
+      if (DIRECTIVE.test(comment.slice(lineOpener.length)))
+        emitVerbatim(comment);
+      else
+        pendingSpace = true;
+      index = end < 0 ? text.length : end;
+      continue;
+    }
+    const block = syntax.block.find(([open]) => text.startsWith(open, index));
+    if (block) {
+      const end = text.indexOf(block[1], index + block[0].length);
+      if (end < 0)
+        return null;
+      const comment = text.slice(index, end + block[1].length);
+      if (DIRECTIVE.test(comment.slice(block[0].length, -block[1].length)))
+        emitVerbatim(comment);
+      else
+        pendingSpace = true;
+      if (comment.includes(`
+`))
+        newline();
+      index = end + block[1].length;
+      continue;
+    }
+    if (syntax.triple && (char === '"' || char === "'") && text.startsWith(char.repeat(3), index)) {
+      if (!scanString(char.repeat(3), !syntax.literal?.includes(char), true))
+        return null;
+      continue;
+    }
+    if (syntax.quotes.includes(char)) {
+      if (!scanString(char, true, Boolean(syntax.multiline)))
+        return null;
+      continue;
+    }
+    if (syntax.literal?.includes(char)) {
+      if (!scanString(char, false, false))
+        return null;
+      continue;
+    }
+    if (syntax.rawBacktick && char === "`") {
+      if (!scanString("`", false, true))
+        return null;
+      continue;
+    }
+    if (syntax.js && char === "`") {
+      emitVerbatim(char);
+      frames.push({ kind: "template" });
+      index += 1;
+      continue;
+    }
+    if (syntax.cssUrl && /^url\(\s*[^"')\s]/iu.test(text.slice(index, index + 64)))
+      return null;
+    if (syntax.js && char === "/" && !regexAllowed() && out.trimEnd().endsWith(")")) {
+      const lineEnd = text.indexOf(`
+`, index);
+      if (text.slice(index + 1, lineEnd < 0 ? text.length : lineEnd).includes("/"))
+        return null;
+    }
+    if (syntax.js && char === "/" && regexAllowed()) {
+      let end = index + 1;
+      let inClass = false;
+      while (end < text.length && (inClass || text[end] !== "/")) {
+        if (text[end] === `
+`)
+          return null;
+        if (text[end] === "\\")
+          end += 1;
+        else if (text[end] === "[")
+          inClass = true;
+        else if (text[end] === "]")
+          inClass = false;
+        end += 1;
+      }
+      if (end >= text.length)
+        return null;
+      emitVerbatim(text.slice(index, end + 1));
+      index = end + 1;
+      continue;
+    }
+    if (frames.length > 1 && frame.kind === "code") {
+      if (char === "{")
+        frame.braces += 1;
+      else if (char === "}") {
+        if (frame.braces === 0) {
+          emitVerbatim(char);
+          frames.pop();
+          index += 1;
+          continue;
+        }
+        frame.braces -= 1;
+      }
+    }
+    emitCode(char);
+    index += 1;
+  }
+  if (frames.length !== 1)
+    return null;
+  newline();
+  return out;
+}
+function unbalanced(body) {
+  let depth = 0;
+  for (const part of body.replaceAll("{{", "").replaceAll("}}", "")) {
+    if (part === "{")
+      depth += 1;
+    else if (part === "}")
+      depth = Math.max(0, depth - 1);
+  }
+  return depth > 0;
+}
+function hasOpaqueLineBreak(text) {
+  return /\r(?!\n)|[\u2028\u2029]/u.test(text);
+}
+var decoder = new TextDecoder("utf-8", { fatal: true });
+function textOf(bytes) {
+  if (bytes.includes(0))
+    return null;
   try {
-    migrateRepoIssued(cwd);
-    const own = hash(issued);
-    const tokens = path7.join(userTokenRoot(), hash(lead));
-    fs5.mkdirSync(tokens, { recursive: true, mode: 448 });
-    fs5.writeFileSync(path7.join(tokens, own), `${tokenHash(token)}
-`, { mode: 384, flag: "wx" });
-    const dir = path7.join(userIssuedRoot(), hash(lead));
-    fs5.mkdirSync(dir, { recursive: true, mode: 448 });
-    fs5.writeFileSync(path7.join(dir, own), `${ISSUED_SESSIONS_MARKER}
-`, { mode: 384 });
-    pruneIssued(dir, own, tokens);
-    return token;
+    return decoder.decode(bytes);
   } catch {
     return null;
   }
 }
-function judgeBranch(cwd) {
-  const branch = currentBranch(cwd);
-  return branch && !isProtectedTarget(cwd, branch) ? branch : null;
+function cosmeticChange(file, before, after) {
+  const left = textOf(before);
+  const right = textOf(after);
+  if (left === null || right === null)
+    return false;
+  if (hasOpaqueLineBreak(left) || hasOpaqueLineBreak(right))
+    return false;
+  const a = substanceOf(file, left);
+  return a !== null && a === substanceOf(file, right);
 }
-function verdictCommand(options) {
-  const kind = options.judge === "verifier" ? "<live|unit>" : options.judge === "reviewer" ? "review" : "<live|unit|review>";
-  return [
-    "workit ledger verdict <verified|failed|blocked>",
-    `--kind ${kind}`,
-    `--branch ${options.branch ?? "<branch>"}`,
-    options.session ? `--session ${options.session}` : null,
-    options.token ? `--token=${options.token}` : null,
-    '--how "<what you ran and saw>"'
-  ].filter(Boolean).join(" ");
+
+// packages/workit-core/src/core/policy/lane.ts
+var LANE_THRESHOLDS = {
+  selfMaxLines: 100,
+  selfMaxFiles: 5,
+  fullMinLines: 500
+};
+var RISK_TOKENS = new Set([
+  "auth",
+  "authn",
+  "authz",
+  "oauth",
+  "security",
+  "permission",
+  "permissions",
+  "secret",
+  "secrets",
+  "crypto",
+  "gate",
+  "gates",
+  "policy",
+  "policies",
+  "hook",
+  "hooks",
+  "husky",
+  "lefthook",
+  "release",
+  "releases",
+  "migration",
+  "migrations",
+  "migrate",
+  "workflows"
+]);
+var RISK_FILES = new Set([
+  ".gitlab-ci.yml",
+  "Jenkinsfile",
+  "azure-pipelines.yml",
+  ".pre-commit-config.yaml",
+  ".workit/risk-paths"
+]);
+var RISK_NAMES = new Set([".gitattributes"]);
+var RISK_PATHS_FILE = ".workit/risk-paths";
+var LOCKFILES = new Set([
+  "bun.lock",
+  "bun.lockb",
+  "package-lock.json",
+  "npm-shrinkwrap.json",
+  "yarn.lock",
+  "pnpm-lock.yaml",
+  "Cargo.lock",
+  "go.sum",
+  "poetry.lock",
+  "uv.lock",
+  "Pipfile.lock",
+  "Gemfile.lock",
+  "composer.lock"
+]);
+var DOC_EXT = /\.(?:md|mdx|markdown|rst|adoc)$/iu;
+var DOC_NAMES = /^(?:license|licence|notice|authors|changelog|changes|contributors)$/iu;
+var INSTRUCTIONS = /(?:^|\/)(?:AGENTS|CLAUDE|GEMINI|SKILL)\.md$|(?:^|\/)(?:skills|agents|commands|rules|prompts)\/[^/]+/iu;
+var TEST_PATH = /(?:^|\/)(?:test|tests|__tests__)\/|\.(?:test|spec)\.[^/]+$|_test\.[^/]+$/iu;
+var basename = (file) => file.slice(file.lastIndexOf("/") + 1);
+var isDoc = (file) => !INSTRUCTIONS.test(file) && (DOC_EXT.test(file) || DOC_NAMES.test(basename(file)));
+function kindOf(file) {
+  if (file.binary)
+    return "behavior";
+  if (file.generated)
+    return "generated";
+  if (LOCKFILES.has(basename(file.path)))
+    return "lockfile";
+  if (isDoc(file.path))
+    return "doc";
+  if (file.cosmetic)
+    return "cosmetic";
+  return TEST_PATH.test(file.path) ? "test" : "behavior";
 }
-function pruneIssued(dir, own, tokens) {
-  try {
-    const entries = fs5.readdirSync(dir);
-    if (entries.length <= ISSUED_PER_LEAD)
-      return;
-    const byAge = entries.filter((name) => name !== own).map((name) => ({ name, at: fs5.statSync(path7.join(dir, name)).mtimeMs })).toSorted((a, b) => a.at - b.at);
-    for (const { name } of byAge.slice(0, entries.length - ISSUED_PER_LEAD)) {
-      fs5.rmSync(path7.join(dir, name), { force: true });
-      fs5.rmSync(path7.join(tokens, name), { force: true });
+var globCache = new Map;
+function globMatch(pattern, file) {
+  let regex = globCache.get(pattern);
+  if (!regex) {
+    let source = "";
+    for (let index = 0;index < pattern.length; index += 1) {
+      const char = pattern[index];
+      if (char === "*" && pattern[index + 1] === "*") {
+        source += pattern[index + 2] === "/" ? "(?:[^/]*/)*" : ".*";
+        index += pattern[index + 2] === "/" ? 2 : 1;
+      } else if (char === "*")
+        source += "[^/]*";
+      else if (char === "?")
+        source += "[^/]";
+      else
+        source += char.replace(/[.+^${}()|[\]\\]/gu, "\\$&");
     }
-  } catch {}
-}
-var issuedRecord = (cwd, claimed) => {
-  const cut = claimed.lastIndexOf(":");
-  if (cut <= 0)
-    return null;
-  migrateRepoIssued(cwd);
-  try {
-    return fs5.readFileSync(path7.join(userIssuedRoot(), hash(claimed.slice(0, cut)), hash(claimed)), "utf8");
-  } catch {
-    return null;
+    regex = new RegExp(`^${source}$`, "u");
+    globCache.set(pattern, regex);
   }
-};
-var TOKEN_HASH = /^([0-9a-f]{64})$/mu;
-var issuedToken = (claimed) => {
-  const cut = claimed.lastIndexOf(":");
-  if (cut <= 0)
-    return { stored: null, leadBound: false };
-  const dir = path7.join(userTokenRoot(), hash(claimed.slice(0, cut)));
+  return regex.test(file) || file.startsWith(`${pattern.replace(/\/$/u, "")}/`);
+}
+function isRiskPath(file, extra = []) {
+  if (extra.some((pattern) => globMatch(pattern, file)))
+    return true;
+  if (RISK_FILES.has(file) || RISK_NAMES.has(basename(file)))
+    return true;
+  if (TEST_PATH.test(file) || isDoc(file))
+    return false;
+  return file.split("/").map((segment, index, all) => index === all.length - 1 ? segment.replace(/\.[^.]+$/u, "") : segment).some((segment) => segment.toLowerCase().split(/[-_.]/u).some((token) => RISK_TOKENS.has(token)));
+}
+var parseRiskPaths = (text) => text.split(`
+`).map((line) => line.trim()).filter((line) => line && !line.startsWith("#")).map((line) => line.replace(/^\//u, ""));
+function computeLane(input) {
+  const riskFiles = input.files.filter((file) => isRiskPath(file.path, input.riskPaths)).map((file) => file.path);
+  const risky = new Set(riskFiles);
+  const kinds = input.files.map((file) => ({
+    file,
+    kind: risky.has(file.path) ? "behavior" : kindOf(file)
+  }));
+  const behavior = kinds.filter((entry) => entry.kind === "behavior" || entry.kind === "test" || entry.kind === "lockfile");
+  const lines = behavior.filter((entry) => entry.kind !== "lockfile").reduce((sum, entry) => sum + entry.file.added + entry.file.deleted, 0);
+  const opaque = behavior.filter((entry) => entry.kind === "lockfile" || entry.file.binary);
+  const result = (lane, reasons) => ({
+    lane,
+    reasons,
+    lines,
+    files: behavior.length,
+    riskFiles
+  });
+  const { selfMaxLines, selfMaxFiles, fullMinLines } = LANE_THRESHOLDS;
+  if (input.riskTier === "high")
+    return result("full", ["the task judgment records high risk"]);
+  if (riskFiles.length)
+    return result("full", [
+      `touches a risk path: ${riskFiles.slice(0, 3).join(", ")}${riskFiles.length > 3 ? ", …" : ""}`
+    ]);
+  if (!behavior.length)
+    return result("none", [
+      input.files.length ? "only docs, comments, formatting or generated copies changed" : "no changes"
+    ]);
+  if (lines >= fullMinLines)
+    return result("full", [`large diff: ${lines} lines (≥ ${fullMinLines})`]);
+  if (lines > selfMaxLines)
+    return result("focused", [`${lines} lines changed (> ${selfMaxLines})`]);
+  if (behavior.length > selfMaxFiles)
+    return result("focused", [`${behavior.length} behavior files changed (> ${selfMaxFiles})`]);
+  if (opaque.length)
+    return result("focused", [
+      `a lockfile or binary changed: ${opaque.slice(0, 3).map((entry) => entry.file.path).join(", ")}${opaque.length > 3 ? ", …" : ""}`
+    ]);
+  return result("self", [
+    `small change: ${lines} line${lines === 1 ? "" : "s"} in ${behavior.length} file${behavior.length === 1 ? "" : "s"}, no risk path`
+  ]);
+}
+function untrackedStat(cwd, file) {
   try {
-    const text = fs5.readFileSync(path7.join(dir, hash(claimed)), "utf8");
-    return { stored: TOKEN_HASH.exec(text)?.[1] ?? null, leadBound: true };
+    const bytes = readFileSync3(path6.join(cwd, file));
+    if (bytes.includes(0))
+      return { path: file, added: 0, deleted: 0, binary: true };
+    const text = bytes.toString("utf8");
+    if (hasOpaqueLineBreak(text))
+      return { path: file, added: 0, deleted: 0, binary: true };
+    const lines = text.split(`
+`).length - (text.endsWith(`
+`) ? 1 : 0);
+    return { path: file, added: lines, deleted: 0 };
   } catch {
-    return { stored: null, leadBound: safeList(dir).length > 0 };
+    return { path: file, added: 0, deleted: 0, binary: true };
   }
-};
-function issuedBinding(cwd, claimed) {
-  const record = issuedRecord(cwd, claimed);
-  const { stored, leadBound } = issuedToken(claimed);
-  if (stored)
-    return "token";
-  if (record === null)
-    return null;
-  return leadBound ? "token" : "legacy";
 }
-var OWN_CHILD_SHELL = new Set(["opencode", "pi"]);
-
-// packages/workit-core/src/hooks/standing-signal.ts
-import { createHash as createHash8 } from "node:crypto";
-import fs6 from "node:fs";
-import path8 from "node:path";
-var gitStoreDir = (cwd) => {
-  try {
-    for (let dir = path8.resolve(cwd);; dir = path8.dirname(dir)) {
-      const dotGit = path8.join(dir, ".git");
-      if (fs6.existsSync(dotGit)) {
-        let gitDir = dotGit;
-        if (fs6.statSync(dotGit).isFile()) {
-          const target = /^gitdir:\s*(.+)$/mu.exec(fs6.readFileSync(dotGit, "utf8"))?.[1]?.trim();
-          if (!target)
-            return null;
-          gitDir = path8.resolve(dir, target);
-          const common = path8.join(gitDir, "commondir");
-          if (fs6.existsSync(common))
-            gitDir = path8.resolve(gitDir, fs6.readFileSync(common, "utf8").trim());
-        }
-        return path8.join(gitDir, "workit");
-      }
-      if (path8.dirname(dir) === dir)
-        return null;
-    }
-  } catch {
+var REGULAR = new Set(["100644", "100755"]);
+var ABSENT = /^0+$/u;
+function cosmeticFiles(cwd, fork, head) {
+  const raw = diffRaw(cwd, fork, head);
+  if (!raw)
     return null;
-  }
-};
-var standingRevFile = (store) => path8.join(store, "standing", "rev");
-var standingSeenFile = (store, session, agentId) => path8.join(store, "standing", "seen", `${createHash8("sha256").update(`${session}\x00${agentId ?? ""}`).digest("hex").slice(0, 32)}.json`);
-var readStandingRev = (store) => {
-  try {
-    return fs6.readFileSync(standingRevFile(store), "utf8").trim() || null;
-  } catch {
+  const candidates = raw.filter((entry) => REGULAR.has(entry.oldMode) && entry.oldMode === entry.newMode && !ABSENT.test(entry.oldBlob) && (head === null || !ABSENT.test(entry.newBlob)));
+  const blobs = readBlobs(cwd, candidates.flatMap((entry) => [entry.oldBlob, entry.newBlob]));
+  if (!blobs)
     return null;
+  const out = new Set;
+  const opaque = new Set;
+  for (const entry of candidates) {
+    const before = blobs.get(entry.oldBlob);
+    let after = blobs.get(entry.newBlob);
+    if (!after && head === null && ABSENT.test(entry.newBlob))
+      try {
+        after = readFileSync3(path6.join(cwd, entry.path));
+      } catch {
+        after = undefined;
+      }
+    if (before && after && cosmeticChange(entry.path, before, after))
+      out.add(entry.path);
+    else if ([before, after].some((bytes) => bytes && hasOpaqueLineBreak(bytes.toString("utf8"))))
+      opaque.add(entry.path);
   }
-};
-var readStandingSeen = (file) => {
-  try {
-    const value = JSON.parse(fs6.readFileSync(file, "utf8"));
-    return {
-      rev: typeof value.rev === "string" ? value.rev : null,
-      ids: Array.isArray(value.ids) ? value.ids.filter((id) => typeof id === "string") : []
-    };
-  } catch {
-    return { rev: null, ids: [] };
-  }
-};
-var writeStandingSeen = (file, seen) => {
-  try {
-    fs6.mkdirSync(path8.dirname(file), { recursive: true });
-    fs6.writeFileSync(file, JSON.stringify(seen));
-  } catch {}
-};
-
-// packages/workit-core/src/ledger.ts
-var LEDGER_VERSION = 1;
-var MAX_LINE_BYTES = 4096;
-var PASSING = new Set(["verified", "tests-verified", "type-check-only"]);
-var FAILING = new Set(["failed", "blocked"]);
-var STRONG_RESULTS = new Set(["verified", "tests-verified"]);
-var PR_ROW_TYPES = new Set([
-  "pr.created",
-  "pr.status",
-  "pr.merged",
-  "pr.linked"
-]);
-var err = (code, error, unblock) => ({
-  ok: false,
-  code,
-  error,
-  ...unblock ? { unblock } : {}
-});
-var gitRun2 = (cwd, args, timeoutMs = GIT_TIMEOUTS.local) => {
-  const run = spawnSync8("git", args, {
-    cwd,
-    encoding: "utf8",
-    timeout: timeoutMs,
-    killSignal: "SIGKILL",
-    windowsHide: true,
-    maxBuffer: 256 * 1024 * 1024,
-    env: {
-      ...process.env,
-      GIT_TERMINAL_PROMPT: "0",
-      GIT_OPTIONAL_LOCKS: "0",
-      LC_ALL: "C",
-      LANGUAGE: "C"
-    }
-  });
-  return {
-    ok: run.status === 0,
-    stdout: run.stdout ?? "",
-    stderr: run.error ? String(run.error.message) : run.stderr ?? ""
-  };
-};
-var git3 = (cwd, args) => {
-  const run = gitRun2(cwd, args);
-  const value = run.ok ? run.stdout.trim() : "";
-  return value ? value : null;
-};
-var safeRef = (value) => value.length > 0 && !value.startsWith("-");
-function resolveCommit(cwd, ref) {
-  if (!safeRef(ref))
-    return null;
-  return git3(cwd, ["rev-parse", "--verify", "-q", `${ref}^{commit}`]);
-}
-function branchHead(cwd, branch) {
-  if (!safeRef(branch))
-    return null;
-  return resolveCommit(cwd, `refs/heads/${branch}`) ?? resolveCommit(cwd, `refs/remotes/origin/${branch}`);
+  return { cosmetic: out, opaque };
 }
-var trackTrunk = (cwd) => {
-  try {
-    const resolved = vcsConfig("resolve", cwd);
-    if (resolved.ok === false || !resolved.releaseTrack || resolved.releaseTrack.blocking)
-      return null;
-    const target = String(resolved.defaultTargetBranch ?? "").trim();
-    return target && safeRef(target) ? target : null;
-  } catch {
-    return null;
-  }
-};
-function defaultBase(cwd) {
-  const trunk = trackTrunk(cwd);
-  if (trunk) {
-    for (const candidate of [`origin/${trunk}`, trunk])
-      if (resolveCommit(cwd, candidate))
-        return candidate;
+function generatedAt(cwd, fork, paths) {
+  const files = treeFilesNamed(cwd, fork, ".gitattributes");
+  const blobs = files?.size ? readBlobs(cwd, [...files.values()]) : null;
+  if (!files || !blobs)
+    return new Set;
+  const texts = new Map;
+  for (const [file, id] of files) {
+    const bytes = blobs.get(id);
+    if (bytes)
+      texts.set(file, bytes.toString("utf8"));
   }
-  const originHead = git3(cwd, ["symbolic-ref", "-q", "--short", "refs/remotes/origin/HEAD"]);
-  if (originHead && resolveCommit(cwd, originHead))
-    return originHead;
-  for (const candidate of [
-    "origin/main",
-    "origin/master",
-    "main",
-    "master",
-    "origin/develop",
-    "develop"
-  ])
-    if (resolveCommit(cwd, candidate))
-      return candidate;
-  return null;
+  return generatedByAttributes(texts, paths);
 }
-function diffHash(cwd, base, head) {
-  if (!safeRef(base) || !safeRef(head))
+var forkOf = (cwd, base, head) => mergeBase(cwd, base, head ?? "HEAD");
+function laneFiles(cwd, fork, head, attributesAt = fork) {
+  const stats = diffNumstat(cwd, fork, head);
+  const cosmetic = stats ? cosmeticFiles(cwd, fork, head) : null;
+  if (!stats || !cosmetic)
     return null;
-  const diff = gitRun2(cwd, [
-    "diff",
-    "-U3",
-    "--diff-algorithm=myers",
-    "--indent-heuristic",
-    "--no-color",
-    "--no-ext-diff",
-    "--no-textconv",
-    "--no-renames",
-    "--full-index",
-    "--binary",
-    "--src-prefix=a/",
-    "--dst-prefix=b/",
-    `${base}...${head}`,
-    "--"
-  ], GIT_TIMEOUTS.worktree);
-  if (!diff.ok || !diff.stdout)
+  const files = [
+    ...stats.map((entry) => ({
+      ...entry,
+      ...cosmetic.opaque.has(entry.path) ? { binary: true } : {},
+      cosmetic: !entry.binary && cosmetic.cosmetic.has(entry.path)
+    })),
+    ...head === null ? untrackedFiles(cwd).map((file) => untrackedStat(cwd, file)) : []
+  ];
+  const generated = generatedAt(cwd, attributesAt, files.map((entry) => entry.path));
+  return files.map((entry) => ({
+    ...entry,
+    generated: generated.has(entry.path)
+  }));
+}
+function driftFiles(cwd, range) {
+  if (range.fromFork === range.toFork)
+    return laneFiles(cwd, range.from, range.to, range.toFork);
+  const drifted = ownChangeDrift(cwd, range);
+  const stats = drifted ? diffNumstat(cwd, range.from, range.to) : null;
+  if (!drifted || !stats)
     return null;
-  const hash = createHash9("sha256");
-  for (const line of diff.stdout.split(`
-`)) {
-    if (line.startsWith("index "))
-      continue;
-    hash.update(line.startsWith("@@ ") ? "@@" : line);
-    hash.update(`
-`);
-  }
-  return `sha256:${hash.digest("hex")}`;
+  const byPath = new Map(stats.map((entry) => [entry.path, entry]));
+  const generated = generatedAt(cwd, range.toFork, drifted);
+  return drifted.map((file) => ({
+    path: file,
+    added: byPath.get(file)?.added ?? 0,
+    deleted: byPath.get(file)?.deleted ?? 0,
+    ...byPath.get(file)?.binary ? { binary: true } : {},
+    cosmetic: false,
+    generated: generated.has(file)
+  }));
 }
-function storeRoot(cwd) {
-  const location = resolveStore(path9.resolve(cwd));
-  if (location instanceof Error)
-    return err("unavailable", location.message.replace(/; fix the repository.*$/u, ""), "fix the repository (git status should work here) or run from a non-git directory");
-  return { ok: true, value: { root: location.dir, shared: location.shared } };
+function branchLane(cwd, options) {
+  const candidates = options.base ? [`origin/${options.base}`, options.base] : [];
+  const base = candidates.find((ref) => resolveRef(cwd, ref) !== null) ?? defaultBase(cwd) ?? null;
+  const head = options.workingTree ? null : options.head;
+  const fork = base && (options.workingTree || options.head) ? forkOf(cwd, base, head) : null;
+  const files = fork ? laneFiles(cwd, fork, head) : null;
+  const riskTier = options.judgment?.riskTier ?? null;
+  if (!fork || !files) {
+    const high = riskTier === "high";
+    return {
+      lane: high ? "full" : "focused",
+      reasons: [
+        `the diff of ${options.head?.slice(0, 12) ?? "(no head)"} against ${base ?? "(no base)"} cannot be read`,
+        ...high ? ["the task judgment records high risk"] : []
+      ],
+      lines: 0,
+      files: 0,
+      riskFiles: [],
+      base,
+      head: options.head
+    };
+  }
+  const repoRisk = parseRiskPaths(fileAt(cwd, fork, RISK_PATHS_FILE) ?? "");
+  return {
+    ...computeLane({
+      files,
+      riskTier,
+      riskPaths: [...repoRisk, ...options.riskPaths ?? []]
+    }),
+    base,
+    head: options.head
+  };
 }
-function ledgerPath(cwd) {
-  const root = storeRoot(cwd);
-  return root.ok ? { ok: true, value: path9.join(root.value.root, "ledger", "ledger.jsonl") } : root;
+var laneNeed = (lane) => lane === "none" ? "none" : lane === "self" ? "self" : "non-author";
+
+// packages/workit-core/src/core/policy/carry.ts
+var TEST_ONLY_KINDS = new Set(["doc", "cosmetic", "generated", "test"]);
+function verdictDrift(cwd, input) {
+  const since = input.from;
+  const stale = (reason, files = null, focused = false) => ({
+    carries: false,
+    since,
+    files,
+    focused,
+    reason
+  });
+  const fromFork = mergeBase(cwd, input.fromBase, input.from);
+  const toFork = mergeBase(cwd, input.toBase, input.to);
+  const files = fromFork && toFork ? driftFiles(cwd, { from: input.from, to: input.to, fromFork, toFork }) : null;
+  if (!fromFork || !toFork || !files)
+    return stale(`the change since ${since.slice(0, 12)} cannot be read`);
+  const riskPaths = [fromFork, toFork].flatMap((fork) => parseRiskPaths(fileAt(cwd, fork, RISK_PATHS_FILE) ?? ""));
+  const lane = computeLane({ files, riskPaths });
+  const paths = files.map((file) => file.path);
+  if (lane.lane === "none")
+    return { carries: true, rule: "lane-none", since, files: paths };
+  if (input.kind === "unit" && lane.lane === "self" && files.every((file) => TEST_ONLY_KINDS.has(kindOf(file))))
+    return { carries: true, rule: "tests-only", since, files: paths };
+  return stale(lane.reasons[0] ?? `lane ${lane.lane}`, paths, lane.lane === "self");
 }
-var newId2 = () => `${Date.now().toString(36)}-${randomBytes2(6).toString("hex")}`;
-var NETWORK_FS_TYPES = new Set([
-  26985,
-  20859,
-  4266872130,
-  4283649346,
-  1702057286,
-  1397113167,
-  12805120,
-  16914839,
-  1196443219,
-  198183888
-]);
-var isNetworkFsType = (type) => NETWORK_FS_TYPES.has(type >>> 0);
-var onNetworkFs = (dir) => {
-  if (process.platform !== "linux")
-    return false;
-  try {
-    return isNetworkFsType(fs7.statfsSync(dir).type);
-  } catch {
-    return false;
-  }
-};
-var LOCK_WAIT_MS = 5000;
-var LOCK_STALE_MS = 30000;
-var LOCK_OWNER = "owner";
-var lockToken = (lock) => {
-  try {
-    return fs7.readFileSync(path9.join(lock, LOCK_OWNER), "utf8");
-  } catch {
-    return null;
-  }
-};
-var lockAgeMs = (lock) => {
-  for (const target of [path9.join(lock, LOCK_OWNER), lock]) {
-    try {
-      return Date.now() - fs7.statSync(target).mtimeMs;
-    } catch {}
+
+// packages/workit-core/src/host-session.ts
+import { createHash as createHash7, randomBytes, timingSafeEqual } from "node:crypto";
+import fs5 from "node:fs";
+import path8 from "node:path";
+
+// packages/workit-core/src/core/branch.ts
+import { createHash as createHash6 } from "node:crypto";
+var withReleaseTracks = (workspaceRoot, policy) => {
+  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 null;
+  return {
+    ...policy,
+    allowed,
+    protected: new Set([
+      ...policy.protected,
+      ...[...trackBranches(read.tracks), ...read.protectedBranches].map((name) => name.toLowerCase())
+    ])
+  };
 };
-var ledgerLock = {
-  acquire(lock) {
-    try {
-      fs7.mkdirSync(lock);
-    } catch (error) {
-      if (error.code === "EEXIST")
-        return null;
-      throw error;
-    }
-    const token = `${process.pid}-${randomBytes2(8).toString("hex")}`;
-    fs7.writeFileSync(path9.join(lock, LOCK_OWNER), token);
-    return token;
-  },
-  release(lock, token) {
-    if (lockToken(lock) !== token)
-      return false;
-    const tomb = `${lock}.release-${randomBytes2(6).toString("hex")}`;
-    try {
-      fs7.renameSync(lock, tomb);
-    } catch {
-      return false;
-    }
-    if (lockToken(tomb) !== token) {
-      try {
-        fs7.renameSync(tomb, lock);
-      } catch {}
-      return false;
-    }
-    fs7.rmSync(tomb, { recursive: true, force: true });
-    return true;
-  },
-  token: lockToken,
-  reap(lock, observed) {
-    const tomb = `${lock}.reap-${randomBytes2(6).toString("hex")}`;
-    try {
-      fs7.renameSync(lock, tomb);
-    } catch {
-      return false;
-    }
-    if (lockToken(tomb) === observed) {
-      fs7.rmSync(tomb, { recursive: true, force: true });
-      return true;
-    }
-    try {
-      fs7.renameSync(tomb, lock);
-    } catch {
-      fs7.rmSync(tomb, { recursive: true, force: true });
+function effectiveWorkspacePolicy(workspaceRoot, kind, profileName) {
+  const selected = resolveRuntimeWorkspacePolicy(workspaceRoot, kind, profileName?.trim() || process.env.WORKFLOW_PROFILE?.trim() || undefined);
+  const config = readConfig();
+  return kind === "branch" ? {
+    branchPolicy: withReleaseTracks(workspaceRoot, resolveBranchPolicy(config, selected.policy ? { branchPolicy: selected.policy } : null, () => repoBranchPreset(workspaceRoot))),
+    provenance: { branchPolicy: selected.source }
+  } : {
+    commitPolicy: resolveCommitPolicy(config, selected.policy ? { commitPolicy: selected.policy } : null),
+    provenance: { commitPolicy: selected.source }
+  };
+}
+var 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"
+};
+var allowedKinds = (allowed) => [
+  ...new Set(allowed.map((pattern) => /^\^([\w.-]+)\\?\/\.\*\$$/u.exec(pattern.source)?.[1]?.toLowerCase()).filter((kind) => Boolean(kind)))
+];
+var 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 false;
   }
+  return row[b.length];
 };
-function withLedgerLock(file, fn, waitMs = hostAwareLockTimeout(LOCK_WAIT_MS)) {
-  const lock = `${file}.lock`;
-  const deadline = Date.now() + waitMs;
-  let token = null;
-  for (;; ) {
-    token = ledgerLock.acquire(lock);
-    if (token)
-      break;
-    const observed = lockToken(lock);
-    const age = lockAgeMs(lock);
-    if (age !== null && age > LOCK_STALE_MS && ledgerLock.reap(lock, observed))
-      continue;
-    if (Date.now() >= deadline)
-      return null;
-    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 25);
-  }
-  try {
-    return fn();
-  } finally {
-    ledgerLock.release(lock, token);
+var 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}`;
+};
+var kindList = (kinds) => kinds.map((kind) => `${kind}/`).join(", ");
+var aliasNote = (kinds) => {
+  const notes = [
+    ["fix", "bugfix"],
+    ["chore", "feature"]
+  ].filter(([, kind]) => kinds.includes(kind)).map(([alias, kind]) => `${alias}/ is ${kind}/`);
+  return notes.length ? ` (${notes.join(", ")})` : "";
+};
+var 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 = 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",
+      source,
+      attempted: name,
+      correction,
+      error: `protected_ref: branch ${JSON.stringify(name)} is protected by ${source}; ${correction}`
+    };
   }
-}
-var sha2562 = (text) => createHash9("sha256").update(text).digest("hex");
-var chainHash = (prevHash, body) => sha2562(`${prevHash ?? ""}
-${body}`);
-var TAIL_BYTES = 64 * 1024;
-var lastLine = (fd, size) => {
-  for (let span = Math.min(size, TAIL_BYTES);span > 0; span = Math.min(size, span * 2)) {
-    const buffer = Buffer.alloc(span);
-    fs7.readSync(fd, buffer, 0, span, size - span);
-    const end = buffer.lastIndexOf(10);
-    if (end < 0) {
-      if (span === size)
-        return null;
-      continue;
-    }
-    let stop = end;
-    let text = "";
-    while (stop >= 0) {
-      const start = buffer.lastIndexOf(10, stop - 1);
-      text = buffer.toString("utf8", start + 1, stop).trim();
-      if (text) {
-        if (start >= 0 || span === size)
-          return text;
-        break;
-      }
-      if (start < 0) {
-        if (span === size)
-          return null;
-        break;
-      }
-      stop = start;
-    }
-    if (span === size)
-      return text || null;
+  if (!policy.allowed.some((pattern) => pattern.test(name))) {
+    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",
+      source,
+      attempted: name,
+      correction,
+      error: `allowed_pattern: branch ${JSON.stringify(name)} violates ${source} policy; ${correction}`
+    };
   }
-  return null;
-};
-var tighten = (fd) => {
-  try {
-    if ((fs7.fstatSync(fd).mode & 63) !== 0)
-      fs7.fchmodSync(fd, 384);
-  } catch {}
+  return { ok: true };
 };
-function appendLine(file, build, options) {
-  const write = () => {
-    const fd = fs7.openSync(file, "a+", 384);
-    try {
-      if (process.platform !== "win32")
-        tighten(fd);
-      const size = fs7.fstatSync(fd).size;
-      let fence = "";
-      if (size > 0) {
-        const last = Buffer.alloc(1);
-        fs7.readSync(fd, last, 0, 1, size - 1);
-        if (last[0] !== 10)
-          fence = `
-`;
-      }
-      const line = build(lastLine(fd, size));
-      if (!line.ok)
-        return line;
-      const bytes = Buffer.from(fence + line.value);
-      const written = fs7.writeSync(fd, bytes);
-      if (written !== bytes.length)
-        return err("unavailable", `short write to ${file}: ${written} of ${bytes.length} bytes; the row is torn and will be skipped`);
-      return { ok: true, value: undefined };
-    } finally {
-      fs7.closeSync(fd);
-    }
+var branchPolicySnapshotFor = (workspaceRoot) => {
+  const resolved = effectiveWorkspacePolicy(workspaceRoot, "branch");
+  const branchPolicy = resolved.branchPolicy;
+  const source = resolved.provenance.branchPolicy;
+  const allowed = branchPolicy.allowed.map((pattern) => `${pattern.source}/${pattern.flags}`).toSorted();
+  const protectedRefs = [...branchPolicy.protected].map((name) => name.toLowerCase()).toSorted();
+  const fingerprint = createHash6("sha256").update(JSON.stringify({ allowed, protectedRefs, source })).digest("hex");
+  return {
+    branchPolicy,
+    namePolicy: { allowed: branchPolicy.allowed, protected: branchPolicy.protected },
+    source,
+    fingerprint
   };
+};
+var validateBranchNameFor = (workspaceRoot, name) => {
   try {
-    fs7.mkdirSync(path9.dirname(file), { recursive: true });
-    if (!options.forceLock && !onNetworkFs(path9.dirname(file)))
-      return write();
-    const locked = withLedgerLock(file, write);
-    return locked ?? err("busy", `ledger lock ${file}.lock is held`, "retry; remove the .lock directory if no workit process is running");
+    const resolved = branchPolicySnapshotFor(workspaceRoot);
+    return validateBranchNamePolicy(name, resolved.namePolicy, resolved.source);
   } catch (error) {
-    return err("unavailable", `cannot append to ${file}: ${error.message}`);
+    const correction = "repair or select a valid workspace policy before creating a branch";
+    return {
+      ok: false,
+      rule: "policy_unavailable",
+      source: "workspaces.json",
+      attempted: name,
+      correction,
+      error: `policy_unavailable: cannot validate branch ${JSON.stringify(name)} because ${error instanceof Error ? error.message : String(error)}; ${correction}`
+    };
   }
-}
-var sealed = (row, id, at, previous) => {
-  const { prevHash: _prev, rowHash: _row, ...fields } = row;
-  const prevHash = previous === null ? null : sha2562(previous);
-  const body = { v: LEDGER_VERSION, id, at, ...fields, prevHash };
-  const full = { ...body, rowHash: chainHash(prevHash, JSON.stringify(body)) };
-  return { full, line: `${JSON.stringify(full)}
-` };
-};
-function appendRaw(cwd, row, options) {
-  const file = ledgerPath(cwd);
-  if (!file.ok)
-    return file;
-  const id = newId2();
-  const at = (options.now ?? new Date).toISOString();
-  let full = null;
-  const written = appendLine(file.value, (previous) => {
-    const next = sealed(row, id, at, previous);
-    const bytes = Buffer.byteLength(next.line);
-    if (bytes > MAX_LINE_BYTES)
-      return err("invalid_input", `ledger row is ${bytes} bytes; the limit is ${MAX_LINE_BYTES}. Shorten the text and pass details by --ref <path|url>`);
-    full = next.full;
-    return { ok: true, value: next.line };
-  }, options);
-  return written.ok ? { ok: true, value: full } : written;
-}
-function observedRowBytes(row) {
-  const sample = sealed({ ...row, observer: "workit_cli" }, newId2(), new Date().toISOString(), "");
-  return Buffer.byteLength(sample.line);
-}
-function appendObserved(cwd, row, options = {}) {
-  return appendRaw(cwd, { ...row, observer: "workit_cli" }, options);
-}
-function appendHookObserved(cwd, row) {
-  return appendRaw(cwd, { ...row, observer: "host_hook" }, {});
-}
-var isRecord2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
-var str = (value) => typeof value === "string" ? value : null;
-var normalizeActor = (value) => {
-  const actor = isRecord2(value) ? value : {};
-  return {
-    host: str(actor.host) ?? "unknown",
-    session: str(actor.session),
-    agentId: str(actor.agentId)
-  };
 };
-function supersedeAllowed(by, target, onBranch = (row) => (by.branch ?? null) === (row.branch ?? null)) {
-  if (by.type !== target.type)
-    return `a ${by.type} row cannot supersede a ${target.type} row`;
-  if (!by.actor.session || by.actor.session !== target.actor.session)
-    return "only the session that wrote a row can supersede it";
-  if (!onBranch(target))
-    return `the row is on another branch (${String(target.branch ?? "none")}); a row supersedes only one on its own branch`;
-  if (by.type === "verdict" && (by.kind ?? "review") !== (target.kind ?? "review"))
-    return `a ${String(by.kind ?? "review")} verdict cannot supersede a ${String(target.kind ?? "review")} verdict; record it with --kind ${String(target.kind ?? "review")}`;
-  if (by.type === "verdict" && by.self === true && target.self !== true)
-    return "a self verdict cannot replace an independent verdict";
-  return null;
-}
-function readLedger(cwd, options = {}) {
-  const file = ledgerPath(cwd);
-  if (!file.ok)
-    return file;
-  let text = "";
-  let stat = null;
+var resolveBranchPolicyFor = (workspaceRoot, profileName) => effectiveWorkspacePolicy(workspaceRoot, "branch", profileName).branchPolicy;
+var gitFlowOf = (root, integration) => {
   try {
-    stat = fs7.statSync(file.value);
-    text = fs7.readFileSync(file.value, "utf8");
-  } catch (error) {
-    if (error.code === "ENOENT")
-      return {
-        ok: true,
-        value: {
-          path: file.value,
-          rows: [],
-          skipped: 0,
-          integrity: options.integrity ? { chained: 0, legacy: 0, unverified: [] } : null
-        }
-      };
-    return err("unavailable", `cannot read ${file.value}: ${error.message}`);
+    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;
   }
-  const rows = [];
-  let skipped = 0;
-  const integrity = { chained: 0, legacy: 0, unverified: [] };
-  const earlier = new Set([null]);
-  let chainStarted = false;
-  const ids = new Set;
-  for (const raw of text.split(`
-`)) {
-    const trimmed = raw.trim();
-    if (!trimmed)
-      continue;
-    const linked = (prevHash) => earlier.has(prevHash);
-    if (options.integrity)
-      earlier.add(sha2562(trimmed));
-    let parsed;
-    try {
-      parsed = JSON.parse(trimmed);
-    } catch {
-      skipped += 1;
-      continue;
-    }
-    if (!isRecord2(parsed) || !str(parsed.id) || !str(parsed.type) || !str(parsed.at)) {
-      skipped += 1;
-      continue;
-    }
-    let rowIntegrity = options.integrity ? "verified" : undefined;
-    let reason = null;
-    if (!options.integrity) {} else if (typeof parsed.rowHash === "string") {
-      chainStarted = true;
-      const { rowHash, ...body } = parsed;
-      const prevHash = str(parsed.prevHash);
-      if (chainHash(prevHash, JSON.stringify(body)) !== rowHash)
-        reason = "hash_mismatch";
-      else if (!linked(prevHash))
-        reason = "broken_link";
-    } else if (chainStarted)
-      reason = "unsigned";
-    else
-      rowIntegrity = "legacy";
-    if (options.integrity && !reason && ids.has(parsed.id))
-      reason = "duplicate_id";
-    if (options.integrity)
-      ids.add(parsed.id);
-    if (reason)
-      rowIntegrity = "unverified";
-    const pr = typeof parsed.pr === "number" && Number.isInteger(parsed.pr) ? parsed.pr : undefined;
-    const row = {
-      ...parsed,
-      v: typeof parsed.v === "number" ? parsed.v : LEDGER_VERSION,
-      id: parsed.id,
-      at: parsed.at,
-      type: parsed.type,
-      actor: normalizeActor(parsed.actor),
-      branch: str(parsed.branch),
-      head: str(parsed.head),
-      base: str(parsed.base),
-      baseSha: str(parsed.baseSha),
-      patchId: str(parsed.patchId),
-      diffHash: str(parsed.diffHash),
-      tree: str(parsed.tree),
-      dirty: typeof parsed.dirty === "boolean" ? parsed.dirty : null,
-      ...pr === undefined ? {} : { pr },
-      ...str(parsed.supersedes) ? { supersedes: parsed.supersedes } : {},
-      seq: rows.length + 1,
-      superseded: false,
-      supersedeIgnored: false,
-      ...rowIntegrity ? { integrity: rowIntegrity } : {},
-      ...reason ? { integrityReason: reason } : {}
+};
+var 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
     };
-    rows.push(row);
-    if (!options.integrity)
-      continue;
-    if (rowIntegrity === "verified")
-      integrity.chained += 1;
-    else if (rowIntegrity === "legacy")
-      integrity.legacy += 1;
-    else if (reason)
-      integrity.unverified.push({
-        seq: row.seq,
-        id: row.id,
-        type: row.type,
-        branch: row.branch,
-        reason
-      });
+  } catch {
+    return { preset: "unknown", branches: [], production: null };
   }
-  const scopes = new Map;
-  const scopeOf = (branch) => {
-    let scope = scopes.get(branch);
-    if (!scope)
-      scopes.set(branch, scope = branchScope(cwd, branch));
-    return scope;
-  };
-  const byId = new Map;
-  for (const row of rows) {
-    const target = row.supersedes ? byId.get(row.supersedes) : undefined;
-    if (target && row.integrity !== "unverified" && supersedeAllowed(row, target, renameAwareBranch(scopeOf, row.branch)) === null)
-      target.superseded = true;
-    else if (row.supersedes)
-      row.supersedeIgnored = true;
-    if (!byId.has(row.id))
-      byId.set(row.id, row);
+};
+var releaseBranch = (cwd, branch) => releaseBranchesOf(cwd).branches.some((name) => name.toLowerCase() === branch.toLowerCase());
+var 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;
   }
-  if (options.integrity && stat && Buffer.byteLength(text) === stat.size)
-    tamperCache.set(file.value, {
-      size: stat.size,
-      stamp: fileStamp(stat),
-      breaks: integrity.unverified.filter((row) => TAMPER_REASONS.has(row.reason))
-    });
-  return {
-    ok: true,
-    value: { path: file.value, rows, skipped, integrity: options.integrity ? integrity : null }
-  };
-}
-var TAMPER_REASONS = new Set(["hash_mismatch", "broken_link"]);
-var tamperCache = new Map;
-var fileStamp = (stat) => `${stat.ino}:${stat.mtimeMs}:${stat.ctimeMs}`;
-function ledgerTampering(cwd) {
-  const file = ledgerPath(cwd);
-  if (!file.ok)
-    return [];
+};
+var globOf = (pattern) => pattern.source.replace(/^\^|\$$/gu, "").replaceAll(".*", "*").replace(/\\(.)/gu, "$1");
+var policy = (root) => resolveBranchPolicyFor(root);
+var isProtected = (root, name) => policy(root).protected.has(name.toLowerCase());
+var isProtectedTarget = (root, name) => {
   try {
-    const stat = fs7.statSync(file.value);
-    const cached = tamperCache.get(file.value);
-    if (cached && cached.size === stat.size && cached.stamp === fileStamp(stat))
-      return cached.breaks;
+    return isProtected(root, name);
   } catch {
-    return [];
+    return true;
   }
-  const read = readLedger(cwd, { integrity: true });
-  return read.ok ? (read.value.integrity?.unverified ?? []).filter((row) => TAMPER_REASONS.has(row.reason)) : [];
-}
-function tamperedUnblock(cwd) {
-  const file = ledgerPath(cwd);
-  const where = file.ok ? file.value : "the ledger file";
-  return `workit ledger verify-integrity  # lists the edited or missing rows; if the edit is understood, move ${where} aside (mv ${where} ${where}.tampered-<date>) and record the verdicts again`;
-}
-var tamperedWarning = (cwd, breaks) => `the ledger was edited, or a row was removed or moved (${breaks.slice(0, 3).map((row) => `${row.reason} at row ${row.seq}`).join(", ")}${breaks.length > 3 ? ", …" : ""}): no verdict is accepted until it is repaired. ${tamperedUnblock(cwd)}`;
-function verdictBasis(verdict, current) {
-  if (verdict.head && verdict.head === current.head)
-    return "fresh";
-  if (verdict.patchId && verdict.patchId === current.patchId && verdict.diffHash && verdict.diffHash === current.diffHash)
-    return "carried";
-  return "stale";
-}
-var isLiveVerdict = (row, retired) => row.type === "verdict" && typeof row.result === "string" && !retired.has(row.id);
-function trailerSessions(cwd, base, head) {
-  if (!base || !head || !safeRef(base) || !safeRef(head))
-    return [];
-  const out = git3(cwd, [
-    "log",
-    "--format=%(trailers:key=Workit-Session,valueonly,separator=%x00)",
-    `${base}..${head}`
-  ]);
-  return (out ?? "").split(/[\0\n]/u).map((value) => value.trim()).filter(Boolean);
-}
-var RENAMED = /^branch: renamed refs\/heads\/(.+) to refs\/heads\/(.+)$/iu;
-function branchScope(cwd, branch) {
-  const renamedAt = new Map;
-  let since = Number.NEGATIVE_INFINITY;
-  if (safeRef(branch)) {
-    const log = git3(cwd, [
-      "log",
-      "-g",
-      "--date=unix",
-      "--format=%gd%x09%gs",
-      `refs/heads/${branch}`,
-      "--"
-    ]);
-    for (const line of (log ?? "").split(`
-`)) {
-      const [selector = "", subject = ""] = line.split("\t");
-      const seconds = Number(/@\{(\d+)\}$/u.exec(selector)?.[1]);
-      if (!Number.isFinite(seconds))
-        continue;
-      since = seconds * 1000;
-      const match = RENAMED.exec(subject);
-      if (!match || match[1] === branch)
-        continue;
-      const until = (seconds + 1) * 1000;
-      renamedAt.set(match[1], Math.max(renamedAt.get(match[1]) ?? 0, until));
+};
+
+// packages/workit-core/src/core/logger.ts
+import os3 from "node:os";
+import path7 from "node:path";
+var SENSITIVE_WORDS = new Set([
+  "token",
+  "secret",
+  "password",
+  "passwd",
+  "authorization",
+  "credential",
+  "credentials",
+  "cookie",
+  "api",
+  "apikey",
+  "apitoken",
+  "accesstoken",
+  "clientsecret",
+  "refreshtoken",
+  "key",
+  "bearer",
+  "prompt",
+  "message",
+  "messages",
+  "content",
+  "body",
+  "args",
+  "argument",
+  "result",
+  "results",
+  "output",
+  "issue",
+  "description",
+  "summary",
+  "payload",
+  "script",
+  "command",
+  "text",
+  "query"
+]);
+var STACK_WORDS = new Set(["stack", "stacktrace", "trace"]);
+var escapeRegExp2 = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+var resolveStateDir = () => {
+  const override = process.env.WORKFLOW_TOOLKIT_STATE;
+  if (override)
+    return override;
+  const home = os3.homedir();
+  if (process.env.XDG_STATE_HOME)
+    return path7.join(process.env.XDG_STATE_HOME, "workit");
+  switch (os3.platform()) {
+    case "darwin":
+      return path7.join(home, "Library", "Application Support", "workit");
+    case "win32":
+      return path7.join(process.env.LOCALAPPDATA ?? path7.join(home, "AppData", "Local"), "workit");
+    default:
+      return path7.join(process.env.HOME ?? home, ".local", "state", "workit");
+  }
+};
+var homePattern = new RegExp(`${escapeRegExp2(os3.homedir())}(?=[/\\\\]|$)|\\$HOME(?=[/\\\\]|$)`, "g");
+
+// packages/workit-core/src/host-session.ts
+var HOST_SESSION_VARS = [
+  ["OPENCODE_SESSION_ID", () => "opencode"],
+  ["PI_SESSION_ID", () => "pi"],
+  [
+    "CODEX_THREAD_ID",
+    (env) => env.CODEX_INTERNAL_ORIGINATOR_OVERRIDE === "Codex Desktop" || env.CODEX_ELECTRON_RESOURCES_PATH ? "codex_desktop" : "codex_cli"
+  ]
+];
+var family = (host) => host?.replace(/_(?:cli|desktop)$/, "") ?? null;
+function hostSessionFromEnv(env) {
+  const value = (key) => env[key]?.trim() || null;
+  let inner = null;
+  for (const [key, host] of HOST_SESSION_VARS) {
+    const session = value(key);
+    if (session) {
+      inner = { host: host(env), session };
+      break;
     }
   }
-  return (row) => {
-    if (row.branch === branch)
-      return true;
-    const until = row.branch === null ? undefined : renamedAt.get(row.branch);
-    if (until === undefined)
-      return false;
-    const at = Date.parse(row.at);
-    return at >= since && at <= until;
-  };
+  const declared = value("WORKIT_HOST");
+  if (env.WORKIT_SESSION_ID !== undefined) {
+    const inherited = inner !== null && declared !== null && family(declared) !== family(inner.host);
+    if (!inherited)
+      return { host: declared, session: value("WORKIT_SESSION_ID") };
+  }
+  return inner ? { host: inner.host, session: inner.session } : { host: declared, session: null };
 }
-var renameAwareBranch = (scopeOf, branch) => {
-  return (target) => {
-    const own = typeof branch === "string" ? branch : null;
-    const theirs = typeof target.branch === "string" ? target.branch : null;
-    if (own === theirs)
-      return true;
-    if (own === null || theirs === null || typeof target.at !== "string")
-      return false;
-    return scopeOf(own)({ branch: theirs, at: target.at });
-  };
-};
-function authorSessions(cwd, rows, branch, range = { base: null, head: null }, scope = branchScope(cwd, branch)) {
-  const sessions = new Set;
-  for (const row of rows) {
-    if (!scope(row) || row.type !== "commit.recorded" && row.type !== "task.opened")
-      continue;
-    const session = str(row.session) ?? row.actor.session;
-    if (session)
-      sessions.add(session);
+var ISSUED_PER_LEAD = 64;
+var ISSUED_SESSIONS_MARKER = "workit-issued-sessions/3";
+var hash = (value) => createHash7("sha256").update(value).digest("hex").slice(0, 32);
+var userIssuedRoot = () => path8.join(resolveStateDir(), "issued");
+var userTokenRoot = () => path8.join(resolveStateDir(), "issued-tokens");
+function migrateRepoIssued(cwd) {
+  if (cwd === undefined)
+    return;
+  let old;
+  try {
+    const location = resolveStore(cwd);
+    if (location instanceof Error)
+      return;
+    old = path8.join(location.dir, "hooks", "issued");
+    if (!fs5.existsSync(old))
+      return;
+  } catch {
+    return;
   }
-  for (const session of trailerSessions(cwd, range.base, range.head))
-    sessions.add(session);
-  return sessions;
+  for (const lead of safeList(old)) {
+    try {
+      const from = path8.join(old, lead);
+      if (!fs5.statSync(from).isDirectory())
+        continue;
+      const to = path8.join(userIssuedRoot(), lead);
+      fs5.mkdirSync(to, { recursive: true, mode: 448 });
+      for (const id of fs5.readdirSync(from)) {
+        try {
+          fs5.copyFileSync(path8.join(from, id), path8.join(to, id), fs5.constants.COPYFILE_EXCL);
+        } catch (error) {
+          if (error.code !== "EEXIST")
+            throw error;
+        }
+        fs5.rmSync(path8.join(from, id), { force: true });
+      }
+      removeIfEmpty(from);
+    } catch {}
+  }
+  removeIfEmpty(old);
 }
-var derivesFrom = (derived, bare) => !bare.includes(":") && derived.endsWith(`:${bare}`);
-var authoredBy = (authors, session) => {
-  if (authors.has(session))
-    return true;
-  for (const author of authors)
-    if (derivesFrom(author, session) || derivesFrom(session, author))
-      return true;
-  return false;
+var safeList = (dir) => {
+  try {
+    return fs5.readdirSync(dir);
+  } catch {
+    return [];
+  }
 };
-var TRUST_REASONS = new Set([
-  "unsigned",
-  "hash_mismatch",
-  "broken_link",
-  "duplicate_id",
-  "unissued_session",
-  "unbound_session"
-]);
-var SHELL_VOUCHED_HOSTS = new Set([
-  "cli",
-  "opencode",
-  "pi",
-  "codex_cli",
-  "codex_desktop"
-]);
-function sessionTrust(cwd, row) {
-  const session = row.actor.session;
-  if (!session || row.self === true)
-    return null;
-  const source = typeof row.sessionSource === "string" ? row.sessionSource : "env";
-  const host = row.actor.host;
-  const issuedOnly = source === "flag" ? host !== "cli" : source === "env" && session.includes(":") && !SHELL_VOUCHED_HOSTS.has(host);
-  if (!issuedOnly)
+var removeIfEmpty = (dir) => {
+  try {
+    fs5.rmdirSync(dir);
+  } catch {}
+};
+var tokenHash = (token) => createHash7("sha256").update(token).digest("hex");
+function recordIssuedSession(cwd, lead, issued) {
+  const token = randomBytes(18).toString("hex");
+  try {
+    migrateRepoIssued(cwd);
+    const own = hash(issued);
+    const tokens = path8.join(userTokenRoot(), hash(lead));
+    fs5.mkdirSync(tokens, { recursive: true, mode: 448 });
+    fs5.writeFileSync(path8.join(tokens, own), `${tokenHash(token)}
+`, { mode: 384, flag: "wx" });
+    const dir = path8.join(userIssuedRoot(), hash(lead));
+    fs5.mkdirSync(dir, { recursive: true, mode: 448 });
+    fs5.writeFileSync(path8.join(dir, own), `${ISSUED_SESSIONS_MARKER}
+`, { mode: 384 });
+    pruneIssued(dir, own, tokens);
+    return token;
+  } catch {
     return null;
-  const binding = issuedBinding(cwd, session);
-  if (binding === null)
-    return "unissued_session";
-  return binding === "token" && row.sessionBound !== true ? "unbound_session" : null;
+  }
 }
-function trustReasons(cwd, row) {
-  if (row.integrity === "unverified")
-    return [row.integrityReason ?? "unsigned"];
-  if (row.integrity !== "verified")
-    return ["unsigned"];
-  const session = sessionTrust(cwd, row);
-  return session ? [session] : [];
+function judgeBranch(cwd) {
+  const branch = currentBranch(cwd);
+  return branch && !isProtectedTarget(cwd, branch) ? branch : null;
 }
-function withIntegrity(cwd, rows) {
-  if (rows.every((row) => row.integrity !== undefined))
-    return rows;
-  const read = readLedger(cwd, { integrity: true });
-  const bySeq = new Map(read.ok ? read.value.rows.map((row) => [row.seq, row]) : []);
-  return rows.map((row) => {
-    if (row.integrity !== undefined)
-      return row;
-    const fresh = bySeq.get(row.seq);
-    return fresh && fresh.id === row.id && fresh.at === row.at ? fresh : row;
-  });
+function verdictCommand(options) {
+  const kind = options.judge === "verifier" ? "<live|unit>" : options.judge === "reviewer" ? "review" : "<live|unit|review>";
+  return [
+    "workit ledger verdict <verified|failed|blocked>",
+    `--kind ${kind}`,
+    `--branch ${options.branch ?? "<branch>"}`,
+    options.session ? `--session ${options.session}` : null,
+    options.token ? `--token=${options.token}` : null,
+    '--how "<what you ran and saw>"'
+  ].filter(Boolean).join(" ");
 }
-var untrusted = (reasons) => reasons.some((reason) => TRUST_REASONS.has(reason));
-var independenceReasons = (row, authors) => {
-  const reasons = [];
-  if (!row.actor.session)
-    reasons.push("no_session");
-  else if (authoredBy(authors, row.actor.session))
-    reasons.push("author_session");
-  if (row.self === true && !reasons.includes("no_session"))
-    reasons.push("self");
-  return reasons;
-};
-function effectiveOf(rows, reasonsOf, sameCode, isCurrent) {
-  let effective = null;
-  for (const row of rows) {
-    if (!effective) {
-      effective = row;
-      continue;
+function pruneIssued(dir, own, tokens) {
+  try {
+    const entries = fs5.readdirSync(dir);
+    if (entries.length <= ISSUED_PER_LEAD)
+      return;
+    const byAge = entries.filter((name) => name !== own).map((name) => ({ name, at: fs5.statSync(path8.join(dir, name)).mtimeMs })).toSorted((a, b) => a.at - b.at);
+    for (const { name } of byAge.slice(0, entries.length - ISSUED_PER_LEAD)) {
+      fs5.rmSync(path8.join(dir, name), { force: true });
+      fs5.rmSync(path8.join(tokens, name), { force: true });
     }
-    if (untrusted(reasonsOf(row)) && !untrusted(reasonsOf(effective)))
-      continue;
-    const rowIndependent = reasonsOf(row).length === 0;
-    const effIndependent = reasonsOf(effective).length === 0;
-    if (effIndependent && !rowIndependent && isCurrent(effective))
-      continue;
-    if (effIndependent && FAILING.has(String(effective.result)) && row.actor.session === effective.actor.session && sameCode(effective, row))
-      continue;
-    effective = row;
-  }
-  return effective;
+  } catch {}
 }
-function restackCarries(rows, branch, from, to) {
-  if (!from || !to)
-    return false;
-  const edges = new Map;
-  for (const row of rows)
-    if (row.type === "stack.restacked" && row.observer === "workit_cli" && row.integrity === "verified" && row.branch === branch && row.patchEqual === true && typeof row.fromHead === "string" && row.head)
-      edges.set(row.fromHead, [...edges.get(row.fromHead) ?? [], row.head]);
-  const seen = new Set([from]);
-  const queue = [from];
-  while (queue.length) {
-    const next = queue.shift();
-    if (next === to)
-      return true;
-    for (const target of edges.get(next) ?? [])
-      if (!seen.has(target)) {
-        seen.add(target);
-        queue.push(target);
-      }
+var issuedRecord = (cwd, claimed) => {
+  const cut = claimed.lastIndexOf(":");
+  if (cut <= 0)
+    return null;
+  migrateRepoIssued(cwd);
+  try {
+    return fs5.readFileSync(path8.join(userIssuedRoot(), hash(claimed.slice(0, cut)), hash(claimed)), "utf8");
+  } catch {
+    return null;
   }
-  return false;
+};
+var TOKEN_HASH = /^([0-9a-f]{64})$/mu;
+var issuedToken = (claimed) => {
+  const cut = claimed.lastIndexOf(":");
+  if (cut <= 0)
+    return { stored: null, leadBound: false };
+  const dir = path8.join(userTokenRoot(), hash(claimed.slice(0, cut)));
+  try {
+    const text = fs5.readFileSync(path8.join(dir, hash(claimed)), "utf8");
+    return { stored: TOKEN_HASH.exec(text)?.[1] ?? null, leadBound: true };
+  } catch {
+    return { stored: null, leadBound: safeList(dir).length > 0 };
+  }
+};
+function issuedBinding(cwd, claimed) {
+  const record = issuedRecord(cwd, claimed);
+  const { stored, leadBound } = issuedToken(claimed);
+  if (stored)
+    return "token";
+  if (record === null)
+    return null;
+  return leadBound ? "token" : "legacy";
 }
-function checkVerdicts(cwd, branch, ledgerRows) {
-  const rows = withIntegrity(cwd, ledgerRows);
-  const head = branchHead(cwd, branch);
-  const fallbackBase = defaultBase(cwd);
-  const scope = branchScope(cwd, branch);
-  const keyCache = new Map;
-  const keysAt = (base, at) => {
-    if (!base || !at)
-      return { patchId: null, diffHash: null };
-    const cacheKey = `${base}\x00${at}`;
-    let key = keyCache.get(cacheKey);
-    if (!key) {
-      key = { patchId: patchId(cwd, base, at), diffHash: diffHash(cwd, base, at) };
-      keyCache.set(cacheKey, key);
-    }
-    return key;
-  };
-  const keyFor = (base) => keysAt(base, head);
-  const basisOf = (row) => {
-    const basis = verdictBasis(row, { head, ...keyFor(row.base ?? fallbackBase) });
-    return basis === "stale" && restackCarries(rows, branch, row.head, head) ? "carried" : basis;
-  };
-  const sameCode = (failed, row) => {
-    if (failed.head && failed.head === row.head)
-      return true;
-    const base = failed.base ?? fallbackBase;
-    const stored = (row.base ?? fallbackBase) === base && row.baseSha !== null && row.baseSha === failed.baseSha;
-    const keys = stored ? { patchId: row.patchId, diffHash: row.diffHash } : keysAt(base, row.head);
-    return verdictBasis(failed, { head: row.head, ...keys }) !== "stale" || restackCarries(rows, branch, failed.head, row.head);
-  };
-  const authors = authorSessions(cwd, rows, branch, { base: fallbackBase, head }, scope);
-  const failureAuthorCache = new Map;
-  const failureAuthors = (row) => {
-    let set = failureAuthorCache.get(row.seq);
-    if (!set) {
-      set = authorSessions(cwd, rows.filter((other) => other.integrity === "verified" && other.seq < row.seq), branch, { base: null, head: null }, scope);
-      failureAuthorCache.set(row.seq, set);
-    }
-    return set;
-  };
-  const reasonCache = new Map;
-  const reasonsOf = (row) => {
-    let reasons = reasonCache.get(row);
-    if (!reasons) {
-      const failing = FAILING.has(String(row.result));
-      reasons = [
-        ...trustReasons(cwd, row),
-        ...independenceReasons(row, failing ? failureAuthors(row) : authors)
-      ];
-      reasonCache.set(row, reasons);
-    }
-    return reasons;
-  };
-  const retired = new Set;
-  for (const row of rows)
-    if (row.type === "verdict" && row.supersedes && !row.supersedeIgnored && trustReasons(cwd, row).length === 0)
-      retired.add(row.supersedes);
-  const byKind = new Map;
-  for (const row of rows)
-    if (isLiveVerdict(row, retired) && scope(row)) {
-      const kind = typeof row.kind === "string" ? row.kind : "review";
-      byKind.set(kind, [...byKind.get(kind) ?? [], row]);
-    }
-  const verdicts = [];
-  const warnings = [];
-  for (const [kind, list] of byKind) {
-    const row = effectiveOf(list, reasonsOf, sameCode, (candidate) => basisOf(candidate) !== "stale");
-    if (!row)
-      continue;
-    const basis = basisOf(row);
-    const current = basis !== "stale";
-    const independence = reasonsOf(row);
-    const reasons = [
-      ...current ? [] : ["stale"],
-      ...PASSING.has(String(row.result)) ? [] : ["not_passing"],
-      ...independence
-    ];
-    verdicts.push({
-      kind,
-      basis,
-      current,
-      independent: independence.length === 0,
-      accepted: reasons.length === 0,
-      reasons,
-      verdict: row
-    });
-    if (reasons.length === 0) {
-      for (const later of list)
-        if (later.seq > row.seq && reasonsOf(later).length > 0 && !untrusted(reasonsOf(later)) && FAILING.has(String(later.result)) && basisOf(later) !== "stale")
-          warnings.push(`the author's own (self) ${String(later.result)} ${kind} verdict ${later.id} by ${later.actor.session ?? "no session"} on the current code is newer than the accepted pass ${row.id}: read it before merging`);
+var OWN_CHILD_SHELL = new Set(["opencode", "pi"]);
+
+// packages/workit-core/src/hooks/standing-signal.ts
+import { createHash as createHash8 } from "node:crypto";
+import fs6 from "node:fs";
+import path9 from "node:path";
+var gitStoreDir = (cwd) => {
+  try {
+    for (let dir = path9.resolve(cwd);; dir = path9.dirname(dir)) {
+      const dotGit = path9.join(dir, ".git");
+      if (fs6.existsSync(dotGit)) {
+        let gitDir = dotGit;
+        if (fs6.statSync(dotGit).isFile()) {
+          const target = /^gitdir:\s*(.+)$/mu.exec(fs6.readFileSync(dotGit, "utf8"))?.[1]?.trim();
+          if (!target)
+            return null;
+          gitDir = path9.resolve(dir, target);
+          const common = path9.join(gitDir, "commondir");
+          if (fs6.existsSync(common))
+            gitDir = path9.resolve(gitDir, fs6.readFileSync(common, "utf8").trim());
+        }
+        return path9.join(gitDir, "workit");
+      }
+      if (path9.dirname(dir) === dir)
+        return null;
     }
+  } catch {
+    return null;
   }
-  for (const row of rows)
-    if (row.integrity === "unverified" && scope(row))
-      warnings.push(`ledger row ${row.id} (${row.type}) on ${row.branch ?? branch} is unverified: the workit CLI did not write it or it changed afterwards (workit ledger verify-integrity)`);
-  const tampered = ledgerTampering(cwd);
-  if (tampered.length) {
-    warnings.push(tamperedWarning(cwd, tampered));
-    for (const entry of verdicts) {
-      entry.accepted = false;
-      entry.reasons = [...entry.reasons, "ledger_tampered"];
-    }
+};
+var standingRevFile = (store) => path9.join(store, "standing", "rev");
+var standingSeenFile = (store, session, agentId) => path9.join(store, "standing", "seen", `${createHash8("sha256").update(`${session}\x00${agentId ?? ""}`).digest("hex").slice(0, 32)}.json`);
+var readStandingRev = (store) => {
+  try {
+    return fs6.readFileSync(standingRevFile(store), "utf8").trim() || null;
+  } catch {
+    return null;
   }
-  verdicts.sort((a, b) => a.verdict.seq - b.verdict.seq);
-  const newestCurrent = verdicts.findLast((entry) => entry.current) ?? verdicts.at(-1) ?? null;
-  const failing = verdicts.find((entry) => entry.current && entry.independent && FAILING.has(String(entry.verdict.result)));
-  const newestAccepted = verdicts.findLast((entry) => entry.accepted && STRONG_RESULTS.has(String(entry.verdict.result))) ?? null;
-  const accepted = tampered.length ? { accepted: false, verdict: null, reasons: ["ledger_tampered"] } : newestAccepted && !failing ? { accepted: true, verdict: newestAccepted.verdict, reasons: [] } : {
-    accepted: false,
-    verdict: failing?.verdict ?? null,
-    reasons: failing ? ["failing_verdict"] : !newestCurrent ? ["no_verdict"] : newestCurrent.reasons.length ? newestCurrent.reasons : ["type_check_only"]
-  };
-  const latestSelf = failing ? undefined : verdicts.findLast((entry) => entry.current && !entry.independent && !untrusted(entry.reasons) && (STRONG_RESULTS.has(String(entry.verdict.result)) || FAILING.has(String(entry.verdict.result))));
-  const selfEntry = latestSelf && STRONG_RESULTS.has(String(latestSelf.verdict.result)) ? latestSelf : undefined;
-  return {
-    branch,
-    head,
-    review: accepted.accepted ? "verified" : selfEntry ? "self-reviewed" : "unreviewed",
-    selfVerdict: accepted.accepted ? null : selfEntry?.verdict ?? null,
-    base: newestCurrent?.verdict.base ?? fallbackBase,
-    patchId: keyFor(newestCurrent?.verdict.base ?? fallbackBase).patchId,
-    current: { basis: newestCurrent?.basis ?? "none", verdict: newestCurrent?.verdict ?? null },
-    accepted,
-    verdicts,
-    authors: [...authors].toSorted(),
-    warnings
-  };
-}
-var fromLead = (row, leads) => leads === null || row.actor.session !== null && leads.includes(row.actor.session);
-function activeStanding(rows, fanout, leads = null) {
-  const active = [];
-  for (const row of rows) {
-    if (row.fanout !== fanout || !fromLead(row, leads))
-      continue;
-    if (row.type === "standing" && typeof row.what === "string" && row.what.trim()) {
-      if (!row.superseded)
-        active.push(row);
-    } else if (row.type === "standing.cleared") {
-      const target = str(row.target);
-      if (target === null)
-        active.length = 0;
-      else {
-        const index = active.findIndex((order) => order.id === target);
-        if (index >= 0)
-          active.splice(index, 1);
-      }
-    }
+};
+var readStandingSeen = (file) => {
+  try {
+    const value = JSON.parse(fs6.readFileSync(file, "utf8"));
+    return {
+      rev: typeof value.rev === "string" ? value.rev : null,
+      ids: Array.isArray(value.ids) ? value.ids.filter((id) => typeof id === "string") : []
+    };
+  } catch {
+    return { rev: null, ids: [] };
   }
-  return active;
-}
-var OBSERVED_ONLY = new Set([
-  "check",
-  "merge.unverified",
-  "policy.judged",
-  ...PR_ROW_TYPES
-]);
-
-// packages/workit-core/src/core/policy/lane.ts
-import { existsSync as existsSync2, readFileSync as readFileSync3 } from "node:fs";
-import path10 from "node:path";
-// packages/workit-core/src/forge/redact.ts
-var KEY = String.raw`[A-Za-z0-9_.-]*?(?:token|secret|password|passwd|pwd|api[_-]?key|access[_-]?key|account[_-]?key|private[_-]?key|client[_-]?secret|credentials?|authorization|cookie|signature)[A-Za-z0-9_.-]*`;
-var ASSIGNMENT = new RegExp(String.raw`(?<![A-Za-z0-9])(["']?${KEY}["']?\s*[:=]\s*["']?)((?:bearer|basic|token|digest)\s+)?([^\s"',;&]+)`, "giu");
-var QUOTED_ASSIGNMENT = new RegExp(String.raw`(?<![A-Za-z0-9])(["']?${KEY}["']?\s*[:=]\s*)(["'])([^"'\n]*[^\s"'][^"'\n]*)\2`, "giu");
-var ANSI = new RegExp(String.raw`\u001b\[[0-9;?]*[ -/]*[@-~]|\u001b\][^\u0007]*\u0007`, "gu");
-
-// packages/workit-core/src/git/ops.ts
-var COMMIT_TIMEOUT_MS = 10 * 60000;
+};
+var writeStandingSeen = (file, seen) => {
+  try {
+    fs6.mkdirSync(path9.dirname(file), { recursive: true });
+    fs6.writeFileSync(file, JSON.stringify(seen));
+  } catch {}
+};
 
-// packages/workit-core/src/core/policy/attributes.ts
-function patternRegex(dir, pattern) {
-  if (!pattern || pattern.endsWith("/") || pattern.startsWith('"') || pattern.startsWith("!"))
+// packages/workit-core/src/ledger.ts
+var LEDGER_VERSION = 1;
+var MAX_LINE_BYTES = 4096;
+var PASSING = new Set(["verified", "tests-verified", "type-check-only"]);
+var FAILING = new Set(["failed", "blocked"]);
+var STRONG_RESULTS = new Set(["verified", "tests-verified"]);
+var PR_ROW_TYPES = new Set([
+  "pr.created",
+  "pr.status",
+  "pr.merged",
+  "pr.linked"
+]);
+var err = (code, error, unblock) => ({
+  ok: false,
+  code,
+  error,
+  ...unblock ? { unblock } : {}
+});
+var gitRun2 = (cwd, args, timeoutMs = GIT_TIMEOUTS.local) => {
+  const run = spawnSync8("git", args, {
+    cwd,
+    encoding: "utf8",
+    timeout: timeoutMs,
+    killSignal: "SIGKILL",
+    windowsHide: true,
+    maxBuffer: 256 * 1024 * 1024,
+    env: {
+      ...process.env,
+      GIT_TERMINAL_PROMPT: "0",
+      GIT_OPTIONAL_LOCKS: "0",
+      LC_ALL: "C",
+      LANGUAGE: "C"
+    }
+  });
+  return {
+    ok: run.status === 0,
+    stdout: run.stdout ?? "",
+    stderr: run.error ? String(run.error.message) : run.stderr ?? ""
+  };
+};
+var git3 = (cwd, args) => {
+  const run = gitRun2(cwd, args);
+  const value = run.ok ? run.stdout.trim() : "";
+  return value ? value : null;
+};
+var safeRef2 = (value) => value.length > 0 && !value.startsWith("-");
+function resolveCommit(cwd, ref) {
+  if (!safeRef2(ref))
     return null;
-  const anchored = pattern.includes("/");
-  const body = pattern.replace(/^\//u, "");
-  let source = "";
-  for (let index = 0;index < body.length; index += 1) {
-    const char = body[index];
-    if (char === "*" && body[index + 1] === "*") {
-      const slash = body[index + 2] === "/";
-      source += slash ? "(?:.*/)?" : ".*";
-      index += slash ? 2 : 1;
-    } else if (char === "*")
-      source += "[^/]*";
-    else if (char === "?")
-      source += "[^/]";
-    else if (char === "[") {
-      const end = body.indexOf("]", index + 2);
-      if (end < 0)
-        return null;
-      const set = body.slice(index + 1, end).replace(/^!/u, "^").replace(/\\/gu, "\\\\");
-      source += `[${set}]`;
-      index = end;
-    } else if (char === "\\" && index + 1 < body.length) {
-      source += body[index + 1].replace(/[.*+?^${}()|[\]\\/]/gu, "\\$&");
-      index += 1;
-    } else
-      source += char.replace(/[.*+?^${}()|[\]\\/]/gu, "\\$&");
-  }
-  const prefix = dir ? `${dir.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&")}/` : "";
-  try {
-    return new RegExp(anchored ? `^${prefix}${source}$` : `^${prefix}(?:.*/)?${source}$`, "u");
-  } catch {
+  return git3(cwd, ["rev-parse", "--verify", "-q", `${ref}^{commit}`]);
+}
+function branchHead(cwd, branch) {
+  if (!safeRef2(branch))
     return null;
-  }
+  return resolveCommit(cwd, `refs/heads/${branch}`) ?? resolveCommit(cwd, `refs/remotes/origin/${branch}`);
 }
-function rulesOf(dir, text) {
-  const out = [];
-  for (const raw of text.split(`
+function diffHash(cwd, base, head) {
+  if (!safeRef2(base) || !safeRef2(head))
+    return null;
+  const diff = gitRun2(cwd, [
+    "diff",
+    "-U3",
+    "--diff-algorithm=myers",
+    "--indent-heuristic",
+    "--no-color",
+    "--no-ext-diff",
+    "--no-textconv",
+    "--no-renames",
+    "--full-index",
+    "--binary",
+    "--src-prefix=a/",
+    "--dst-prefix=b/",
+    `${base}...${head}`,
+    "--"
+  ], GIT_TIMEOUTS.worktree);
+  if (!diff.ok || !diff.stdout)
+    return null;
+  const hash = createHash9("sha256");
+  for (const line of diff.stdout.split(`
 `)) {
-    const line = raw.trim();
-    if (!line || line.startsWith("#") || line.startsWith("[attr]"))
-      continue;
-    const [pattern, ...attributes] = line.split(/\s+/u);
-    let generated = null;
-    for (const attribute of attributes) {
-      if (attribute === "linguist-generated" || attribute === "linguist-generated=true")
-        generated = true;
-      else if (attribute === "-linguist-generated" || attribute === "!linguist-generated" || attribute.startsWith("linguist-generated="))
-        generated = false;
-    }
-    if (generated === null)
+    if (line.startsWith("index "))
       continue;
-    const regex = patternRegex(dir, pattern);
-    if (regex)
-      out.push({ regex, generated });
+    hash.update(line.startsWith("@@ ") ? "@@" : line);
+    hash.update(`
+`);
   }
-  return out;
+  return `sha256:${hash.digest("hex")}`;
 }
-function generatedByAttributes(files, paths) {
-  const rules = [...files].map(([file, text]) => {
-    const dir = file.includes("/") ? file.slice(0, file.lastIndexOf("/")) : "";
-    return {
-      depth: dir ? dir.split("/").length : 0,
-      rules: rulesOf(dir, text)
-    };
-  }).toSorted((left, right) => left.depth - right.depth).flatMap((entry) => entry.rules);
-  const out = new Set;
-  for (const file of paths) {
-    const last = rules.findLast((rule) => rule.regex.test(file));
-    if (last?.generated)
-      out.add(file);
-  }
-  return out;
+function storeRoot(cwd) {
+  const location = resolveStore(path10.resolve(cwd));
+  if (location instanceof Error)
+    return err("unavailable", location.message.replace(/; fix the repository.*$/u, ""), "fix the repository (git status should work here) or run from a non-git directory");
+  return { ok: true, value: { root: location.dir, shared: location.shared } };
 }
-
-// packages/workit-core/src/core/policy/substance.ts
-var SLASH_BLOCK = [["/*", "*/"]];
-var C_LIKE = { line: ["//"], block: SLASH_BLOCK, quotes: `"'` };
-var SYNTAXES = Object.fromEntries([
-  ...["ts", "mts", "cts", "js", "mjs", "cjs"].map((ext) => [ext, { ...C_LIKE, js: true }]),
-  ...["java", "kt", "kts", "scala", "swift", "dart", "groovy"].map((ext) => [
-    ext,
-    { ...C_LIKE, triple: true }
-  ]),
-  ["go", { ...C_LIKE, rawBacktick: true }],
-  ...["css", "scss", "less"].map((ext) => [
-    ext,
-    { line: [], block: SLASH_BLOCK, quotes: `"'`, cssUrl: true }
-  ]),
-  ...["py", "pyi"].map((ext) => [
-    ext,
-    { line: ["#"], block: [], quotes: `"'`, triple: true, indented: true, fstring: true }
-  ]),
-  ["toml", { line: ["#"], block: [], quotes: `"`, literal: "'", triple: true }],
-  ...["html", "htm", "xml", "svg", "xhtml"].map((ext) => [
-    ext,
-    { line: [], block: [["<!--", "-->"]], quotes: "", indented: true }
-  ])
+function ledgerPath(cwd) {
+  const root = storeRoot(cwd);
+  return root.ok ? { ok: true, value: path10.join(root.value.root, "ledger", "ledger.jsonl") } : root;
+}
+var newId2 = () => `${Date.now().toString(36)}-${randomBytes2(6).toString("hex")}`;
+var NETWORK_FS_TYPES = new Set([
+  26985,
+  20859,
+  4266872130,
+  4283649346,
+  1702057286,
+  1397113167,
+  12805120,
+  16914839,
+  1196443219,
+  198183888
 ]);
-var DIRECTIVE = /@ts-|eslint|prettier|biome|oxlint|istanbul|\bc8\b|\bv8\b|@jsx|@flow|@vite|webpack|__PURE__|__NO_SIDE_EFFECTS__|source(?:Mapping)?URL|^\/\s*<|go:|\+build|nolint|noqa|type:|pyright|mypy|pylint|pragma|coding[:=]|fmt:|NOSONAR|@license|@preserve|@refresh|environment|language=|cython|ruff|isort|deno-|@vitest|@jest|swiftlint|ktlint|checkstyle|suppress|nullable|#(?:end)?region/iu;
-var extensionOf = (file) => {
-  const name = file.slice(file.lastIndexOf("/") + 1);
-  const dot = name.lastIndexOf(".");
-  return dot > 0 ? name.slice(dot + 1).toLowerCase() : "";
+var isNetworkFsType = (type) => NETWORK_FS_TYPES.has(type >>> 0);
+var onNetworkFs = (dir) => {
+  if (process.platform !== "linux")
+    return false;
+  try {
+    return isNetworkFsType(fs7.statfsSync(dir).type);
+  } catch {
+    return false;
+  }
 };
-var CI_PATH = /^\.github\/|(?:^|\/)(?:\.gitlab-ci\.ya?ml|Jenkinsfile|azure-pipelines\.ya?ml|\.pre-commit-config\.ya?ml|\.circleci\/.*)$/u;
-var syntaxOf = (file) => CI_PATH.test(file) ? null : SYNTAXES[extensionOf(file)] ?? null;
-var SPACE = /[ \t\r\f\v]/u;
-var WORD = /[\w$]/u;
-var NO_SPACE_AFTER = "([{,;";
-var NO_SPACE_BEFORE = ")]},;";
-var REGEX_AFTER = "(,=:[!&|?{};+-*%<>~^";
-var REGEX_KEYWORDS = new Set([
-  "return",
-  "typeof",
-  "instanceof",
-  "case",
-  "do",
-  "else",
-  "in",
-  "of",
-  "new",
-  "delete",
-  "void",
-  "throw",
-  "yield",
-  "await"
-]);
-function substanceOf(file, text) {
-  const syntax = syntaxOf(file);
-  if (!syntax)
-    return plainSubstance(text);
-  const markup = syntax.block.some(([open]) => open === "<!--");
-  if (markup && (/<(?:script|style)\b|<!\[CDATA\[|<\?/iu.test(text) || /[^>\s][ \t]*<!--/u.test(text)))
-    return plainSubstance(text);
-  return lex(syntax, text);
-}
-function plainSubstance(text) {
-  return text.split(`
-`).map((line) => line.replace(/[ \t\r\f\v]+$/u, "")).filter(Boolean).join(`
-`);
-}
-function lex(syntax, text) {
-  const collapse = !syntax.indented;
-  let out = "";
-  let lineStart = 0;
-  let kept = 0;
-  let pendingSpace = false;
-  const frames = [{ kind: "code", braces: 0 }];
-  let index = 0;
-  if (text.startsWith("#!")) {
-    const end = text.indexOf(`
-`);
-    out = end < 0 ? text : text.slice(0, end);
-    kept = out.length;
-    index = end < 0 ? text.length : end;
+var LOCK_WAIT_MS = 5000;
+var LOCK_STALE_MS = 30000;
+var LOCK_OWNER = "owner";
+var lockToken = (lock) => {
+  try {
+    return fs7.readFileSync(path10.join(lock, LOCK_OWNER), "utf8");
+  } catch {
+    return null;
   }
-  const emitCode = (chunk) => {
-    if (collapse && pendingSpace && out.length > lineStart) {
-      const before = out[out.length - 1];
-      if (!NO_SPACE_AFTER.includes(before) && !NO_SPACE_BEFORE.includes(chunk[0]))
-        out += " ";
-    }
-    pendingSpace = false;
-    out += chunk;
-  };
-  const emitVerbatim = (chunk) => {
-    emitCode(chunk);
-    kept = out.length;
-  };
-  const newline = () => {
-    if (!collapse) {
-      let end = out.length;
-      while (end > Math.max(lineStart, kept) && SPACE.test(out[end - 1]))
-        end -= 1;
-      out = out.slice(0, end);
-    }
-    pendingSpace = false;
-    if (out.length > lineStart) {
-      out += `
-`;
-      lineStart = out.length;
-    }
-  };
-  const regexAllowed = () => {
-    let end = out.length;
-    while (end > 0 && /\s/u.test(out[end - 1]))
-      end -= 1;
-    if (end === 0 || REGEX_AFTER.includes(out[end - 1]))
-      return true;
-    let start = end;
-    while (start > 0 && WORD.test(out[start - 1]))
-      start -= 1;
-    return REGEX_KEYWORDS.has(out.slice(start, end));
-  };
-  const scanString = (quote, escapes, multiline) => {
-    const prefix = text.slice(Math.max(0, index - 2), index).match(/[a-z]*$/iu)?.[0] ?? "";
-    const fstring = syntax.fstring === true && /f/iu.test(prefix);
-    let end = index + quote.length;
-    while (end < text.length) {
-      const char = text[end];
-      if (escapes && char === "\\") {
-        end += 2;
-        continue;
-      }
-      if (text.startsWith(quote, end)) {
-        if (fstring && unbalanced(text.slice(index + quote.length, end)))
-          return false;
-        emitVerbatim(text.slice(index, end + quote.length));
-        index = end + quote.length;
-        return true;
-      }
-      if (char === `
-` && !multiline)
-        return false;
-      end += 1;
+};
+var lockAgeMs = (lock) => {
+  for (const target of [path10.join(lock, LOCK_OWNER), lock]) {
+    try {
+      return Date.now() - fs7.statSync(target).mtimeMs;
+    } catch {}
+  }
+  return null;
+};
+var ledgerLock = {
+  acquire(lock) {
+    try {
+      fs7.mkdirSync(lock);
+    } catch (error) {
+      if (error.code === "EEXIST")
+        return null;
+      throw error;
     }
-    return false;
-  };
-  while (index < text.length) {
-    const frame = frames[frames.length - 1];
-    const char = text[index];
-    if (frame.kind === "template") {
-      if (char === "\\") {
-        emitVerbatim(text.slice(index, index + 2));
-        index += 2;
-      } else if (char === "`") {
-        emitVerbatim(char);
-        frames.pop();
-        index += 1;
-      } else if (text.startsWith("${", index)) {
-        emitVerbatim("${");
-        frames.push({ kind: "code", braces: 0 });
-        index += 2;
-      } else {
-        out += char;
-        kept = out.length;
-        index += 1;
-      }
-      continue;
+    const token = `${process.pid}-${randomBytes2(8).toString("hex")}`;
+    fs7.writeFileSync(path10.join(lock, LOCK_OWNER), token);
+    return token;
+  },
+  release(lock, token) {
+    if (lockToken(lock) !== token)
+      return false;
+    const tomb = `${lock}.release-${randomBytes2(6).toString("hex")}`;
+    try {
+      fs7.renameSync(lock, tomb);
+    } catch {
+      return false;
     }
-    if (char === `
-`) {
-      newline();
-      index += 1;
-      continue;
+    if (lockToken(tomb) !== token) {
+      try {
+        fs7.renameSync(tomb, lock);
+      } catch {}
+      return false;
     }
-    if (SPACE.test(char)) {
-      if (collapse)
-        pendingSpace = true;
-      else
-        out += char;
-      index += 1;
-      continue;
+    fs7.rmSync(tomb, { recursive: true, force: true });
+    return true;
+  },
+  token: lockToken,
+  reap(lock, observed) {
+    const tomb = `${lock}.reap-${randomBytes2(6).toString("hex")}`;
+    try {
+      fs7.renameSync(lock, tomb);
+    } catch {
+      return false;
     }
-    const lineOpener = syntax.line.find((opener) => text.startsWith(opener, index));
-    if (lineOpener) {
-      const end = text.indexOf(`
-`, index);
-      const comment = text.slice(index, end < 0 ? text.length : end);
-      if (DIRECTIVE.test(comment.slice(lineOpener.length)))
-        emitVerbatim(comment);
-      else
-        pendingSpace = true;
-      index = end < 0 ? text.length : end;
-      continue;
+    if (lockToken(tomb) === observed) {
+      fs7.rmSync(tomb, { recursive: true, force: true });
+      return true;
     }
-    const block = syntax.block.find(([open]) => text.startsWith(open, index));
-    if (block) {
-      const end = text.indexOf(block[1], index + block[0].length);
-      if (end < 0)
-        return null;
-      const comment = text.slice(index, end + block[1].length);
-      if (DIRECTIVE.test(comment.slice(block[0].length, -block[1].length)))
-        emitVerbatim(comment);
-      else
-        pendingSpace = true;
-      if (comment.includes(`
-`))
-        newline();
-      index = end + block[1].length;
-      continue;
+    try {
+      fs7.renameSync(tomb, lock);
+    } catch {
+      fs7.rmSync(tomb, { recursive: true, force: true });
     }
-    if (syntax.triple && (char === '"' || char === "'") && text.startsWith(char.repeat(3), index)) {
-      if (!scanString(char.repeat(3), !syntax.literal?.includes(char), true))
-        return null;
+    return false;
+  }
+};
+function withLedgerLock(file, fn, waitMs = hostAwareLockTimeout(LOCK_WAIT_MS)) {
+  const lock = `${file}.lock`;
+  const deadline = Date.now() + waitMs;
+  let token = null;
+  for (;; ) {
+    token = ledgerLock.acquire(lock);
+    if (token)
+      break;
+    const observed = lockToken(lock);
+    const age = lockAgeMs(lock);
+    if (age !== null && age > LOCK_STALE_MS && ledgerLock.reap(lock, observed))
       continue;
-    }
-    if (syntax.quotes.includes(char)) {
-      if (!scanString(char, true, Boolean(syntax.multiline)))
+    if (Date.now() >= deadline)
+      return null;
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 25);
+  }
+  try {
+    return fn();
+  } finally {
+    ledgerLock.release(lock, token);
+  }
+}
+var sha2562 = (text) => createHash9("sha256").update(text).digest("hex");
+var chainHash = (prevHash, body) => sha2562(`${prevHash ?? ""}
+${body}`);
+var TAIL_BYTES = 64 * 1024;
+var lastLine = (fd, size) => {
+  for (let span = Math.min(size, TAIL_BYTES);span > 0; span = Math.min(size, span * 2)) {
+    const buffer = Buffer.alloc(span);
+    fs7.readSync(fd, buffer, 0, span, size - span);
+    const end = buffer.lastIndexOf(10);
+    if (end < 0) {
+      if (span === size)
         return null;
       continue;
     }
-    if (syntax.literal?.includes(char)) {
-      if (!scanString(char, false, false))
-        return null;
-      continue;
-    }
-    if (syntax.rawBacktick && char === "`") {
-      if (!scanString("`", false, true))
-        return null;
-      continue;
-    }
-    if (syntax.js && char === "`") {
-      emitVerbatim(char);
-      frames.push({ kind: "template" });
-      index += 1;
-      continue;
-    }
-    if (syntax.cssUrl && /^url\(\s*[^"')\s]/iu.test(text.slice(index, index + 64)))
-      return null;
-    if (syntax.js && char === "/" && !regexAllowed() && out.trimEnd().endsWith(")")) {
-      const lineEnd = text.indexOf(`
-`, index);
-      if (text.slice(index + 1, lineEnd < 0 ? text.length : lineEnd).includes("/"))
-        return null;
-    }
-    if (syntax.js && char === "/" && regexAllowed()) {
-      let end = index + 1;
-      let inClass = false;
-      while (end < text.length && (inClass || text[end] !== "/")) {
-        if (text[end] === `
-`)
+    let stop = end;
+    let text = "";
+    while (stop >= 0) {
+      const start = buffer.lastIndexOf(10, stop - 1);
+      text = buffer.toString("utf8", start + 1, stop).trim();
+      if (text) {
+        if (start >= 0 || span === size)
+          return text;
+        break;
+      }
+      if (start < 0) {
+        if (span === size)
           return null;
-        if (text[end] === "\\")
-          end += 1;
-        else if (text[end] === "[")
-          inClass = true;
-        else if (text[end] === "]")
-          inClass = false;
-        end += 1;
+        break;
       }
-      if (end >= text.length)
-        return null;
-      emitVerbatim(text.slice(index, end + 1));
-      index = end + 1;
-      continue;
+      stop = start;
     }
-    if (frames.length > 1 && frame.kind === "code") {
-      if (char === "{")
-        frame.braces += 1;
-      else if (char === "}") {
-        if (frame.braces === 0) {
-          emitVerbatim(char);
-          frames.pop();
-          index += 1;
-          continue;
-        }
-        frame.braces -= 1;
+    if (span === size)
+      return text || null;
+  }
+  return null;
+};
+var tighten = (fd) => {
+  try {
+    if ((fs7.fstatSync(fd).mode & 63) !== 0)
+      fs7.fchmodSync(fd, 384);
+  } catch {}
+};
+function appendLine(file, build, options) {
+  const write = () => {
+    const fd = fs7.openSync(file, "a+", 384);
+    try {
+      if (process.platform !== "win32")
+        tighten(fd);
+      const size = fs7.fstatSync(fd).size;
+      let fence = "";
+      if (size > 0) {
+        const last = Buffer.alloc(1);
+        fs7.readSync(fd, last, 0, 1, size - 1);
+        if (last[0] !== 10)
+          fence = `
+`;
       }
+      const line = build(lastLine(fd, size));
+      if (!line.ok)
+        return line;
+      const bytes = Buffer.from(fence + line.value);
+      const written = fs7.writeSync(fd, bytes);
+      if (written !== bytes.length)
+        return err("unavailable", `short write to ${file}: ${written} of ${bytes.length} bytes; the row is torn and will be skipped`);
+      return { ok: true, value: undefined };
+    } finally {
+      fs7.closeSync(fd);
     }
-    emitCode(char);
-    index += 1;
+  };
+  try {
+    fs7.mkdirSync(path10.dirname(file), { recursive: true });
+    if (!options.forceLock && !onNetworkFs(path10.dirname(file)))
+      return write();
+    const locked = withLedgerLock(file, write);
+    return locked ?? err("busy", `ledger lock ${file}.lock is held`, "retry; remove the .lock directory if no workit process is running");
+  } catch (error) {
+    return err("unavailable", `cannot append to ${file}: ${error.message}`);
   }
-  if (frames.length !== 1)
-    return null;
-  newline();
-  return out;
 }
-function unbalanced(body) {
-  let depth = 0;
-  for (const part of body.replaceAll("{{", "").replaceAll("}}", "")) {
-    if (part === "{")
-      depth += 1;
-    else if (part === "}")
-      depth = Math.max(0, depth - 1);
-  }
-  return depth > 0;
+var sealed = (row, id, at, previous) => {
+  const { prevHash: _prev, rowHash: _row, ...fields } = row;
+  const prevHash = previous === null ? null : sha2562(previous);
+  const body = { v: LEDGER_VERSION, id, at, ...fields, prevHash };
+  const full = { ...body, rowHash: chainHash(prevHash, JSON.stringify(body)) };
+  return { full, line: `${JSON.stringify(full)}
+` };
+};
+function appendRaw(cwd, row, options) {
+  const file = ledgerPath(cwd);
+  if (!file.ok)
+    return file;
+  const id = newId2();
+  const at = (options.now ?? new Date).toISOString();
+  let full = null;
+  const written = appendLine(file.value, (previous) => {
+    const next = sealed(row, id, at, previous);
+    const bytes = Buffer.byteLength(next.line);
+    if (bytes > MAX_LINE_BYTES)
+      return err("invalid_input", `ledger row is ${bytes} bytes; the limit is ${MAX_LINE_BYTES}. Shorten the text and pass details by --ref <path|url>`);
+    full = next.full;
+    return { ok: true, value: next.line };
+  }, options);
+  return written.ok ? { ok: true, value: full } : written;
 }
-function hasOpaqueLineBreak(text) {
-  return /\r(?!\n)|[\u2028\u2029]/u.test(text);
+function observedRowBytes(row) {
+  const sample = sealed({ ...row, observer: "workit_cli" }, newId2(), new Date().toISOString(), "");
+  return Buffer.byteLength(sample.line);
 }
-var decoder = new TextDecoder("utf-8", { fatal: true });
-function textOf(bytes) {
-  if (bytes.includes(0))
-    return null;
-  try {
-    return decoder.decode(bytes);
-  } catch {
-    return null;
-  }
+function appendObserved(cwd, row, options = {}) {
+  return appendRaw(cwd, { ...row, observer: "workit_cli" }, options);
 }
-function cosmeticChange(file, before, after) {
-  const left = textOf(before);
-  const right = textOf(after);
-  if (left === null || right === null)
-    return false;
-  if (hasOpaqueLineBreak(left) || hasOpaqueLineBreak(right))
-    return false;
-  const a = substanceOf(file, left);
-  return a !== null && a === substanceOf(file, right);
+function appendHookObserved(cwd, row) {
+  return appendRaw(cwd, { ...row, observer: "host_hook" }, {});
 }
-
-// packages/workit-core/src/core/policy/lane.ts
-var LANE_THRESHOLDS = {
-  selfMaxLines: 100,
-  selfMaxFiles: 5,
-  fullMinLines: 500
+var isRecord2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var str = (value) => typeof value === "string" ? value : null;
+var normalizeActor = (value) => {
+  const actor = isRecord2(value) ? value : {};
+  return {
+    host: str(actor.host) ?? "unknown",
+    session: str(actor.session),
+    agentId: str(actor.agentId)
+  };
 };
-var RISK_TOKENS = new Set([
-  "auth",
-  "authn",
-  "authz",
-  "oauth",
-  "security",
-  "permission",
-  "permissions",
-  "secret",
-  "secrets",
-  "crypto",
-  "gate",
-  "gates",
-  "policy",
-  "policies",
-  "hook",
-  "hooks",
-  "husky",
-  "lefthook",
-  "release",
-  "releases",
-  "migration",
-  "migrations",
-  "migrate",
-  "workflows"
-]);
-var RISK_FILES = new Set([
-  ".gitlab-ci.yml",
-  "Jenkinsfile",
-  "azure-pipelines.yml",
-  ".pre-commit-config.yaml",
-  ".workit/risk-paths"
-]);
-var RISK_NAMES = new Set([".gitattributes"]);
-var RISK_PATHS_FILE = ".workit/risk-paths";
-var LOCKFILES = new Set([
-  "bun.lock",
-  "bun.lockb",
-  "package-lock.json",
-  "npm-shrinkwrap.json",
-  "yarn.lock",
-  "pnpm-lock.yaml",
-  "Cargo.lock",
-  "go.sum",
-  "poetry.lock",
-  "uv.lock",
-  "Pipfile.lock",
-  "Gemfile.lock",
-  "composer.lock"
-]);
-var DOC_EXT = /\.(?:md|mdx|markdown|rst|adoc|txt)$/iu;
-var DOC_NAMES = /^(?:license|licence|notice|authors|changelog|changes|contributors)$/iu;
-var INSTRUCTIONS = /(?:^|\/)(?:AGENTS|CLAUDE|GEMINI|SKILL)\.md$|(?:^|\/)(?:skills|agents|commands|rules|prompts)\/[^/]+/iu;
-var TEST_PATH = /(?:^|\/)(?:test|tests|__tests__|spec|specs|fixtures)\/|\.(?:test|spec)\.[^/]+$/iu;
-var basename = (file) => file.slice(file.lastIndexOf("/") + 1);
-var isDoc = (file) => !INSTRUCTIONS.test(file) && (DOC_EXT.test(file) || DOC_NAMES.test(basename(file)));
-function kindOf(file) {
-  if (file.binary)
-    return "behavior";
-  if (file.generated)
-    return "generated";
-  if (LOCKFILES.has(basename(file.path)))
-    return "lockfile";
-  if (isDoc(file.path))
-    return "doc";
-  if (file.cosmetic)
-    return "cosmetic";
-  return TEST_PATH.test(file.path) ? "test" : "behavior";
+function supersedeAllowed(by, target, onBranch = (row) => (by.branch ?? null) === (row.branch ?? null)) {
+  if (by.type !== target.type)
+    return `a ${by.type} row cannot supersede a ${target.type} row`;
+  if (!by.actor.session || by.actor.session !== target.actor.session)
+    return "only the session that wrote a row can supersede it";
+  if (!onBranch(target))
+    return `the row is on another branch (${String(target.branch ?? "none")}); a row supersedes only one on its own branch`;
+  if (by.type === "verdict" && (by.kind ?? "review") !== (target.kind ?? "review"))
+    return `a ${String(by.kind ?? "review")} verdict cannot supersede a ${String(target.kind ?? "review")} verdict; record it with --kind ${String(target.kind ?? "review")}`;
+  if (by.type === "verdict" && by.self === true && target.self !== true)
+    return "a self verdict cannot replace an independent verdict";
+  return null;
 }
-var globCache = new Map;
-function globMatch(pattern, file) {
-  let regex = globCache.get(pattern);
-  if (!regex) {
-    let source = "";
-    for (let index = 0;index < pattern.length; index += 1) {
-      const char = pattern[index];
-      if (char === "*" && pattern[index + 1] === "*") {
-        source += pattern[index + 2] === "/" ? "(?:[^/]*/)*" : ".*";
-        index += pattern[index + 2] === "/" ? 2 : 1;
-      } else if (char === "*")
-        source += "[^/]*";
-      else if (char === "?")
-        source += "[^/]";
-      else
-        source += char.replace(/[.+^${}()|[\]\\]/gu, "\\$&");
+function readLedger(cwd, options = {}) {
+  const file = ledgerPath(cwd);
+  if (!file.ok)
+    return file;
+  let text = "";
+  let stat = null;
+  try {
+    stat = fs7.statSync(file.value);
+    text = fs7.readFileSync(file.value, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return {
+        ok: true,
+        value: {
+          path: file.value,
+          rows: [],
+          skipped: 0,
+          integrity: options.integrity ? { chained: 0, legacy: 0, unverified: [] } : null
+        }
+      };
+    return err("unavailable", `cannot read ${file.value}: ${error.message}`);
+  }
+  const rows = [];
+  let skipped = 0;
+  const integrity = { chained: 0, legacy: 0, unverified: [] };
+  const earlier = new Set([null]);
+  let chainStarted = false;
+  const ids = new Set;
+  for (const raw of text.split(`
+`)) {
+    const trimmed = raw.trim();
+    if (!trimmed)
+      continue;
+    const linked = (prevHash) => earlier.has(prevHash);
+    if (options.integrity)
+      earlier.add(sha2562(trimmed));
+    let parsed;
+    try {
+      parsed = JSON.parse(trimmed);
+    } catch {
+      skipped += 1;
+      continue;
     }
-    regex = new RegExp(`^${source}$`, "u");
-    globCache.set(pattern, regex);
+    if (!isRecord2(parsed) || !str(parsed.id) || !str(parsed.type) || !str(parsed.at)) {
+      skipped += 1;
+      continue;
+    }
+    let rowIntegrity = options.integrity ? "verified" : undefined;
+    let reason = null;
+    if (!options.integrity) {} else if (typeof parsed.rowHash === "string") {
+      chainStarted = true;
+      const { rowHash, ...body } = parsed;
+      const prevHash = str(parsed.prevHash);
+      if (chainHash(prevHash, JSON.stringify(body)) !== rowHash)
+        reason = "hash_mismatch";
+      else if (!linked(prevHash))
+        reason = "broken_link";
+    } else if (chainStarted)
+      reason = "unsigned";
+    else
+      rowIntegrity = "legacy";
+    if (options.integrity && !reason && ids.has(parsed.id))
+      reason = "duplicate_id";
+    if (options.integrity)
+      ids.add(parsed.id);
+    if (reason)
+      rowIntegrity = "unverified";
+    const pr = typeof parsed.pr === "number" && Number.isInteger(parsed.pr) ? parsed.pr : undefined;
+    const row = {
+      ...parsed,
+      v: typeof parsed.v === "number" ? parsed.v : LEDGER_VERSION,
+      id: parsed.id,
+      at: parsed.at,
+      type: parsed.type,
+      actor: normalizeActor(parsed.actor),
+      branch: str(parsed.branch),
+      head: str(parsed.head),
+      base: str(parsed.base),
+      baseSha: str(parsed.baseSha),
+      patchId: str(parsed.patchId),
+      diffHash: str(parsed.diffHash),
+      tree: str(parsed.tree),
+      dirty: typeof parsed.dirty === "boolean" ? parsed.dirty : null,
+      ...pr === undefined ? {} : { pr },
+      ...str(parsed.supersedes) ? { supersedes: parsed.supersedes } : {},
+      seq: rows.length + 1,
+      superseded: false,
+      supersedeIgnored: false,
+      ...rowIntegrity ? { integrity: rowIntegrity } : {},
+      ...reason ? { integrityReason: reason } : {}
+    };
+    rows.push(row);
+    if (!options.integrity)
+      continue;
+    if (rowIntegrity === "verified")
+      integrity.chained += 1;
+    else if (rowIntegrity === "legacy")
+      integrity.legacy += 1;
+    else if (reason)
+      integrity.unverified.push({
+        seq: row.seq,
+        id: row.id,
+        type: row.type,
+        branch: row.branch,
+        reason
+      });
   }
-  return regex.test(file) || file.startsWith(`${pattern.replace(/\/$/u, "")}/`);
-}
-function isRiskPath(file, extra = []) {
-  if (extra.some((pattern) => globMatch(pattern, file)))
-    return true;
-  if (RISK_FILES.has(file) || RISK_NAMES.has(basename(file)))
-    return true;
-  if (TEST_PATH.test(file) || isDoc(file))
-    return false;
-  return file.split("/").map((segment, index, all) => index === all.length - 1 ? segment.replace(/\.[^.]+$/u, "") : segment).some((segment) => segment.toLowerCase().split(/[-_.]/u).some((token) => RISK_TOKENS.has(token)));
-}
-var parseRiskPaths = (text) => text.split(`
-`).map((line) => line.trim()).filter((line) => line && !line.startsWith("#")).map((line) => line.replace(/^\//u, ""));
-function computeLane(input) {
-  const riskFiles = input.files.filter((file) => isRiskPath(file.path, input.riskPaths)).map((file) => file.path);
-  const risky = new Set(riskFiles);
-  const kinds = input.files.map((file) => ({
-    file,
-    kind: risky.has(file.path) ? "behavior" : kindOf(file)
-  }));
-  const behavior = kinds.filter((entry) => entry.kind === "behavior" || entry.kind === "test" || entry.kind === "lockfile");
-  const lines = behavior.filter((entry) => entry.kind !== "lockfile").reduce((sum, entry) => sum + entry.file.added + entry.file.deleted, 0);
-  const opaque = behavior.filter((entry) => entry.kind === "lockfile" || entry.file.binary);
-  const result = (lane, reasons) => ({
-    lane,
-    reasons,
-    lines,
-    files: behavior.length,
-    riskFiles
-  });
-  const { selfMaxLines, selfMaxFiles, fullMinLines } = LANE_THRESHOLDS;
-  if (input.riskTier === "high")
-    return result("full", ["the task judgment records high risk"]);
-  if (riskFiles.length)
-    return result("full", [
-      `touches a risk path: ${riskFiles.slice(0, 3).join(", ")}${riskFiles.length > 3 ? ", …" : ""}`
-    ]);
-  if (!behavior.length)
-    return result("none", [
-      input.files.length ? "only docs, comments, formatting or generated copies changed" : "no changes"
-    ]);
-  if (lines >= fullMinLines)
-    return result("full", [`large diff: ${lines} lines (≥ ${fullMinLines})`]);
-  if (lines > selfMaxLines)
-    return result("focused", [`${lines} lines changed (> ${selfMaxLines})`]);
-  if (behavior.length > selfMaxFiles)
-    return result("focused", [`${behavior.length} behavior files changed (> ${selfMaxFiles})`]);
-  if (opaque.length)
-    return result("focused", [
-      `a lockfile or binary changed: ${opaque.slice(0, 3).map((entry) => entry.file.path).join(", ")}${opaque.length > 3 ? ", …" : ""}`
-    ]);
-  return result("self", [
-    `small change: ${lines} line${lines === 1 ? "" : "s"} in ${behavior.length} file${behavior.length === 1 ? "" : "s"}, no risk path`
-  ]);
+  const scopes = new Map;
+  const scopeOf = (branch) => {
+    let scope = scopes.get(branch);
+    if (!scope)
+      scopes.set(branch, scope = branchScope(cwd, branch));
+    return scope;
+  };
+  const byId = new Map;
+  for (const row of rows) {
+    const target = row.supersedes ? byId.get(row.supersedes) : undefined;
+    if (target && row.integrity !== "unverified" && supersedeAllowed(row, target, renameAwareBranch(scopeOf, row.branch)) === null)
+      target.superseded = true;
+    else if (row.supersedes)
+      row.supersedeIgnored = true;
+    if (!byId.has(row.id))
+      byId.set(row.id, row);
+  }
+  if (options.integrity && stat && Buffer.byteLength(text) === stat.size)
+    tamperCache.set(file.value, {
+      size: stat.size,
+      stamp: fileStamp(stat),
+      breaks: integrity.unverified.filter((row) => TAMPER_REASONS.has(row.reason))
+    });
+  return {
+    ok: true,
+    value: { path: file.value, rows, skipped, integrity: options.integrity ? integrity : null }
+  };
 }
-function untrackedStat(cwd, file) {
+var TAMPER_REASONS = new Set(["hash_mismatch", "broken_link"]);
+var tamperCache = new Map;
+var fileStamp = (stat) => `${stat.ino}:${stat.mtimeMs}:${stat.ctimeMs}`;
+function ledgerTampering(cwd) {
+  const file = ledgerPath(cwd);
+  if (!file.ok)
+    return [];
   try {
-    const bytes = readFileSync3(path10.join(cwd, file));
-    if (bytes.includes(0))
-      return { path: file, added: 0, deleted: 0, binary: true };
-    const text = bytes.toString("utf8");
-    if (hasOpaqueLineBreak(text))
-      return { path: file, added: 0, deleted: 0, binary: true };
-    const lines = text.split(`
-`).length - (text.endsWith(`
-`) ? 1 : 0);
-    return { path: file, added: lines, deleted: 0 };
+    const stat = fs7.statSync(file.value);
+    const cached = tamperCache.get(file.value);
+    if (cached && cached.size === stat.size && cached.stamp === fileStamp(stat))
+      return cached.breaks;
   } catch {
-    return { path: file, added: 0, deleted: 0, binary: true };
+    return [];
   }
+  const read = readLedger(cwd, { integrity: true });
+  return read.ok ? (read.value.integrity?.unverified ?? []).filter((row) => TAMPER_REASONS.has(row.reason)) : [];
 }
-var REGULAR = new Set(["100644", "100755"]);
-var ABSENT = /^0+$/u;
-function cosmeticFiles(cwd, fork, head) {
-  const raw = diffRaw(cwd, fork, head);
-  if (!raw)
+function tamperedUnblock(cwd) {
+  const file = ledgerPath(cwd);
+  const where = file.ok ? file.value : "the ledger file";
+  return `workit ledger verify-integrity  # lists the edited or missing rows; if the edit is understood, move ${where} aside (mv ${where} ${where}.tampered-<date>) and record the verdicts again`;
+}
+var tamperedWarning = (cwd, breaks) => `the ledger was edited, or a row was removed or moved (${breaks.slice(0, 3).map((row) => `${row.reason} at row ${row.seq}`).join(", ")}${breaks.length > 3 ? ", …" : ""}): no verdict is accepted until it is repaired. ${tamperedUnblock(cwd)}`;
+function verdictBasis(verdict, current) {
+  if (verdict.head && verdict.head === current.head)
+    return "fresh";
+  if (verdict.patchId && verdict.patchId === current.patchId && verdict.diffHash && verdict.diffHash === current.diffHash)
+    return "carried";
+  return "stale";
+}
+var isLiveVerdict = (row, retired) => row.type === "verdict" && typeof row.result === "string" && !retired.has(row.id);
+function trailerSessions(cwd, base, head) {
+  if (!base || !head || !safeRef2(base) || !safeRef2(head))
+    return [];
+  const out = git3(cwd, [
+    "log",
+    "--format=%(trailers:key=Workit-Session,valueonly,separator=%x00)",
+    `${base}..${head}`
+  ]);
+  return (out ?? "").split(/[\0\n]/u).map((value) => value.trim()).filter(Boolean);
+}
+var RENAMED = /^branch: renamed refs\/heads\/(.+) to refs\/heads\/(.+)$/iu;
+function branchScope(cwd, branch) {
+  const renamedAt = new Map;
+  let since = Number.NEGATIVE_INFINITY;
+  if (safeRef2(branch)) {
+    const log = git3(cwd, [
+      "log",
+      "-g",
+      "--date=unix",
+      "--format=%gd%x09%gs",
+      `refs/heads/${branch}`,
+      "--"
+    ]);
+    for (const line of (log ?? "").split(`
+`)) {
+      const [selector = "", subject = ""] = line.split("\t");
+      const seconds = Number(/@\{(\d+)\}$/u.exec(selector)?.[1]);
+      if (!Number.isFinite(seconds))
+        continue;
+      since = seconds * 1000;
+      const match = RENAMED.exec(subject);
+      if (!match || match[1] === branch)
+        continue;
+      const until = (seconds + 1) * 1000;
+      renamedAt.set(match[1], Math.max(renamedAt.get(match[1]) ?? 0, until));
+    }
+  }
+  return (row) => {
+    if (row.branch === branch)
+      return true;
+    const until = row.branch === null ? undefined : renamedAt.get(row.branch);
+    if (until === undefined)
+      return false;
+    const at = Date.parse(row.at);
+    return at >= since && at <= until;
+  };
+}
+var renameAwareBranch = (scopeOf, branch) => {
+  return (target) => {
+    const own = typeof branch === "string" ? branch : null;
+    const theirs = typeof target.branch === "string" ? target.branch : null;
+    if (own === theirs)
+      return true;
+    if (own === null || theirs === null || typeof target.at !== "string")
+      return false;
+    return scopeOf(own)({ branch: theirs, at: target.at });
+  };
+};
+function authorSessions(cwd, rows, branch, range = { base: null, head: null }, scope = branchScope(cwd, branch)) {
+  const sessions = new Set;
+  for (const row of rows) {
+    if (!scope(row) || row.type !== "commit.recorded" && row.type !== "task.opened")
+      continue;
+    const session = str(row.session) ?? row.actor.session;
+    if (session)
+      sessions.add(session);
+  }
+  for (const session of trailerSessions(cwd, range.base, range.head))
+    sessions.add(session);
+  return sessions;
+}
+var derivesFrom = (derived, bare) => !bare.includes(":") && derived.endsWith(`:${bare}`);
+var authoredBy = (authors, session) => {
+  if (authors.has(session))
+    return true;
+  for (const author of authors)
+    if (derivesFrom(author, session) || derivesFrom(session, author))
+      return true;
+  return false;
+};
+var TRUST_REASONS = new Set([
+  "unsigned",
+  "hash_mismatch",
+  "broken_link",
+  "duplicate_id",
+  "unissued_session",
+  "unbound_session"
+]);
+var SHELL_VOUCHED_HOSTS = new Set([
+  "cli",
+  "opencode",
+  "pi",
+  "codex_cli",
+  "codex_desktop"
+]);
+function sessionTrust(cwd, row) {
+  const session = row.actor.session;
+  if (!session || row.self === true)
     return null;
-  const candidates = raw.filter((entry) => REGULAR.has(entry.oldMode) && entry.oldMode === entry.newMode && !ABSENT.test(entry.oldBlob) && (head === null || !ABSENT.test(entry.newBlob)));
-  const blobs = readBlobs(cwd, candidates.flatMap((entry) => [entry.oldBlob, entry.newBlob]));
-  if (!blobs)
+  const source = typeof row.sessionSource === "string" ? row.sessionSource : "env";
+  const host = row.actor.host;
+  const issuedOnly = source === "flag" ? host !== "cli" : source === "env" && session.includes(":") && !SHELL_VOUCHED_HOSTS.has(host);
+  if (!issuedOnly)
     return null;
-  const out = new Set;
-  const opaque = new Set;
-  for (const entry of candidates) {
-    const before = blobs.get(entry.oldBlob);
-    let after = blobs.get(entry.newBlob);
-    if (!after && head === null && ABSENT.test(entry.newBlob))
-      try {
-        after = readFileSync3(path10.join(cwd, entry.path));
-      } catch {
-        after = undefined;
-      }
-    if (before && after && cosmeticChange(entry.path, before, after))
-      out.add(entry.path);
-    else if ([before, after].some((bytes) => bytes && hasOpaqueLineBreak(bytes.toString("utf8"))))
-      opaque.add(entry.path);
+  const binding = issuedBinding(cwd, session);
+  if (binding === null)
+    return "unissued_session";
+  return binding === "token" && row.sessionBound !== true ? "unbound_session" : null;
+}
+function trustReasons(cwd, row) {
+  if (row.integrity === "unverified")
+    return [row.integrityReason ?? "unsigned"];
+  if (row.integrity !== "verified")
+    return ["unsigned"];
+  const session = sessionTrust(cwd, row);
+  return session ? [session] : [];
+}
+function withIntegrity(cwd, rows) {
+  if (rows.every((row) => row.integrity !== undefined))
+    return rows;
+  const read = readLedger(cwd, { integrity: true });
+  const bySeq = new Map(read.ok ? read.value.rows.map((row) => [row.seq, row]) : []);
+  return rows.map((row) => {
+    if (row.integrity !== undefined)
+      return row;
+    const fresh = bySeq.get(row.seq);
+    return fresh && fresh.id === row.id && fresh.at === row.at ? fresh : row;
+  });
+}
+var untrusted = (reasons) => reasons.some((reason) => TRUST_REASONS.has(reason));
+var independenceReasons = (row, authors) => {
+  const reasons = [];
+  if (!row.actor.session)
+    reasons.push("no_session");
+  else if (authoredBy(authors, row.actor.session))
+    reasons.push("author_session");
+  if (row.self === true && !reasons.includes("no_session"))
+    reasons.push("self");
+  return reasons;
+};
+function effectiveOf(rows, reasonsOf, sameCode, isCurrent) {
+  let effective = null;
+  for (const row of rows) {
+    if (!effective) {
+      effective = row;
+      continue;
+    }
+    if (untrusted(reasonsOf(row)) && !untrusted(reasonsOf(effective)))
+      continue;
+    const rowIndependent = reasonsOf(row).length === 0;
+    const effIndependent = reasonsOf(effective).length === 0;
+    if (effIndependent && !rowIndependent && isCurrent(effective))
+      continue;
+    if (effIndependent && FAILING.has(String(effective.result)) && row.actor.session === effective.actor.session && sameCode(effective, row))
+      continue;
+    effective = row;
   }
-  return { cosmetic: out, opaque };
+  return effective;
 }
-function generatedAt(cwd, fork, paths) {
-  const files = treeFilesNamed(cwd, fork, ".gitattributes");
-  const blobs = files?.size ? readBlobs(cwd, [...files.values()]) : null;
-  if (!files || !blobs)
-    return new Set;
-  const texts = new Map;
-  for (const [file, id] of files) {
-    const bytes = blobs.get(id);
-    if (bytes)
-      texts.set(file, bytes.toString("utf8"));
+var restackExact = new WeakMap;
+function restackCarries(exactIn, rows, branch, from, to) {
+  if (!from || !to)
+    return false;
+  const exact = (row, fromHead, head) => {
+    if (exactIn === null)
+      return true;
+    const cwd = exactIn;
+    let known = restackExact.get(row);
+    if (known === undefined) {
+      known = typeof row.fromBase === "string" && typeof row.toBase === "string" && sameOwnChange(cwd, {
+        from: fromHead,
+        to: head,
+        fromBase: row.fromBase,
+        toBase: row.toBase
+      });
+      restackExact.set(row, known);
+    }
+    return known;
+  };
+  const edges = new Map;
+  for (const row of rows)
+    if (row.type === "stack.restacked" && row.observer === "workit_cli" && row.integrity === "verified" && row.branch === branch && row.patchEqual === true && typeof row.fromHead === "string" && row.head && exact(row, row.fromHead, row.head))
+      edges.set(row.fromHead, [...edges.get(row.fromHead) ?? [], row.head]);
+  const seen = new Set([from]);
+  const queue = [from];
+  while (queue.length) {
+    const next = queue.shift();
+    if (next === to)
+      return true;
+    for (const target of edges.get(next) ?? [])
+      if (!seen.has(target)) {
+        seen.add(target);
+        queue.push(target);
+      }
   }
-  return generatedByAttributes(texts, paths);
-}
-var forkOf = (cwd, base, head) => mergeBase(cwd, base, head ?? "HEAD");
-function laneFiles(cwd, fork, head) {
-  const stats = diffNumstat(cwd, fork, head);
-  const cosmetic = stats ? cosmeticFiles(cwd, fork, head) : null;
-  if (!stats || !cosmetic)
-    return null;
-  const files = [
-    ...stats.map((entry) => ({
-      ...entry,
-      ...cosmetic.opaque.has(entry.path) ? { binary: true } : {},
-      cosmetic: !entry.binary && cosmetic.cosmetic.has(entry.path)
-    })),
-    ...head === null ? untrackedFiles(cwd).map((file) => untrackedStat(cwd, file)) : []
-  ];
-  const generated = generatedAt(cwd, fork, files.map((entry) => entry.path));
-  return files.map((entry) => ({
-    ...entry,
-    generated: generated.has(entry.path)
-  }));
+  return false;
 }
-function branchLane(cwd, options) {
-  const candidates = options.base ? [`origin/${options.base}`, options.base] : [];
-  const base = candidates.find((ref) => resolveRef(cwd, ref) !== null) ?? defaultBase(cwd) ?? null;
-  const head = options.workingTree ? null : options.head;
-  const fork = base && (options.workingTree || options.head) ? forkOf(cwd, base, head) : null;
-  const files = fork ? laneFiles(cwd, fork, head) : null;
-  const riskTier = options.judgment?.riskTier ?? null;
-  if (!fork || !files) {
-    const high = riskTier === "high";
-    return {
-      lane: high ? "full" : "focused",
-      reasons: [
-        `the diff of ${options.head?.slice(0, 12) ?? "(no head)"} against ${base ?? "(no base)"} cannot be read`,
-        ...high ? ["the task judgment records high risk"] : []
-      ],
-      lines: 0,
-      files: 0,
-      riskFiles: [],
-      base,
-      head: options.head
-    };
+function checkVerdicts(cwd, branch, ledgerRows) {
+  const rows = withIntegrity(cwd, ledgerRows);
+  const head = branchHead(cwd, branch);
+  const fallbackBase = defaultBase(cwd);
+  const scope = branchScope(cwd, branch);
+  const keyCache = new Map;
+  const keysAt = (base, at) => {
+    if (!base || !at)
+      return { patchId: null, diffHash: null };
+    const cacheKey = `${base}\x00${at}`;
+    let key = keyCache.get(cacheKey);
+    if (!key) {
+      key = { patchId: patchId(cwd, base, at), diffHash: diffHash(cwd, base, at) };
+      keyCache.set(cacheKey, key);
+    }
+    return key;
+  };
+  const keyFor = (base) => keysAt(base, head);
+  const driftCache = new Map;
+  const driftOf = (row) => {
+    if (driftCache.has(row))
+      return driftCache.get(row) ?? null;
+    let drift = null;
+    const toBase = row.base ?? fallbackBase;
+    const toBaseSha = toBase ? resolveCommit(cwd, toBase) : null;
+    const fromBase = row.baseSha ?? toBaseSha;
+    if (row.head && head && row.head !== head && toBaseSha && fromBase && !untrusted(reasonsOf(row)))
+      drift = verdictDrift(cwd, {
+        from: row.head,
+        to: head,
+        fromBase,
+        toBase: toBaseSha,
+        kind: typeof row.kind === "string" ? row.kind : "review"
+      });
+    driftCache.set(row, drift);
+    return drift;
+  };
+  const exactCache = new Map;
+  const exactCarry = (row) => {
+    if (FAILING.has(String(row.result)))
+      return true;
+    let exact = exactCache.get(row);
+    if (exact === undefined) {
+      const toBase = row.base ?? fallbackBase;
+      const toBaseSha = toBase ? resolveCommit(cwd, toBase) : null;
+      const fromBase = row.baseSha ?? toBaseSha;
+      exact = Boolean(row.head && head && toBaseSha && fromBase && sameOwnChange(cwd, { from: row.head, to: head, fromBase, toBase: toBaseSha }));
+      exactCache.set(row, exact);
+    }
+    return exact;
+  };
+  const keyBasis = (row) => {
+    const basis = verdictBasis(row, { head, ...keyFor(row.base ?? fallbackBase) });
+    return basis === "carried" && !exactCarry(row) ? "stale" : basis;
+  };
+  const restacked = (row) => restackCarries(FAILING.has(String(row.result)) ? null : cwd, rows, branch, row.head, head);
+  const carryOf = (row) => {
+    if (keyBasis(row) !== "stale")
+      return null;
+    if (restacked(row))
+      return null;
+    const drift = driftOf(row);
+    return drift?.carries ? { rule: drift.rule, since: drift.since, files: drift.files } : null;
+  };
+  const basisOf = (row) => {
+    const basis = keyBasis(row);
+    if (basis !== "stale")
+      return basis;
+    return restacked(row) || carryOf(row) ? "carried" : basis;
+  };
+  const sameCode = (failed, row) => {
+    if (failed.head && failed.head === row.head)
+      return true;
+    const base = failed.base ?? fallbackBase;
+    const stored = (row.base ?? fallbackBase) === base && row.baseSha !== null && row.baseSha === failed.baseSha;
+    const keys = stored ? { patchId: row.patchId, diffHash: row.diffHash } : keysAt(base, row.head);
+    return verdictBasis(failed, { head: row.head, ...keys }) !== "stale" || restackCarries(null, rows, branch, failed.head, row.head);
+  };
+  const authors = authorSessions(cwd, rows, branch, { base: fallbackBase, head }, scope);
+  const failureAuthorCache = new Map;
+  const failureAuthors = (row) => {
+    let set = failureAuthorCache.get(row.seq);
+    if (!set) {
+      set = authorSessions(cwd, rows.filter((other) => other.integrity === "verified" && other.seq < row.seq), branch, { base: null, head: null }, scope);
+      failureAuthorCache.set(row.seq, set);
+    }
+    return set;
+  };
+  const reasonCache = new Map;
+  const reasonsOf = (row) => {
+    let reasons = reasonCache.get(row);
+    if (!reasons) {
+      const failing = FAILING.has(String(row.result));
+      reasons = [
+        ...trustReasons(cwd, row),
+        ...independenceReasons(row, failing ? failureAuthors(row) : authors)
+      ];
+      reasonCache.set(row, reasons);
+    }
+    return reasons;
+  };
+  const retired = new Set;
+  for (const row of rows)
+    if (row.type === "verdict" && row.supersedes && !row.supersedeIgnored && trustReasons(cwd, row).length === 0)
+      retired.add(row.supersedes);
+  const byKind = new Map;
+  for (const row of rows)
+    if (isLiveVerdict(row, retired) && scope(row)) {
+      const kind = typeof row.kind === "string" ? row.kind : "review";
+      byKind.set(kind, [...byKind.get(kind) ?? [], row]);
+    }
+  const verdicts = [];
+  const warnings = [];
+  for (const [kind, list] of byKind) {
+    const row = effectiveOf(list, reasonsOf, sameCode, (candidate) => basisOf(candidate) !== "stale");
+    if (!row)
+      continue;
+    const basis = basisOf(row);
+    const current = basis !== "stale";
+    const independence = reasonsOf(row);
+    const reasons = [
+      ...current ? [] : ["stale"],
+      ...PASSING.has(String(row.result)) ? [] : ["not_passing"],
+      ...independence
+    ];
+    verdicts.push({
+      kind,
+      basis,
+      current,
+      independent: independence.length === 0,
+      accepted: reasons.length === 0,
+      reasons,
+      carry: basis === "carried" ? carryOf(row) : null,
+      verdict: row
+    });
+    if (reasons.length === 0) {
+      for (const later of list)
+        if (later.seq > row.seq && reasonsOf(later).length > 0 && !untrusted(reasonsOf(later)) && FAILING.has(String(later.result)) && basisOf(later) !== "stale")
+          warnings.push(`the author's own (self) ${String(later.result)} ${kind} verdict ${later.id} by ${later.actor.session ?? "no session"} on the current code is newer than the accepted pass ${row.id}: read it before merging`);
+    }
   }
-  const repoRisk = parseRiskPaths(fileAt(cwd, fork, RISK_PATHS_FILE) ?? "");
+  for (const row of rows)
+    if (row.integrity === "unverified" && scope(row))
+      warnings.push(`ledger row ${row.id} (${row.type}) on ${row.branch ?? branch} is unverified: the workit CLI did not write it or it changed afterwards (workit ledger verify-integrity)`);
+  const tampered = ledgerTampering(cwd);
+  if (tampered.length) {
+    warnings.push(tamperedWarning(cwd, tampered));
+    for (const entry of verdicts) {
+      entry.accepted = false;
+      entry.reasons = [...entry.reasons, "ledger_tampered"];
+    }
+  }
+  verdicts.sort((a, b) => a.verdict.seq - b.verdict.seq);
+  const newestCurrent = verdicts.findLast((entry) => entry.current) ?? verdicts.at(-1) ?? null;
+  const failing = verdicts.find((entry) => entry.current && entry.independent && FAILING.has(String(entry.verdict.result)));
+  const newestAccepted = verdicts.findLast((entry) => entry.accepted && STRONG_RESULTS.has(String(entry.verdict.result))) ?? null;
+  const accepted = tampered.length ? { accepted: false, verdict: null, reasons: ["ledger_tampered"] } : newestAccepted && !failing ? { accepted: true, verdict: newestAccepted.verdict, reasons: [] } : {
+    accepted: false,
+    verdict: failing?.verdict ?? null,
+    reasons: failing ? ["failing_verdict"] : !newestCurrent ? ["no_verdict"] : newestCurrent.reasons.length ? newestCurrent.reasons : ["type_check_only"]
+  };
+  const latestSelf = failing ? undefined : verdicts.findLast((entry) => entry.current && !entry.independent && !untrusted(entry.reasons) && (STRONG_RESULTS.has(String(entry.verdict.result)) || FAILING.has(String(entry.verdict.result))));
+  const selfEntry = latestSelf && STRONG_RESULTS.has(String(latestSelf.verdict.result)) ? latestSelf : undefined;
+  const carryEntry = verdicts.find((entry) => entry.verdict === accepted.verdict && entry.accepted) ?? newestCurrent;
+  const lastPass = accepted.accepted || failing || tampered.length ? undefined : verdicts.findLast((entry) => !entry.current && !untrusted(entry.reasons) && STRONG_RESULTS.has(String(entry.verdict.result)));
+  const drift = lastPass ? driftOf(lastPass.verdict) : null;
+  const reverify = drift && !drift.carries && drift.focused && drift.files ? { scope: "focused", since: drift.since, files: drift.files } : null;
   return {
-    ...computeLane({
-      files,
-      riskTier,
-      riskPaths: [...repoRisk, ...options.riskPaths ?? []]
-    }),
-    base,
-    head: options.head
+    branch,
+    head,
+    review: accepted.accepted ? "verified" : selfEntry ? "self-reviewed" : "unreviewed",
+    selfVerdict: accepted.accepted ? null : selfEntry?.verdict ?? null,
+    base: newestCurrent?.verdict.base ?? fallbackBase,
+    patchId: keyFor(newestCurrent?.verdict.base ?? fallbackBase).patchId,
+    current: { basis: newestCurrent?.basis ?? "none", verdict: newestCurrent?.verdict ?? null },
+    carry: carryEntry?.carry ?? null,
+    reverify,
+    accepted,
+    verdicts,
+    authors: [...authors].toSorted(),
+    warnings
   };
 }
-var laneNeed = (lane) => lane === "none" ? "none" : lane === "self" ? "self" : "non-author";
+var fromLead = (row, leads) => leads === null || row.actor.session !== null && leads.includes(row.actor.session);
+function activeStanding(rows, fanout, leads = null) {
+  const active = [];
+  for (const row of rows) {
+    if (row.fanout !== fanout || !fromLead(row, leads))
+      continue;
+    if (row.type === "standing" && typeof row.what === "string" && row.what.trim()) {
+      if (!row.superseded)
+        active.push(row);
+    } else if (row.type === "standing.cleared") {
+      const target = str(row.target);
+      if (target === null)
+        active.length = 0;
+      else {
+        const index = active.findIndex((order) => order.id === target);
+        if (index >= 0)
+          active.splice(index, 1);
+      }
+    }
+  }
+  return active;
+}
+var OBSERVED_ONLY = new Set([
+  "check",
+  "merge.unverified",
+  "policy.judged",
+  ...PR_ROW_TYPES
+]);
 
 // packages/workit-core/src/core/policy/derive.ts
 var RULES = {
@@ -14612,7 +14743,7 @@ function splitCommand(command) {
     argv.push(current);
   return argv.length ? argv : new Error("empty command");
 }
-var git5 = (cwd, args) => {
+var git4 = (cwd, args) => {
   const run = spawnSync9("git", args, {
     cwd,
     encoding: "utf8",
@@ -14624,7 +14755,7 @@ var git5 = (cwd, args) => {
   return value || null;
 };
 function checkRoot(cwd) {
-  return path18.resolve(git5(cwd, ["rev-parse", "--show-toplevel"]) ?? cwd);
+  return path18.resolve(git4(cwd, ["rev-parse", "--show-toplevel"]) ?? cwd);
 }
 var packageManager = (root) => {
   const has = (file) => fs13.existsSync(path18.join(root, file));
@@ -15576,7 +15707,7 @@ Autonomy contract:
 CLI first: if a step has one right answer, use the \`workit\` verb instead of
 hand-running git, gh or glab (\`workit git|pr|ci|check|help\`;
 else \`npx -y @brainervirus/workit-cli\`).
-Other checkout: \`workit --cwd <dir> <verb>\` (Codex: \`<verb> --cwd <dir>\`); one workit
+Other checkout: \`workit <verb> --cwd <dir> …\` (verb first: host rules match it); one workit
 verb per shell call, never \`cd <dir> && workit\`. zsh-safe: no \`echo =====\`
 (\`printf '%s\\n' ---\`), quote globs and URLs, no variable named \`status\` or \`path\`.
 Add Co-Authored-By via \`workit git commit --trailer "K: v" -- <paths>\`, never
@@ -15588,7 +15719,7 @@ authorizes an effect. Judge work once with
 \`workit policy assess --judge risk= behavior= product-choice= plan=\`.
 Across repositories, bind items to checkout, branch and endpoint, resolve
 competing targets before a mutation, and reconcile an uncertain
-external effect before a retry.
+effect before a retry.
 
 Mid-task: never silently drop or resume an objective (workit-continue).
 
@@ -17994,6 +18125,18 @@ var substitutions = (body) => {
 };
 var PLAIN_POSIX = /[^\s'"\\`$(){},<>|;&#]+/uy;
 var PLAIN_POWERSHELL = /[^\s'"`(){}<>|;&#]+/uy;
+var expandsInQuotes = (body, dialect) => {
+  const escape = dialect === "posix" ? "\\" : "`";
+  for (let index = 0;index < body.length; index++) {
+    const char = body[index];
+    if (char === escape)
+      index++;
+    else if (char === "$" || dialect === "posix" && char === "`")
+      return true;
+  }
+  return false;
+};
+var EXPANDING_RUN = /[*?[]/u;
 var arithmeticEnd = (command, start) => {
   const end = substitutionEnd(command, start);
   return command[end - 1] === ")" && end > start + 2 ? end : 0;
@@ -18012,6 +18155,7 @@ var tokenize = (command, dialect) => {
   let current = { words: [], redirects: [] };
   let word = "";
   let inWord = false;
+  let expanding = false;
   let pending = null;
   const heredocs = [];
   const escape = posix ? "\\" : "`";
@@ -18026,11 +18170,16 @@ var tokenize = (command, dialect) => {
       heredocs.push({ delimiter: text.replace(/^-/, ""), owner: current });
     else if (pending === "herestring")
       (current.stdin ??= []).push(text);
-    else if (pending !== "input")
+    else if (pending !== "input") {
+      const at = current.words.length;
       current.words.push(...MARKERS.test(word) ? expandBraces(word) : [word]);
+      if (expanding || !posix && word.startsWith("@"))
+        (current.expands ??= []).push(...current.words.slice(at).map((_, i) => at + i));
+    }
     pending = null;
     word = "";
     inWord = false;
+    expanding = false;
   };
   const flushSegment = () => {
     flushWord();
@@ -18045,6 +18194,7 @@ var tokenize = (command, dialect) => {
   };
   const substitution = (inner, text) => {
     (current.subs ??= []).push(inner);
+    expanding = true;
     word += text;
     inWord = true;
   };
@@ -18055,6 +18205,8 @@ var tokenize = (command, dialect) => {
     if (run) {
       word += run[0];
       inWord = true;
+      if (EXPANDING_RUN.test(run[0]))
+        expanding = true;
       index += run[0].length - 1;
       continue;
     }
@@ -18083,6 +18235,8 @@ var tokenize = (command, dialect) => {
       const body = command.slice(index + 1, end < 0 ? undefined : end);
       if (posix && char === '"' && /\$\(|`/.test(body))
         (current.subs ??= []).push(...substitutions(body));
+      if (char === '"' && expandsInQuotes(body, dialect))
+        expanding = true;
       word += unquote(body, char, dialect);
       inWord = true;
       index = end < 0 ? command.length : end;
@@ -18128,6 +18282,8 @@ var tokenize = (command, dialect) => {
       if (char === "(" && inWord && word.endsWith("$")) {
         word = word.slice(0, -1);
         inWord = word !== "";
+        if (!inWord)
+          expanding = false;
       }
       group(char === "(" ? "open" : "close");
     } else if (!posix && (char === "{" || char === "}")) {
@@ -18181,6 +18337,8 @@ var tokenize = (command, dialect) => {
     else if (posix && char === "}" && word.includes(OPEN))
       word += CLOSE;
     else {
+      if (char === "$")
+        expanding = true;
       word += char;
       inWord = true;
     }
@@ -18235,7 +18393,7 @@ var GIT_VALUE_OPTIONS = new Set([
 ]);
 var GIT_CONFIG_OPTIONS = new Set(["-c", "--config-env", "--git-dir"]);
 var GIT_CONFIG_ENV = /^GIT_(?:CONFIG\w*|DIR|COMMON_DIR|WORK_TREE)$/;
-var ASSIGNMENT2 = /^([A-Za-z_]\w*)=([\s\S]*)$/;
+var ASSIGNMENT = /^([A-Za-z_]\w*)=([\s\S]*)$/;
 var MAX_DEPTH = 4;
 var MAX_EXPANSIONS = 16;
 var isAbsolute = (value) => path22.isAbsolute(value) || /^[A-Za-z]:[\\/]/.test(value) || value.startsWith("\\\\");
@@ -18262,7 +18420,7 @@ var stripPrefixes = (input) => {
     const first = words[0];
     if (first === undefined)
       return { words, env };
-    const assignment = ASSIGNMENT2.exec(first);
+    const assignment = ASSIGNMENT.exec(first);
     if (assignment) {
       if (GIT_CONFIG_ENV.test(assignment[1]))
         env[assignment[1]] = assignment[2];
@@ -18321,10 +18479,10 @@ var assignments = (words, vars) => {
     while (rest[0]?.startsWith("-"))
       rest = rest.slice(1);
   }
-  if (rest.length === 0 || !rest.every((word) => ASSIGNMENT2.test(word)))
+  if (rest.length === 0 || !rest.every((word) => ASSIGNMENT.test(word)))
     return null;
   return rest.map((word) => {
-    const [, name, value] = ASSIGNMENT2.exec(word);
+    const [, name, value] = ASSIGNMENT.exec(word);
     return [name, expandWord(value, vars)];
   });
 };
@@ -18512,7 +18670,7 @@ var splitString = (line) => {
       return line.slice(index).join(" ").slice(15);
     if (/^-S./.test(word))
       return [word.slice(2), ...line.slice(index + 1)].join(" ");
-    if (!word.startsWith("-") && !ASSIGNMENT2.test(word))
+    if (!word.startsWith("-") && !ASSIGNMENT.test(word))
       return null;
   }
   return null;
@@ -18625,8 +18783,17 @@ function walk2(command, dialect, depth, seen) {
           visit(next, undefined, hops + 1);
     };
     const wrapped = seen ? null : workitCheckTail(words);
-    if (wrapped)
-      return "script" in wrapped ? nested(wrapped.script, "posix") : runs([wrapped.argv]);
+    if (wrapped) {
+      const outer = dir;
+      if (wrapped.cwd !== null)
+        dir = joinDir(dir, wrapped.cwd);
+      if ("script" in wrapped)
+        nested(wrapped.script, "posix");
+      else
+        runs([wrapped.argv]);
+      dir = outer;
+      return;
+    }
     if (CD.has(name)) {
       const target = cdTarget(words);
       dir = target === null ? os5.homedir() : joinDir(dir, target);
@@ -18727,14 +18894,14 @@ function workitCheckTail(words) {
       return null;
   } else if (!/^workit(?:\.exe|\.cmd)?$/.test(commandName(words[0])))
     return null;
-  const args = words.slice(at + 1);
+  const { rest: args, cwd } = skipWorkitGlobals(words.slice(at + 1));
   if (args[0] !== "check" && !(args[0] === "lock" && args[1] === "run"))
     return null;
   const split = args.indexOf("--");
   const tail = split < 0 ? [] : args.slice(split + 1);
   if (!tail.length)
     return null;
-  return args.slice(0, split).includes("--shell") ? { script: tail.join(" ") } : { argv: tail };
+  return args.slice(0, split).includes("--shell") ? { script: tail.join(" "), cwd } : { argv: tail, cwd };
 }
 function simpleCommand(command, dialect = "posix", depth = 0) {
   let segments;
@@ -18795,7 +18962,21 @@ function skipWorkitGlobals(args) {
     } else if (args[at] !== "--json")
       break;
   }
-  return { rest: args.slice(at), cwd };
+  const rest = [];
+  for (;at < args.length; at++) {
+    const arg = args[at];
+    if (arg === "--") {
+      rest.push(...args.slice(at));
+      break;
+    }
+    if (arg.startsWith("--cwd="))
+      cwd = arg.slice("--cwd=".length);
+    else if (arg === "--cwd" && args[at + 1] !== undefined)
+      cwd = args[++at];
+    else
+      rest.push(arg);
+  }
+  return { rest, cwd };
 }
 var PUSH_VALUE_OPTIONS = new Set(["-o", "--push-option", "--receive-pack", "--exec", "--repo"]);
 var CURRENT_BRANCH = /^\$\(\s*git\s+(?:branch\s+--show-current|rev-parse\s+--abbrev-ref\s+HEAD|symbolic-ref\s+--short\s+HEAD)\s*\)$/;
@@ -19241,7 +19422,7 @@ var rewrittenUrl = (url, config) => {
   }
   return url;
 };
-var pushUrl2 = (config, remote, dir) => {
+var pushUrl = (config, remote, dir) => {
   const configured = configValue(config, `remote.${remote}.pushurl`) ?? configValue(config, `remote.${remote}.url`);
   return normalizedUrl(rewrittenUrl(configured ?? remote, config), dir);
 };
@@ -19269,7 +19450,7 @@ var toPushRemote = (repo, remote, config) => {
   const pushRemote = pushRemoteOf(config, repo.branch);
   if (pushRemote === null || pushRemote === remote)
     return true;
-  return pushUrl2(config, remote, repo.dir) === pushUrl2(config, pushRemote, repo.dir);
+  return pushUrl(config, remote, repo.dir) === pushUrl(config, pushRemote, repo.dir);
 };
 var quote = (text) => `\`${text}\``;
 var refusal = (action, branch, dir) => {
@@ -19807,6 +19988,53 @@ var shellPolicy = (cwd, command, dialect = "posix") => {
   }
   return policy && !policy.ok ? { kind: "deny", reason: `branch_policy_denied: ${policy.error}`, unblock: null } : { kind: "none" };
 };
+// packages/workit-core/src/hooks/delivery-verbs.ts
+var WORKIT_ALLOWED_VERBS = [
+  "git",
+  "pr",
+  "ci",
+  "stack",
+  "release",
+  "task",
+  "ledger",
+  "evidence",
+  "finding",
+  "decision",
+  "worker",
+  "verify-delivery",
+  "policy",
+  "doctor",
+  "help"
+];
+var WORKIT_BYPASS_FLAGS = ["--unverified", "--overwrite-unintegrated"];
+var ALLOWED = new Set(WORKIT_ALLOWED_VERBS);
+var isBypass = (word) => WORKIT_BYPASS_FLAGS.some((flag) => word === flag || word.startsWith(`${flag}=`));
+var isWorkitWord = (word) => /^(?:.*[\\/])?workit(?:-cli)?$/u.test(word);
+var bypassReason = (flag) => `Workit: \`${flag}\` overrides a Workit gate, so the user decides this call (no allow rule covers it).`;
+var EXPANSION_REASON = "Workit: an expansion before `--` could become a bypass flag, so the user decides this call (no allow rule covers it).";
+var workitBypassFlag = (command, dialect = "posix") => {
+  for (const segment of segmentsOf(command, dialect)) {
+    if (segment.unanalyzable) {
+      const text = command.replaceAll(/['"\\`]/gu, "");
+      if (!/\bworkit\b/u.test(text))
+        return null;
+      const found = WORKIT_BYPASS_FLAGS.find((flag) => text.includes(flag));
+      return found ? bypassReason(found) : null;
+    }
+    const start = segment.words.findIndex(isWorkitWord);
+    if (start < 0)
+      continue;
+    const words = segment.words.slice(start + 1);
+    const end = words.indexOf("--");
+    const flag = (end < 0 ? words : words.slice(0, end)).find(isBypass);
+    if (flag)
+      return bypassReason(flag.split("=")[0] ?? flag);
+    const limit = start + 1 + (end < 0 ? words.length : end);
+    if (segment.expands?.some((index) => index > start && index < limit))
+      return EXPANSION_REASON;
+  }
+  return null;
+};
 // packages/workit-core/src/core/heavy-rules.ts
 import fs18 from "node:fs";
 import os6 from "node:os";
@@ -21191,7 +21419,7 @@ var segmentTargets = (cwd, command, dialect, depth = 0, strict = false) => {
     }
     const inner = depth < 4 ? wrappedScript(words) ?? (strict ? shellScript2(words) : null) : null;
     if (inner !== null && dir !== undefined)
-      targets.push(...segmentTargets(dir, inner, "posix", depth + 1, strict));
+      targets.push(...segmentTargets(workitRunDir(dir, words), inner, "posix", depth + 1, strict));
     if (strict && dir !== undefined) {
       const runIn = dir;
       for (const sub of depth < 4 ? segment.subs ?? [] : [])
@@ -21231,6 +21459,14 @@ var segmentTargets = (cwd, command, dialect, depth = 0, strict = false) => {
   }
   return targets;
 };
+var workitRunDir = (dir, words) => {
+  for (const invocation of workitInvocations(words.map(quoteWord2).join(" "), "posix")) {
+    const { at, args } = workitCwd(dir, invocation);
+    if (args[0] === "check" || args[0] === "lock" && args[1] === "run")
+      return at;
+  }
+  return dir;
+};
 var workitCwd = (dir, args) => {
   const { rest, cwd } = skipWorkitGlobals(args);
   return { at: cwd === null ? dir : path28.resolve(dir, homeExpanded(cwd)), args: rest };
@@ -22015,8 +22251,13 @@ var standingDelta = (input) => {
 };
 var sinceStart = new Map;
 // packages/workit-core/src/hooks/cwd-normalize.ts
-var COMPOUND = /^\s*cd\s+([A-Za-z0-9_./@%+:,=-]+|'[^'$`\\\n]*'|"[^"$`\\!\n]*")\s*&&\s*(workit(?:\s[\s\S]*)?)$/u;
+var DIR = String.raw`[A-Za-z0-9_./@%+:,=-]+|'[^'$${"`"}\\\n]*'|"[^"$${"`"}\\!\n]*"`;
+var COMPOUND = new RegExp(String.raw`^\s*cd\s+(${DIR})\s*&&\s*(workit(?:\s[\s\S]*)?)$`, "u");
+var GLOBALS_FIRST = new RegExp(String.raw`^(\s*workit)((?:\s+(?:--json|--cwd(?:=|\s+)(?:${DIR})))+)\s+([a-z][a-z-]*)(?=\s|$)`, "u");
+var VERB_FIRST = /^((?:--json\s+)*)([a-z][a-z-]*)(?=\s|$)/u;
+var VERBS = new Set(WORKIT_ALLOWED_VERBS);
 var FILTERS = new Set(["tail", "head", "grep"]);
+var clean = (s) => !s.unanalyzable && !s.group && !s.subs?.length && !s.stdin?.length && !s.redirects.length;
 var stdinOnly = (words) => {
   const [name, ...args] = words;
   const operands = args.filter((w) => !w.startsWith("-"));
@@ -22038,14 +22279,28 @@ var cwdRewrite = (command) => {
     return null;
   if (head.words.some((w) => w === "--cwd" || w.startsWith("--cwd=")))
     return null;
-  const clean = (s) => !s.unanalyzable && !s.group && !s.subs?.length && !s.stdin?.length && !s.redirects.length;
   if (!segments.every(clean))
     return null;
   if (!segments.slice(0, -1).every((s) => s.pipe))
     return null;
   if (!filters.every((s) => FILTERS.has(s.words[0] ?? "") && stdinOnly(s.words)))
     return null;
-  return `workit --cwd ${dir} ${rest.slice("workit".length).trimStart()}`.trimEnd();
+  const args = rest.slice("workit".length).trimStart();
+  const verb = VERB_FIRST.exec(args);
+  if (!verb?.[2] || !VERBS.has(verb[2]))
+    return `workit --cwd ${dir} ${args}`.trimEnd();
+  const json = verb[1] ? " --json" : "";
+  return `workit ${verb[2]} --cwd ${dir}${json}${args.slice(verb[0].length)}`.trimEnd();
+};
+var verbFirst = (command) => {
+  const match = GLOBALS_FIRST.exec(command);
+  const [whole, lead, globals, verb] = match ?? [];
+  if (!whole || !verb || !VERBS.has(verb) || !globals?.includes("--cwd"))
+    return null;
+  const segments = segmentsOf(command);
+  if (segments.length !== 1 || !segments.every(clean))
+    return null;
+  return `${lead} ${verb}${globals}${command.slice(whole.length)}`;
 };
 
 // packages/workit-core/src/hooks/worktree-confine.ts
@@ -22161,7 +22416,7 @@ var hostIsolated = (cwd, agentId) => {
 };
 var shown = (target) => path31.basename(target) === ".workit-live-target" ? path31.dirname(target) : target;
 var unboundDeny = (input, target) => {
-  const unblock = "Work only in the worktree your brief names, which the lead made with `workit fanout worktree create <slice>`: edit files under it and run one verb per call against it (`workit --cwd <worktree> git commit -m … -- <paths>`, `workit --cwd <worktree> check <name>`). If your brief names no worktree, stop and report that to the lead.";
+  const unblock = "Work only in the worktree your brief names, which the lead made with `workit fanout worktree create <slice>`: edit files under it and run one verb per call against it (`workit git --cwd <worktree> commit -m … -- <paths>`, `workit check --cwd <worktree> <name>`). If your brief names no worktree, stop and report that to the lead.";
   return {
     kind: "deny",
     reason: `workit worktree confinement: implementer ${input.session.agentId} is not working in a Workit worktree yet, and ${shown(target)} is outside every worktree \`workit fanout worktree create\` made, so it would change the lead's checkout. ${unblock}`,
@@ -22169,7 +22424,7 @@ var unboundDeny = (input, target) => {
   };
 };
 var outsideDeny = (input, worktree, target) => {
-  const unblock = `Edit only under ${worktree} and run git there, one verb per call: \`workit --cwd ${worktree} git commit -m … -- <paths>\`, \`workit --cwd ${worktree} check <name>\` (or \`git -C ${worktree} …\`); a command whose writes Workit cannot see is judged by the directory it runs in. Anything outside it is a follow-up for your report.`;
+  const unblock = `Edit only under ${worktree} and run git there, one verb per call: \`workit git --cwd ${worktree} commit -m … -- <paths>\`, \`workit check --cwd ${worktree} <name>\` (or \`git -C ${worktree} …\`); a command whose writes Workit cannot see is judged by the directory it runs in. Anything outside it is a follow-up for your report.`;
   return {
     kind: "deny",
     reason: `workit worktree confinement: implementer ${input.session.agentId} is bound to the worktree ${worktree}, and ${shown(target)} is outside it. ${unblock}`,
@@ -22178,7 +22433,7 @@ var outsideDeny = (input, worktree, target) => {
 };
 var unknownDirDeny = (input, worktree) => {
   const wt = worktree ?? "<worktree>";
-  const unblock = `Workit cannot resolve \`cd -\`, \`cd "$X"\` or \`popd\`: write by absolute path, \`git -C ${wt}\` or \`workit --cwd ${wt}\`.`;
+  const unblock = `Workit cannot resolve \`cd -\`, \`cd "$X"\` or \`popd\`: write by absolute path, \`git -C ${wt}\` or \`workit <verb> --cwd ${wt}\`.`;
   return {
     kind: "deny",
     reason: `workit worktree confinement: implementer ${input.session.agentId} writes after an unknown directory change. ${unblock}`,
@@ -22336,7 +22591,7 @@ var subagentStartText = (input, descriptor, event) => {
     return `${isolatedGit(input.cwd)}
 ${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 one its brief names (the lead makes it with \`workit fanout worktree create <slice>\` before spawning), never in the lead's checkout, within its brief's scope. Workit binds it to the first Workit worktree it changes: from then on an edit or a mutating git command outside that worktree is denied, and before then so is one outside every Workit worktree. Run Workit against the worktree one verb per call, never \`cd … &&\` chains or \`$VAR\` paths: \`workit --cwd <worktree> git commit -m "<message>" -- <paths>\`, \`workit --cwd <worktree> check <name>\`. The worktree is on the brief's branch once the lead made it; otherwise switch with \`workit --cwd <worktree> 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.`;
+    return `Workit observed ${who} as an implementer: it edits and commits only in its own git worktree, the one its brief names (the lead makes it with \`workit fanout worktree create <slice>\` before spawning), never in the lead's checkout, within its brief's scope. Workit binds it to the first Workit worktree it changes: from then on an edit or a mutating git command outside that worktree is denied, and before then so is one outside every Workit worktree. Run Workit against the worktree one verb per call, never \`cd … &&\` chains or \`$VAR\` paths: \`workit git --cwd <worktree> commit -m "<message>" -- <paths>\`, \`workit check --cwd <worktree> <name>\` (verb first, so host allow rules match). The worktree is on the brief's branch once the lead made it; otherwise switch with \`workit git --cwd <worktree> 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;
@@ -22353,7 +22608,7 @@ ${subagentStartText({ ...input, cwd: "" }, descriptor, event)}`;
 var PRE_TOOL = new Set(["shell.pre", "write.pre", "tool.pre"]);
 function handleHook(input, deps) {
   const decision = decide(input, deps);
-  if (deps.descriptor.transport !== "hook-process" || !PRE_TOOL.has(input.event.kind) || decision.kind === "deny")
+  if (deps.descriptor.transport !== "hook-process" || !PRE_TOOL.has(input.event.kind) || decision.kind === "deny" || decision.kind === "ask")
     return decision;
   const delta = standingDelta(input);
   if (!delta)
@@ -22420,9 +22675,12 @@ function decide(input, deps) {
       if (plan.kind === "rewrite" && !rewrites && canDeny)
         return heavyDenial(event.command, plan);
       const lease = plan.kind === "rewrite" && rewrites ? plan : null;
-      const cwdCommand = !lease && rewrites && input.host === "claude_code" ? cwdRewrite(event.command) : null;
+      const cwdCommand = !lease && rewrites && input.host === "claude_code" ? cwdRewrite(event.command) ?? verbFirst(event.command) : null;
       const aside = plan.kind === "passthrough" ? plan.note : null;
       noteRawCommit(input, event.command, postTool ? callKey(event.toolUseId, event.command) : NEXT_COMMAND);
+      const bypass = !lease && input.host === "claude_code" ? workitBypassFlag(event.command, event.dialect) : null;
+      if (bypass)
+        return { kind: "ask", reason: bypass };
       const rewrittenTo = lease?.command ?? cwdCommand;
       const rewritten = (text) => rewrittenTo ? {
         kind: "rewrite",
@@ -22849,6 +23107,17 @@ var render = (decision, native) => {
       },
       exitCode: 0
     };
+  if (decision.kind === "ask" && native === "PreToolUse")
+    return {
+      json: {
+        hookSpecificOutput: {
+          hookEventName: "PreToolUse",
+          permissionDecision: "ask",
+          permissionDecisionReason: decision.reason
+        }
+      },
+      exitCode: 0
+    };
   if (decision.kind === "context" && native !== null && CONTEXT_EVENTS.has(native))
     return {
       json: { hookSpecificOutput: { hookEventName: native, additionalContext: decision.text } },