@brainervirus/workit-pi 1.0.12 → 1.1.0

package/dist/workit.js

@@ -7576,7 +7576,13 @@ var refSchema = discriminatedUnion("kind", [
     id
   }).strict(),
   object({ kind: literal("host"), host: hostSchema, handle: nonEmpty }).strict(),
-  object({ kind: literal("external"), url: text.url() }).strict()
+  object({ kind: literal("external"), url: text.url() }).strict(),
+  object({
+    kind: literal("standing"),
+    workspace: nonEmpty,
+    class: nonEmpty,
+    configDigest: nullableDigest
+  }).strict()
 ]);
 var rewriteUnknown = (value, map) => {
   if (Array.isArray(value)) {
@@ -7881,7 +7887,8 @@ var decisionSchema = object({
     approvedContent: text,
     displayed: text.optional(),
     contentRefs: array(refSchema),
-    statedChoice: object({ ref: text, text }).strict().optional()
+    statedChoice: object({ ref: text, text }).strict().optional(),
+    standing: object({ workspace: nonEmpty, class: nonEmpty }).strict().optional()
   }).strict(),
   digest,
   response: _enum(["approved", "rejected", "stated"]),
@@ -9978,2136 +9985,2383 @@ function assertProductWriteAllowed(input) {
 }
 
 // packages/workit-core/src/core/task-evaluation.ts
+import { createHash as createHash5 } from "node:crypto";
+import * as fs7 from "node:fs";
+import { spawnSync as spawnSync2 } from "node:child_process";
+import path10 from "node:path";
+
+// packages/workit-core/src/core/authority.ts
 import { createHash as createHash4 } from "node:crypto";
 import * as fs6 from "node:fs";
-import { spawnSync } from "node:child_process";
-import path6 from "node:path";
+import path9 from "node:path";
 
-// packages/workit-core/src/core/authority.ts
+// packages/workit-core/src/core/auto-approval.ts
 import { createHash as createHash3 } from "node:crypto";
-import * as fs5 from "node:fs";
+import { readFileSync as readFileSync5 } from "node:fs";
+
+// packages/workit-core/src/core/workspaces.ts
+import { readFileSync as readFileSync3, realpathSync as realpathSync2 } from "node:fs";
+import path6 from "node:path";
+
+// packages/workit-core/src/core/config.ts
+import {
+  copyFileSync,
+  cpSync,
+  existsSync as existsSync3,
+  mkdirSync as mkdirSync2,
+  readFileSync as readFileSync2,
+  readdirSync as readdirSync2,
+  writeFileSync as writeFileSync2
+} from "node:fs";
+import os from "node:os";
 import path5 from "node:path";
-var verifiedAuthorities = new WeakMap;
-var trustedAuthority = (kind, provenance, expected, binding, caller) => {
-  const token = {};
-  verifiedAuthorities.set(token, { kind, provenance, ...expected, ...binding, caller });
-  return token;
+
+// packages/workit-core/src/core/boundary.ts
+var EVENT = {
+  initialization: "initialization",
+  provenance: "provenance",
+  assets: "assets",
+  configurationSource: "configuration_source",
+  hooks: "hooks",
+  mcpConnection: "mcp_connection",
+  migration: "migration",
+  installSteps: "install_steps",
+  uncaughtFailure: "uncaught_failure",
+  toolsFailed: "tools_failed",
+  doctor: "doctor"
 };
-var chainStepKey = (step) => step.kind === "commit" ? step.message : step.kind === "branch" ? `branch:${step.target}` : "pr";
-var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
-var normalizeChainSteps = (steps) => {
-  if (!Array.isArray(steps) || steps.length === 0 || steps.length > 32)
-    return null;
-  const normalized = [];
-  for (const step of steps) {
-    if (typeof step === "string") {
-      if (!step.trim())
-        return null;
-      normalized.push({ kind: "commit", message: step });
-      continue;
-    }
-    if (!isRecord(step))
-      return null;
-    if (typeof step.branch === "string" && step.branch.trim() && Object.keys(step).length === 1) {
-      normalized.push({ kind: "branch", target: step.branch });
-      continue;
-    }
-    if (step.pr === true && Object.keys(step).length === 1) {
-      normalized.push({ kind: "pr" });
+var errorDetail = (err) => {
+  if (err instanceof Error) {
+    return { error_name: err.name, error: err.message };
+  }
+  return { error_name: "unknown", error: String(err) };
+};
+
+// packages/workit-core/src/core/config.ts
+var diagnosticLogger;
+var PRESETS = {
+  gitflow: {
+    allowed: ["feature/*", "bugfix/*", "hotfix/*", "release/*"],
+    protected: ["main", "develop", "master", "prod", "production"]
+  },
+  "github-flow": { allowed: ["*"], protected: ["main"] },
+  "trunk-based": { allowed: ["*"], protected: ["main"] },
+  custom: { allowed: [], protected: [] }
+};
+var mergePreset = (preset, input = {}, current = {
+  branchPolicy: { preset, allowed: [], protected: [] }
+}) => {
+  const defs = PRESETS[preset];
+  return {
+    preset,
+    allowed: preset === "custom" ? input.allowed ?? current.branchPolicy.allowed : [...defs.allowed],
+    protected: preset === "custom" ? input.protectedNames ?? current.branchPolicy.protected : [...defs.protected]
+  };
+};
+var resolveConfigDir = () => process.env.WORKFLOW_TOOLKIT_CONFIG ?? process.env.WORKFLOW_TOOLKIT_CONFIG_DIR ?? path5.join(process.env.XDG_CONFIG_HOME || path5.join(os.homedir(), ".config"), "workit");
+var migratedDir = null;
+var migrationFailed = false;
+var ensureConfigDir = (dir = resolveConfigDir()) => {
+  if (migratedDir === dir)
+    return dir;
+  if (process.env.WORKFLOW_TOOLKIT_CONFIG || process.env.WORKFLOW_TOOLKIT_CONFIG_DIR) {
+    migratedDir = dir;
+    return dir;
+  }
+  const legacy = path5.join(process.env.XDG_CONFIG_HOME || path5.join(os.homedir(), ".config"), "workflow-toolkit");
+  if (!existsSync3(legacy)) {
+    migratedDir = dir;
+    return dir;
+  }
+  if (!migrationFailed && existsSync3(dir)) {
+    migratedDir = dir;
+    return dir;
+  }
+  migrationFailed = false;
+  mkdirSync2(dir, { recursive: true });
+  diagnosticLogger?.info(EVENT.migration, { from: legacy, to: dir });
+  for (const entry of readdirSync2(legacy, { withFileTypes: true })) {
+    const src = path5.join(legacy, entry.name);
+    const dest = path5.join(dir, entry.name);
+    if (existsSync3(dest))
       continue;
+    try {
+      if (entry.isDirectory())
+        cpSync(src, dest, { recursive: true });
+      else if (entry.isFile())
+        copyFileSync(src, dest);
+    } catch (err) {
+      migrationFailed = true;
+      diagnosticLogger?.warn(EVENT.migration, { from: src, ok: false, ...errorDetail(err) });
+      console.warn(`[workit] config migration: a file could not be copied to ${dir}; it will be retried on the next run`);
     }
-    return null;
   }
-  const keys = normalized.map(chainStepKey);
-  if (new Set(keys).size !== keys.length)
-    return null;
-  return normalized;
+  if (!migrationFailed)
+    migratedDir = dir;
+  return dir;
 };
-var scopeEqual = (left, right) => canonicalJson(left) === canonicalJson(right);
-var parseSteps = (content) => {
-  let value;
+var configDir = () => ensureConfigDir();
+var LOCALE_RE = /^[a-z]{2,3}(-(?:[A-Z]{2}|[0-9]{3}))?$/;
+var DEFAULTS = {
+  locale: "en",
+  localeOptions: ["en", "es-CL", "es-MX", "es-AR", "pt-BR"],
+  timezone: "America/Santiago",
+  branchPolicy: {
+    preset: "gitflow",
+    allowed: [...PRESETS.gitflow.allowed],
+    protected: [...PRESETS.gitflow.protected]
+  },
+  commitPolicy: { preset: "conventional" }
+};
+var readSafe = (p) => {
   try {
-    value = JSON.parse(content);
+    return readFileSync2(p, "utf8");
   } catch {
-    return [];
-  }
-  if (typeof value !== "object" || value === null || !("steps" in value))
-    return [];
-  const steps = value.steps;
-  if (!Array.isArray(steps))
     return null;
-  const normalized = normalizeChainSteps(steps);
-  return normalized;
+  }
 };
-var decisionMatches = (entry, purpose, binding) => {
-  const decision = entry.data;
-  return binding.taskId === decision.binding.taskId && binding.workspaceId === decision.binding.workspaceId && decision.purpose === purpose && decision.response === "approved" && decision.revoked === null && (purpose !== "action" || decision.consumption === null) && decision.digest === decisionDigest(decision) && scopeEqual(decision.binding.scope, binding.scope) && canonicalJson(decision.binding) === canonicalJson(binding);
+var isConfigObject = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+var parseConfigResult = (raw, file) => {
+  if (raw === null)
+    return { status: "missing", path: file };
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return { status: "malformed", path: file, error: `${file} is not valid JSON` };
+  }
+  if (!isConfigObject(parsed)) {
+    return { status: "malformed", path: file, error: `${file} is not a JSON object` };
+  }
+  const input = parsed;
+  const locale = LOCALE_RE.test(String(input.locale ?? "")) ? input.locale : DEFAULTS.locale;
+  const preset = Object.hasOwn(PRESETS, input.branchPolicy?.preset) ? input.branchPolicy?.preset : "gitflow";
+  const commitPreset = COMMIT_PRESETS.includes(String(input.commitPolicy?.preset ?? "")) ? input.commitPolicy?.preset : "conventional";
+  return {
+    status: "valid",
+    path: file,
+    config: {
+      locale,
+      localeOptions: Array.isArray(input.localeOptions) ? input.localeOptions : DEFAULTS.localeOptions,
+      timezone: input.timezone ?? DEFAULTS.timezone,
+      branchPolicy: mergePreset(preset, {
+        allowed: Array.isArray(input.branchPolicy?.allowed) ? input.branchPolicy.allowed : undefined,
+        protectedNames: Array.isArray(input.branchPolicy?.protected) ? input.branchPolicy.protected : undefined
+      }, DEFAULTS),
+      commitPolicy: {
+        preset: commitPreset,
+        ...typeof input.commitPolicy?.pattern === "string" ? { pattern: input.commitPolicy.pattern } : {}
+      }
+    }
+  };
 };
-var sameRef = (left, right) => canonicalJson(left) === canonicalJson(right);
-var validProvenance = (value, caller) => {
-  if (!provenanceSchema.safeParse(value).success)
-    return false;
-  const provenance = value;
-  return provenance.kind === "host_observed" && provenance.host === caller.host && provenance.session?.kind === "host" && provenance.session.host === caller.host && provenance.session.handle === caller.actor && provenance.receipts.some((receipt) => receipt.kind === "host" && receipt.host === caller.host);
+var readConfigTyped = (dir) => {
+  const file = path5.join(dir ?? configDir(), "config.json");
+  return parseConfigResult(readSafe(file), file);
 };
-var verifyNativeDecision = (verifier, input, binding) => {
-  if (!verifier)
-    return failure("permission_denied", "native authority verifier is unavailable");
-  const result = verifier.verifyDecision(input);
-  if (!result.ok || !validProvenance(result.data, input.caller))
-    return failure("permission_denied", "native decision observation was not attested");
-  return success(null, null, trustedAuthority("decision", result.data, {
-    taskId: input.expected.taskId,
-    workspaceId: input.expected.workspaceId,
-    purpose: input.expected.purpose,
-    response: input.expected.response,
-    binding: input.expected.binding,
-    bindingBytes: input.expected.bindingBytes,
-    digest: input.expected.digest,
-    requirementIds: [...input.expected.requirementIds]
-  }, binding, input.caller));
+var readConfig = () => {
+  const result = readConfigTyped();
+  if (result.status === "malformed")
+    throw new Error(result.error);
+  return result.config ?? DEFAULTS;
 };
-var verifyNativeAction = (verifier, input, binding) => {
-  if (!verifier)
-    return failure("permission_denied", "native authority verifier is unavailable");
-  const result = verifier.verifyAction(input);
-  if (!result.ok || !validProvenance(result.data, input.caller))
-    return failure("permission_denied", "native action observation was not attested");
-  return success(null, null, trustedAuthority("action", result.data, {
-    taskId: input.expected.taskId,
-    workspaceId: input.expected.workspaceId,
-    decisionId: input.expected.decisionId,
-    actionRef: input.expected.actionRef,
-    taskRevision: input.expected.taskRevision,
-    workspaceRevision: input.expected.workspaceRevision,
-    outcome: input.expected.outcome,
-    purpose: input.expected.decision.purpose,
-    response: input.expected.decision.response,
-    binding: input.expected.decision.binding,
-    digest: input.expected.decision.digest,
-    requirementIds: [...input.expected.decision.requirementIds]
-  }, binding, input.caller));
+var resolveBranchPolicy = (config, workspace) => {
+  const wp = workspace?.branchPolicy ?? {};
+  const preset = Object.hasOwn(PRESETS, wp.preset) ? wp.preset : config.branchPolicy?.preset ?? "gitflow";
+  const merged = mergePreset(preset, {
+    allowed: wp.allowed,
+    protectedNames: wp.protected
+  }, config);
+  const allowed = merged.allowed.map((p) => new RegExp(`^${p.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*")}$`, "i"));
+  return {
+    preset,
+    allowed,
+    protected: new Set(merged.protected.map((p) => p.toLowerCase())),
+    integration: wp.integration === "merge" ? "merge" : "pr",
+    defaultTargetBranch: preset === "github-flow" ? "main" : preset === "trunk-based" ? "master" : "develop"
+  };
 };
-var verifyNativeReconciliation = (verifier, input, binding) => {
-  if (!verifier?.verifyReconciliation)
-    return failure("permission_denied", "native reconciliation authority is unavailable");
-  const result = verifier.verifyReconciliation(input);
-  if (!result.ok || !validProvenance(result.data, input.caller))
-    return failure("permission_denied", "native reconciliation observation was not attested");
-  return success(null, null, trustedAuthority("reconciliation", result.data, {
-    taskId: input.expected.taskId,
-    workspaceId: input.expected.workspaceId,
-    decisionId: input.expected.decisionId,
-    actionRef: input.expected.actionRef,
-    taskRevision: input.expected.taskRevision,
-    workspaceRevision: input.expected.workspaceRevision,
-    outcome: input.expected.outcome,
-    evidenceDigest: input.expected.evidenceDigest,
-    step: input.expected.step,
-    purpose: input.expected.decision.purpose,
-    response: input.expected.decision.response,
-    binding: input.expected.decision.binding,
-    digest: input.expected.decision.digest,
-    requirementIds: [...input.expected.decision.requirementIds]
-  }, binding, input.caller));
+var COMMIT_PRESETS = [
+  "conventional",
+  "gitmoji",
+  "ticket-prefix",
+  "freeform",
+  "custom",
+  "auto"
+];
+var resolveCommitPolicy = (config, workspace) => {
+  const wp = workspace?.commitPolicy ?? {};
+  if (COMMIT_PRESETS.includes(String(wp.preset ?? ""))) {
+    return {
+      preset: wp.preset,
+      ...typeof wp.pattern === "string" ? { pattern: wp.pattern } : {}
+    };
+  }
+  return config.commitPolicy ?? { preset: "conventional" };
 };
-var takeAuthority = (authority, binding, caller) => {
-  const record = verifiedAuthorities.get(authority);
-  verifiedAuthorities.delete(authority);
-  if (!record)
-    return null;
-  if (record.owner !== binding.owner || record.store !== binding.store || record.root !== binding.root || record.root !== record.store.root || canonicalJson(record.caller) !== canonicalJson(caller))
-    return null;
-  return record;
+
+// packages/workit-core/src/core/workspaces.ts
+var readWorkspacesResult = (dir = configDir()) => {
+  const file = path6.join(dir, "workspaces.json");
+  let raw;
+  try {
+    raw = readFileSync3(file, "utf8");
+  } catch {
+    return { status: "missing", path: file, entries: [] };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return { status: "malformed", path: file, entries: [], error: `${file} is not valid JSON` };
+  }
+  if (!isConfigObject(parsed)) {
+    return { status: "malformed", path: file, entries: [], error: `${file} is not a JSON object` };
+  }
+  const list = parsed.workspaces;
+  return {
+    status: "valid",
+    path: file,
+    entries: Array.isArray(list) ? list : []
+  };
 };
-var retireNativeAuthority = (authority) => {
-  const record = verifiedAuthorities.get(authority);
-  verifiedAuthorities.delete(authority);
-  return record?.provenance ?? null;
+var loadWorkspacesFrom = (dir) => readWorkspacesResult(dir).entries;
+var globToRegExp = (glob) => {
+  let out = "";
+  for (let i = 0;i < glob.length; i++) {
+    const c = glob[i];
+    if (c === "*") {
+      if (glob[i + 1] === "*") {
+        if (glob[i + 2] === "/") {
+          if (out === "")
+            out += "/?";
+          out += "(?:[^/]+/)*";
+          i += 2;
+        } else {
+          if (i + 2 >= glob.length) {
+            if (out.endsWith("/")) {
+              out = out.slice(0, -1);
+              out += "(?:/.*)?";
+            } else {
+              out += ".*";
+            }
+          } else {
+            out += ".*";
+          }
+          i++;
+        }
+      } else {
+        out += "[^/]*";
+      }
+    } else {
+      out += c.replace(/[.+?^${}()|[\]\\]/g, "\\$&");
+    }
+  }
+  return new RegExp(`^${out}$`);
 };
-var authorityMatches = (authority, expected) => authority.kind === "action" && authority.taskId === expected.taskId && authority.workspaceId === expected.workspaceId && authority.decisionId === expected.decisionId && sameRef(authority.actionRef, expected.actionRef) && authority.taskRevision === expected.taskRevision && authority.workspaceRevision === expected.workspaceRevision && authority.outcome === expected.outcome;
-var authorityDecisionMatches = (authority, decision) => authority.purpose === decision.purpose && authority.response === decision.response && authority.digest === decision.digest && canonicalJson(authority.binding) === canonicalJson(decision.binding) && canonicalJson(authority.requirementIds) === canonicalJson(decision.requirementIds);
-var provenanceMatches = (left, right) => left.kind === "host_observed" && right.kind === "host_observed" && left.host === right.host && canonicalJson(left.session) === canonicalJson(right.session);
-function applicableDecision(task, purpose, binding, checkoutRoot) {
-  if (binding.taskId !== task.id || binding.workspaceId !== task.workspaceId)
-    return [];
-  return task.decisions.filter((entry) => entry.provenance.kind !== "imported" && decisionMatches(entry, purpose, binding) && (checkoutRoot ? verifyDecisionContentAtRoot(checkoutRoot, entry.data.binding).ok : entry.data.binding.contentRefs.every((reference) => reference.kind !== "file"))).map((entry) => entry.data);
-}
-var digestBytes2 = (bytes) => createHash3("sha256").update(bytes).digest("hex");
-var verifyDecisionContentAtRoot = (checkoutRoot, binding) => {
-  let root;
+var matchWorkspace = (glob, target) => globToRegExp(glob.replaceAll("\\", "/")).test(target.replaceAll("\\", "/"));
+var realpathOf = (p) => {
+  const real = realpathSync2.native ?? realpathSync2;
   try {
-    root = fs5.realpathSync(checkoutRoot);
+    return real(p);
   } catch {
-    return failure("permission_denied", "checkout root is unavailable");
+    return p;
   }
-  for (const reference of binding.contentRefs) {
-    if (reference.kind !== "file")
+};
+var canonicalGlob = (glob) => {
+  const m = /[*?[\]{]/.exec(glob);
+  const prefix = m ? glob.slice(0, m.index) : glob;
+  const rest = m ? glob.slice(m.index) : "";
+  if (!prefix)
+    return glob;
+  const real = realpathOf(prefix.replace(/\/+$/, "") || "/");
+  return real + (prefix.endsWith("/") ? "/" : "") + rest;
+};
+var resolveWorkspaceFrom = (cwd, dir) => {
+  const targets = [cwd, realpathOf(cwd)].map((p) => p.replaceAll("\\", "/"));
+  for (const entry of loadWorkspacesFrom(dir)) {
+    if (!entry || typeof entry !== "object")
       continue;
-    if (!reference.digest)
-      return failure("invalid_input", "document references require a byte digest");
-    const target = path5.resolve(root, reference.path);
-    if (target !== root && !target.startsWith(`${root}${path5.sep}`))
-      return failure("invalid_input", "document reference escapes checkout; cite it as an external file:// reference instead", {
-        fields: [
-          { path: "contentRefs.path", reason: `${reference.path} is outside the checkout` }
-        ]
-      });
-    try {
-      const relative = path5.relative(root, target);
-      let current = root;
-      for (const segment of relative.split(path5.sep)) {
-        if (!segment)
-          continue;
-        current = path5.join(current, segment);
-        const stat = fs5.lstatSync(current);
-        const real = fs5.realpathSync(current);
-        if (real !== root && !real.startsWith(`${root}${path5.sep}`))
-          return failure("invalid_input", "document reference escapes checkout; cite it as an external file:// reference instead", {
-            fields: [
-              {
-                path: "contentRefs.path",
-                reason: `${reference.path} resolves outside the checkout`
-              }
-            ]
-          });
-        if (stat.isSymbolicLink())
-          return failure("invalid_input", "document reference uses a symlink");
-        if (current === target && !stat.isFile())
-          return failure("invalid_input", "document reference is not a regular file");
-        if (current !== target && !stat.isDirectory())
-          return failure("invalid_input", "document reference ancestor is not a directory");
-      }
-      if (digestBytes2(fs5.readFileSync(target)) !== reference.digest)
-        return failure("permission_denied", "approved document bytes have changed");
-    } catch {
-      return failure("invalid_input", "approved document is unavailable");
+    const ws = entry;
+    if (typeof ws.glob !== "string" || !ws.glob)
+      continue;
+    const glob = ws.glob.replaceAll("\\", "/");
+    const canonical = canonicalGlob(glob);
+    for (const target of targets) {
+      if (matchWorkspace(glob, target))
+        return ws;
+      if (canonical !== glob && matchWorkspace(canonical, target))
+        return ws;
     }
   }
-  return success(null, null, null);
+  return null;
 };
-var verifyContentRefs = (store, binding) => verifyDecisionContentAtRoot(store.root, binding);
-var storedDecisionApplicable = (store, task, purpose, binding) => task.decisions.filter((entry) => entry.provenance.kind !== "imported" && decisionMatches(entry, purpose, binding) && verifyDecisionContentAtRoot(store.root, entry.data.binding).ok);
-var validateAction = (store, task, workspaceId, input, authority) => {
-  if (task.status !== "active")
-    return failure("invalid_transition", "only active tasks can authorize actions");
-  if (!refSchema.safeParse(input.actionRef).success)
-    return failure("invalid_input", "action reference is invalid");
-  const entry = task.decisions.find((candidate) => candidate.id === input.decisionId);
-  if (!entry)
-    return failure("not_found", "decision not found");
-  const decision = entry.data;
-  if (decision.purpose !== "action")
-    return failure("permission_denied", "decision is not an action approval");
-  if (!authorityMatches(authority, {
-    taskId: task.id,
-    workspaceId,
-    decisionId: input.decisionId,
-    actionRef: input.actionRef,
-    taskRevision: input.expectedRevision,
-    workspaceRevision: input.expectedWorkspaceRevision,
-    outcome: "reserve"
-  }))
-    return failure("permission_denied", "native reservation authority is not bound");
-  if (!authorityDecisionMatches(authority, decision))
-    return failure("permission_denied", "native reservation authority does not match decision");
-  if (decision.response !== "approved")
-    return failure("permission_denied", "decision was rejected");
-  if (entry.provenance.kind !== "host_observed" || entry.provenance.receipts.length === 0 || !provenanceMatches(entry.provenance, authority.provenance))
-    return failure("permission_denied", "action approval lacks native receipt assurance");
-  if (decision.revoked)
-    return failure("permission_denied", "decision is revoked");
-  if (decision.digest !== decisionDigest(decision))
-    return failure("permission_denied", "decision binding is invalid");
-  if (decision.binding.taskId !== task.id || decision.binding.workspaceId !== workspaceId)
-    return failure("permission_denied", "decision task or workspace binding is invalid");
-  if (input.binding && canonicalJson(input.binding) !== canonicalJson(decision.binding))
-    return failure("permission_denied", "action binding does not match the approved decision");
-  const content = verifyContentRefs(store, decision.binding);
-  if (!content.ok)
-    return content;
-  const requestedSteps = parseSteps(decision.binding.approvedContent);
-  if (requestedSteps === null)
-    return failure("invalid_input", "bounded action steps must be a unique non-empty array");
-  if (input.steps && canonicalJson(input.steps) !== canonicalJson(requestedSteps.map(chainStepKey)))
-    return failure("permission_denied", "bounded action steps do not match approved content");
-  const stored = task.actionProgress?.find((item) => item.decisionId === input.decisionId);
-  const workflow = stored ? { steps: stored.steps, completed: stored.completedSteps } : { steps: requestedSteps.map(chainStepKey), completed: [] };
-  if (workflow.steps.length && requestedSteps.length && canonicalJson(workflow.steps) !== canonicalJson(requestedSteps.map(chainStepKey)))
-    return failure("permission_denied", "bounded action scope changed");
-  return success(null, null, { entry, workflow });
+var resolveWorkspace = (cwd) => resolveWorkspaceFrom(cwd, configDir());
+
+// packages/workit-core/src/core/branch.ts
+import { existsSync as existsSync4, mkdirSync as mkdirSync3, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "node:fs";
+import { execFileSync as execFileSync2 } from "node:child_process";
+import path8 from "node:path";
+
+// packages/workit-core/src/core/git.ts
+import { execFileSync } from "node:child_process";
+var run = (cwd, args) => {
+  try {
+    const stdout = execFileSync("git", args, {
+      cwd,
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return { stdout: stdout.trimEnd(), stderr: "", exitCode: 0 };
+  } catch (error) {
+    const e = error;
+    return {
+      stdout: (e.stdout ?? "").trimEnd(),
+      stderr: (e.stderr ?? "").trimEnd(),
+      exitCode: e.status ?? 1
+    };
+  }
 };
-function reserveAction(input) {
-  if (!input.store || !input.expectedRevision || !input.expectedWorkspaceRevision)
-    return failure("invalid_input", "action reservation preconditions are required");
-  const authority = takeAuthority(input.authority, {
-    owner: input.authorityOwner,
-    store: input.store,
-    root: input.store.root
-  }, input.authorityCaller);
-  if (!authority)
-    return failure("permission_denied", "native reservation authority is not verified");
-  const changed = input.store.mutateTask(input.taskId, input.expectedRevision, (current, mutation) => {
-    const workspace = input.store.readWorkspace();
-    if (!workspace.ok)
-      return workspace;
-    if (!workspace.data)
-      return failure("not_found", "workspace not found");
-    if (workspace.data.revision !== input.expectedWorkspaceRevision)
-      return failure("revision_conflict", "workspace revision does not match", {
-        expectedWorkspaceRevision: input.expectedWorkspaceRevision,
-        actualWorkspaceRevision: workspace.data.revision
-      });
-    const valid = validateAction(input.store, current, workspace.data.id, input, authority);
-    if (!valid.ok)
-      return valid;
-    const { entry, workflow } = valid.data;
-    const existing = entry.data.consumption;
-    if (existing?.state === "uncertain")
-      return failure("external_outcome_unknown", "previous action outcome is unknown", {
-        operation: "reserve_action",
-        outcome: "unknown"
-      });
-    if (existing?.state === "consumed")
-      return failure("permission_denied", "action approval is consumed");
-    if (existing?.state === "reserved" && workflow.completed.length === 0)
-      return failure("permission_denied", "action approval is already reserved");
-    const requestedStep = input.step ?? workflow.steps[workflow.completed.length];
-    if (workflow.steps.length && (!requestedStep || requestedStep !== workflow.steps[workflow.completed.length]))
-      return failure("permission_denied", "action step is outside the approved remaining workflow");
-    if (requestedStep && workflow.completed.includes(requestedStep))
-      return failure("permission_denied", "action step was already completed");
-    const nextDecision = {
-      ...entry.data,
-      consumption: { state: "reserved", at: mutation.now, actionRef: input.actionRef }
-    };
-    const actionProgress = workflow.steps.length ? [
-      ...(current.actionProgress ?? []).filter((progress) => progress.decisionId !== input.decisionId),
-      {
-        decisionId: input.decisionId,
-        steps: [...workflow.steps],
-        completedSteps: [...workflow.completed]
-      }
-    ] : current.actionProgress ?? [];
-    return success(mutation.revision, null, {
-      ...current,
-      actionProgress,
-      decisions: current.decisions.map((candidate) => candidate.id === input.decisionId ? { ...candidate, data: nextDecision } : candidate)
-    });
-  }, input.native?.now);
-  if (!changed.ok)
-    return changed;
-  const workspace = input.store.readWorkspace();
-  if (!workspace.ok || !workspace.data)
-    return failure("recovery_required", "workspace disappeared after reservation");
-  const entry = changed.data.decisions.find((candidate) => candidate.id === input.decisionId);
-  if (!entry)
-    return failure("recovery_required", "reserved decision disappeared");
-  const workflow = changed.data.actionProgress?.find((progress) => progress.decisionId === input.decisionId) ?? {
-    steps: [],
-    completedSteps: []
-  };
-  return success(changed.data.revision, workspace.data.revision, {
-    taskId: input.taskId,
-    decisionId: input.decisionId,
-    actionRef: input.actionRef,
-    taskRevision: changed.data.revision,
-    workspaceRevision: workspace.data.revision,
-    completedSteps: [...workflow.completedSteps],
-    remainingSteps: workflow.steps.slice(workflow.completedSteps.length)
-  });
-}
-function settleAction(input) {
-  if (!input.store || !input.taskRevision || !input.workspaceRevision)
-    return failure("invalid_input", "action settlement preconditions are required");
-  const authority = takeAuthority(input.authority, {
-    owner: input.authorityOwner,
-    store: input.store,
-    root: input.store.root
-  }, input.authorityCaller);
-  if (!authority)
-    return failure("permission_denied", "native settlement authority is not verified");
-  if (!refSchema.safeParse(input.actionRef).success)
-    return failure("invalid_input", "action reference is invalid");
-  if (!authorityMatches(authority, {
-    taskId: input.taskId,
-    workspaceId: authority.workspaceId,
-    decisionId: input.decisionId,
-    actionRef: input.actionRef,
-    taskRevision: input.taskRevision,
-    workspaceRevision: input.workspaceRevision,
-    outcome: input.outcome
-  }))
-    return failure("permission_denied", "native settlement authority is not verified");
-  let outcomeResult = null;
-  const changed = input.store.mutateTask(input.taskId, input.taskRevision, (current, mutation) => {
-    const workspace = input.store.readWorkspace();
-    if (!workspace.ok)
-      return workspace;
-    if (!workspace.data)
-      return failure("not_found", "workspace not found");
-    if (!authorityMatches(authority, {
-      taskId: input.taskId,
-      workspaceId: workspace.data.id,
-      decisionId: input.decisionId,
-      actionRef: input.actionRef,
-      taskRevision: input.taskRevision,
-      workspaceRevision: input.workspaceRevision,
-      outcome: input.outcome
-    }))
-      return failure("permission_denied", "native settlement authority does not match context");
-    if (workspace.data.revision !== input.workspaceRevision)
-      return failure("revision_conflict", "workspace revision does not match", {
-        expectedWorkspaceRevision: input.workspaceRevision,
-        actualWorkspaceRevision: workspace.data.revision
-      });
-    const entry = current.decisions.find((candidate) => candidate.id === input.decisionId);
-    if (!entry)
-      return failure("not_found", "decision not found");
-    if (!authorityDecisionMatches(authority, entry.data))
-      return failure("permission_denied", "native settlement authority does not match decision");
-    if (!provenanceMatches(entry.provenance, authority.provenance))
-      return failure("permission_denied", "native settlement caller does not match approval");
-    if (entry.data.purpose !== "action" || entry.data.digest !== decisionDigest(entry.data))
-      return failure("permission_denied", "decision binding is invalid");
-    if (entry.data.consumption?.state === "uncertain")
-      return failure("external_outcome_unknown", "previous action outcome is unknown", {
-        operation: "settle_action",
-        outcome: "unknown"
-      });
-    if (entry.data.consumption?.state !== "reserved")
-      return failure("permission_denied", "action is not reserved");
-    if (canonicalJson(entry.data.consumption.actionRef) !== canonicalJson(input.actionRef))
-      return failure("permission_denied", "settlement reference does not match reservation");
-    const stored = current.actionProgress?.find((progress) => progress.decisionId === input.decisionId);
-    const workflow = stored ? { steps: stored.steps, completed: stored.completedSteps } : { steps: [], completed: [] };
-    if (entry.data.binding.approvedContent && !stored && (parseSteps(entry.data.binding.approvedContent) ?? []).length)
-      return failure("recovery_required", "bounded action progress is missing");
-    const currentStep = input.step ?? workflow.steps[workflow.completed.length];
-    if (workflow.steps.length && (!currentStep || currentStep !== workflow.steps[workflow.completed.length]))
-      return failure("permission_denied", "settlement step is outside the approved workflow");
-    if (input.outcome === "unknown") {
-      outcomeResult = failure("external_outcome_unknown", "external action outcome is unknown", {
-        operation: "settle_action",
-        outcome: "unknown"
-      });
-      const uncertain = {
-        ...entry.data,
-        consumption: { ...entry.data.consumption, state: "uncertain", at: mutation.now }
-      };
-      return success(mutation.revision, null, {
-        ...current,
-        decisions: current.decisions.map((candidate) => candidate.id === input.decisionId ? { ...candidate, data: uncertain } : candidate)
-      });
-    }
-    if (input.outcome === "not_started") {
-      const released = { ...entry.data, consumption: null };
-      return success(mutation.revision, null, {
-        ...current,
-        decisions: current.decisions.map((candidate) => candidate.id === input.decisionId ? { ...candidate, data: released } : candidate)
-      });
-    }
-    if (currentStep)
-      workflow.completed.push(currentStep);
-    const complete = !workflow.steps.length || workflow.completed.length >= workflow.steps.length;
-    const settled = {
-      ...entry.data,
-      consumption: complete ? { ...entry.data.consumption, state: "consumed", at: mutation.now } : null
-    };
-    const actionProgress = workflow.steps.length ? [
-      ...(current.actionProgress ?? []).filter((progress) => progress.decisionId !== input.decisionId),
-      {
-        decisionId: input.decisionId,
-        steps: [...workflow.steps],
-        completedSteps: [...workflow.completed]
-      }
-    ] : current.actionProgress ?? [];
-    const next = {
-      ...current,
-      actionProgress,
-      decisions: current.decisions.map((candidate) => candidate.id === input.decisionId ? { ...candidate, data: settled } : candidate)
-    };
-    if (!complete) {
-      outcomeResult = success(mutation.revision, input.workspaceRevision, {
-        ...entry,
-        data: settled
-      });
-    }
-    return success(mutation.revision, null, next);
-  }, input.native?.now);
-  if (!changed.ok)
-    return changed;
-  const entry = changed.data.decisions.find((candidate) => candidate.id === input.decisionId);
-  if (!entry)
-    return failure("recovery_required", "settled decision disappeared");
-  if (outcomeResult)
-    return outcomeResult;
-  return success(changed.data.revision, input.workspaceRevision, entry);
-}
-function reconcileAction(input) {
-  if (!input.store || !input.taskRevision || !input.workspaceRevision || !input.evidenceDigest)
-    return failure("invalid_input", "action reconciliation preconditions are required");
-  const authority = takeAuthority(input.authority, { owner: input.authorityOwner, store: input.store, root: input.store.root }, input.authorityCaller);
-  if (!authority || authority.kind !== "reconciliation")
-    return failure("permission_denied", "native reconciliation authority is not verified");
-  if (authority.taskId !== input.taskId || authority.decisionId !== input.decisionId || !sameRef(authority.actionRef, input.actionRef) || authority.taskRevision !== input.taskRevision || authority.workspaceRevision !== input.workspaceRevision || authority.outcome !== input.outcome || authority.evidenceDigest !== input.evidenceDigest || authority.step !== input.step)
-    return failure("permission_denied", "native reconciliation authority is not bound");
-  const changed = input.store.mutateTask(input.taskId, input.taskRevision, (current, mutation) => {
-    const workspace = input.store.readWorkspace();
-    if (!workspace.ok)
-      return workspace;
-    if (!workspace.data)
-      return failure("not_found", "workspace not found");
-    if (authority.workspaceId !== workspace.data.id)
-      return failure("permission_denied", "native reconciliation workspace does not match");
-    if (workspace.data.revision !== input.workspaceRevision)
-      return failure("revision_conflict", "workspace revision does not match");
-    const entry = current.decisions.find((candidate) => candidate.id === input.decisionId);
-    if (!entry || entry.data.purpose !== "action")
-      return failure("not_found", "decision not found");
-    if (!authorityDecisionMatches(authority, entry.data) || !provenanceMatches(entry.provenance, authority.provenance))
-      return failure("permission_denied", "native reconciliation caller does not match approval");
-    if (entry.data.response !== "approved" || entry.data.revoked !== null || entry.data.digest !== decisionDigest(entry.data) || entry.data.binding.taskId !== current.id || entry.data.binding.workspaceId !== current.workspaceId || entry.data.binding.workspaceId !== workspace.data.id)
-      return failure("permission_denied", "reconciliation decision binding is invalid");
-    if (entry.data.consumption?.state !== "uncertain")
-      return failure("external_outcome_unknown", "only an uncertain action can be reconciled");
-    if (!sameRef(entry.data.consumption.actionRef, input.actionRef))
-      return failure("permission_denied", "reconciliation reference does not match reservation");
-    const stored = current.actionProgress?.find((progress) => progress.decisionId === input.decisionId);
-    const workflow = stored ? { steps: [...stored.steps], completed: [...stored.completedSteps] } : { steps: [], completed: [] };
-    const currentStep = input.step ?? workflow.steps[workflow.completed.length];
-    if (workflow.steps.length && (!currentStep || currentStep !== workflow.steps[workflow.completed.length]))
-      return failure("permission_denied", "reconciliation step is outside the approved workflow");
-    if (input.outcome === "not_started") {
-      return success(mutation.revision, null, {
-        ...current,
-        decisions: current.decisions.map((candidate) => candidate.id === input.decisionId ? { ...candidate, data: { ...candidate.data, consumption: null } } : candidate)
-      });
-    }
-    if (currentStep)
-      workflow.completed.push(currentStep);
-    const complete = !workflow.steps.length || workflow.completed.length >= workflow.steps.length;
-    const nextDecision = {
-      ...entry.data,
-      consumption: complete ? { ...entry.data.consumption, state: "consumed", at: mutation.now } : null
-    };
-    const actionProgress = workflow.steps.length ? [
-      ...(current.actionProgress ?? []).filter((progress) => progress.decisionId !== input.decisionId),
-      {
-        decisionId: input.decisionId,
-        steps: workflow.steps,
-        completedSteps: workflow.completed
-      }
-    ] : current.actionProgress ?? [];
-    return success(mutation.revision, null, {
-      ...current,
-      actionProgress,
-      decisions: current.decisions.map((candidate) => candidate.id === input.decisionId ? { ...candidate, data: nextDecision } : candidate)
-    });
-  }, input.native?.now);
-  if (!changed.ok)
-    return changed;
-  const entry = changed.data.decisions.find((candidate) => candidate.id === input.decisionId);
-  return entry ? success(changed.data.revision, input.workspaceRevision, entry) : failure("recovery_required", "reconciled decision disappeared");
-}
-var bindingCovers = scopeCovers;
-var verifyDecisionContent = verifyContentRefs;
-
-// packages/workit-core/src/core/task-evaluation.ts
-var digestBytes3 = (value) => createHash4("sha256").update(value).digest("hex");
-var inside = (root, candidate) => candidate === root || candidate.startsWith(`${root}${path6.sep}`);
-var relative = (root, candidate) => path6.relative(root, candidate).split(path6.sep).join("/") || ".";
-var canonicalPath = (value) => {
-  if (typeof value !== "string" || !value)
-    return null;
-  if (value.includes("\\") || value.split("/").includes(".."))
-    return null;
-  const normalized = path6.posix.normalize(value);
-  if (normalized === ".." || normalized.startsWith("../") || normalized.startsWith("/"))
-    return null;
-  return normalized === "." ? "." : normalized.replace(/\/$/, "");
-};
-var canonicalScope = (scope) => {
-  const paths = scope.paths.length ? scope.paths : ["."];
-  const normalizedPaths = paths.map(canonicalPath);
-  const normalizedExclusions = scope.exclusions.map(canonicalPath);
-  if (normalizedPaths.some((value) => value === null) || normalizedExclusions.some((value) => value === null))
-    return null;
-  return {
-    description: scope.description,
-    paths: [...new Set(normalizedPaths)],
-    exclusions: [...new Set(normalizedExclusions)]
-  };
-};
-var excluded = (value, exclusions) => exclusions.some((item) => item === value || item !== "." && value.startsWith(`${item}/`));
-var scopeMatches = (value, scope) => {
-  const normalized = canonicalScope(scope);
-  if (!normalized)
-    return false;
-  const paths = normalized.paths;
-  return paths.some((item) => item === "." || value === item || value.startsWith(`${item}/`)) && !excluded(value, normalized.exclusions);
-};
-var pathRelevant = (value, scope) => scopeMatches(value, scope);
-var compareCodeUnits2 = (left, right) => {
-  const length = Math.min(left.length, right.length);
-  for (let index = 0;index < length; index += 1) {
-    const difference = left.charCodeAt(index) - right.charCodeAt(index);
-    if (difference !== 0)
-      return difference;
-  }
-  return left.length - right.length;
-};
-var gitPaths = (root) => {
-  const result = spawnSync("git", ["ls-files", "-z", "--cached", "--others", "--exclude-standard"], {
-    cwd: root,
-    encoding: "buffer"
-  });
-  if (result.status !== 0) {
-    const stderr = result.stderr?.toString("utf8") ?? "";
-    return {
-      paths: [],
-      uncertain: !/not a git repository/i.test(stderr),
-      git: /not a git repository/i.test(stderr) ? false : true
-    };
-  }
-  const paths = result.stdout ? result.stdout.toString("utf8").split("\x00").filter(Boolean).map((item) => item.split(path6.sep).join("/")) : [];
-  const stagedDeleted = spawnSync("git", ["diff", "--cached", "--name-only", "--diff-filter=D", "-z"], { cwd: root, encoding: "buffer" });
-  if (stagedDeleted.status !== 0) {
-    const stderr = stagedDeleted.stderr?.toString("utf8") ?? "";
-    if (!/not a git repository/i.test(stderr))
-      return { paths, uncertain: true, git: true };
-  } else if (stagedDeleted.stdout) {
-    paths.push(...stagedDeleted.stdout.toString("utf8").split("\x00").filter(Boolean).map((item) => item.split(path6.sep).join("/")));
-  }
-  return { paths: [...new Set(paths)], uncertain: false, git: true };
-};
-var walk = (root, directory, output) => {
-  let names;
-  try {
-    names = fs6.readdirSync(directory);
-  } catch {
-    return true;
-  }
-  let uncertain = false;
-  for (const name of names) {
-    if (name === ".git" || name === ".workit")
-      continue;
-    const target = path6.join(directory, name);
-    let stat;
-    try {
-      stat = fs6.lstatSync(target);
-    } catch {
-      uncertain = true;
-      continue;
-    }
-    const item = relative(root, target);
-    output.add(item);
-    if (stat.isDirectory() && !stat.isSymbolicLink())
-      uncertain = walk(root, target, output) || uncertain;
-  }
-  return uncertain;
-};
-var scopeRoots = (root, scope) => {
-  const roots = [];
-  for (const item of scope.paths.length ? scope.paths : ["."]) {
-    const target = path6.resolve(root, item);
-    if (!inside(root, target))
-      return failure("invalid_input", `candidate scope escapes checkout: ${item} — keep one task per repository and coordinate a separate linked task in the other checkout`, { fields: [{ path: "scope.paths", reason: `${item} is outside the checkout` }] });
-    let ancestor = target;
-    while (!fs6.existsSync(ancestor) && ancestor !== root)
-      ancestor = path6.dirname(ancestor);
-    try {
-      if (!inside(root, fs6.realpathSync(ancestor)))
-        return failure("invalid_input", `candidate scope escapes checkout through a symlink: ${item} — keep one task per repository and coordinate a separate linked task in the other checkout`, { fields: [{ path: "scope.paths", reason: `${item} resolves outside the checkout` }] });
-    } catch {
-      return failure("invalid_input", `candidate scope cannot be inspected: ${item}`);
-    }
-    roots.push(target);
-  }
-  return success(null, null, roots);
-};
-function captureCandidate(root, scope, environment = []) {
-  let checkout;
-  try {
-    checkout = fs6.realpathSync(root);
-  } catch {
-    return failure("invalid_input", "candidate root does not exist");
-  }
-  const normalizedScope = canonicalScope(scope);
-  if (!normalizedScope)
-    return failure("invalid_input", "candidate scope is invalid: paths must be checkout-relative — to work in another repository, keep this task here and coordinate a separate linked task in that checkout", { fields: [{ path: "scope.paths", reason: "must be checkout-relative" }] });
-  const roots = scopeRoots(checkout, normalizedScope);
-  if (!roots.ok)
-    return roots;
-  const git = gitPaths(checkout);
-  const names = new Set;
-  let uncertain = git.uncertain;
-  for (const target of roots.data) {
-    const item = relative(checkout, target);
-    if (item === ".git" || item === ".workit")
-      continue;
-    names.add(item);
-    if (!fs6.existsSync(target))
-      continue;
-    let stat;
-    try {
-      stat = fs6.lstatSync(target);
-    } catch {
-      uncertain = true;
-      continue;
-    }
-    if (!git.git && stat.isDirectory() && !stat.isSymbolicLink())
-      uncertain = walk(checkout, target, names) || uncertain;
-  }
-  for (const item of git.paths)
-    if (scopeMatches(item, normalizedScope))
-      names.add(item);
-  const files = [];
-  let completeness = uncertain ? "uncertain" : "known";
-  for (const item of [...names].sort()) {
-    if (!scopeMatches(item, normalizedScope))
-      continue;
-    const target = path6.join(checkout, item);
-    try {
-      const stat = fs6.lstatSync(target);
-      if (stat.isSymbolicLink()) {
-        const link = fs6.readlinkSync(target);
-        files.push({ path: item, kind: "symlink", digest: digestBytes3(link), executable: null });
-      } else if (stat.isFile()) {
-        files.push({
-          path: item,
-          kind: "file",
-          digest: digestBytes3(fs6.readFileSync(target)),
-          executable: (stat.mode & 73) !== 0
-        });
-      } else if (!stat.isDirectory()) {
-        completeness = "uncertain";
-      } else if (git.git && git.paths.includes(item)) {
-        completeness = "uncertain";
-      }
-    } catch (error) {
-      if (error?.code === "ENOENT") {
-        files.push({ path: item, kind: "absent", digest: null, executable: null });
-      } else
-        completeness = "uncertain";
-    }
-  }
-  const supplied = Array.isArray(environment) ? environment.map((value) => typeof value === "string" ? { name: value, value: process.env[value] ?? null } : { name: value.name, value: value.value ?? null }) : Object.keys(environment).map((name) => ({
-    name,
-    value: environment[name] ?? null
-  }));
-  const namesByEnvironment = supplied.map(({ name }) => name);
-  if (new Set(namesByEnvironment).size !== namesByEnvironment.length || namesByEnvironment.some((name) => typeof name !== "string" || !name))
-    return failure("invalid_input", "candidate environment names must be unique and non-empty");
-  const values = supplied.sort((left, right) => compareCodeUnits2(left.name, right.name)).map(({ name, value }) => ({ name, value, refs: [] }));
-  if (values.some(({ value }) => value === null))
-    completeness = "uncertain";
-  const headResult = spawnSync("git", ["rev-parse", "HEAD"], { cwd: checkout, encoding: "utf8" });
-  if (headResult.status !== 0 && !/not a git repository/i.test(headResult.stderr ?? ""))
-    completeness = "uncertain";
-  const head = headResult.status === 0 ? headResult.stdout.trim() : null;
-  const partial = {
-    id: "0".repeat(64),
-    scope: normalizedScope,
-    completeness,
-    files,
-    environment: values,
-    head
+var gitContext = (workspaceRoot, paths = []) => {
+  const cwd = workspaceRoot;
+  let failure;
+  const runHere = (args) => {
+    const result = run(cwd, args);
+    if (!failure && result.exitCode !== 0) {
+      failure = { stderr: result.stderr, exitCode: result.exitCode };
+    }
+    return result.stdout;
   };
-  const candidate = { ...partial, id: candidateDigest(partial) };
-  const parsed = candidateSchema.safeParse(candidate);
-  return parsed.success ? success(null, null, parsed.data) : failure("invalid_input", "captured candidate is invalid");
-}
-var fileMap = (candidate) => new Map(candidate.files.map((file) => [file.path, file]));
-var changedPaths = (before, after) => {
-  const paths = new Set([...before.files, ...after.files].map((file) => file.path));
-  const left = fileMap(before);
-  const right = fileMap(after);
-  const changed = [...paths].filter((item) => JSON.stringify(left.get(item) ?? null) !== JSON.stringify(right.get(item) ?? null));
-  if (before.head !== after.head)
-    changed.push(".");
-  if (JSON.stringify(before.environment) !== JSON.stringify(after.environment))
-    changed.push(".");
-  return changed;
-};
-var sessionFromRef = (value) => {
-  if (typeof value !== "object" || value === null || value.kind !== "host")
-    return null;
-  return typeof value.host === "string" && typeof value.handle === "string" ? { host: value.host, handle: value.handle } : null;
-};
-var sameSession = (left, right) => {
-  const other = sessionFromRef(right);
-  return left !== null && other !== null && left.host === other.host && left.handle === other.handle;
-};
-var evidenceScopes = (task, ids) => (task.policy?.requirements ?? []).filter((requirement) => ids.includes(requirement.id)).map((requirement) => requirement.scope);
-function evaluateEvidence(task, candidate) {
-  const current = candidate ?? task.candidates.at(-1) ?? null;
-  return task.evidence.map((entry) => {
-    const evidence = entry.data;
-    if (evidence.result === "failed")
-      return {
-        evidenceId: entry.id,
-        status: "failed",
-        reason: "failed evidence remains historical"
-      };
-    if (evidence.kind === "check" || evidence.kind === "review") {
-      if (!evidence.beforeCandidateId || !evidence.candidateId)
-        return {
-          evidenceId: entry.id,
-          status: "stale",
-          reason: "check or review evidence lacks start and end candidates"
-        };
-      if (evidence.beforeCandidateId !== evidence.candidateId)
-        return {
-          evidenceId: entry.id,
-          status: "stale",
-          reason: "candidate changed during the check or review"
-        };
+  const branch = runHere(["rev-parse", "--abbrev-ref", "HEAD"]) || "unknown";
+  const status_short = runHere(["status", "--porcelain"]);
+  const staged = [];
+  const unstaged = [];
+  const untracked = [];
+  for (const line of status_short.split(`
+`).filter(Boolean)) {
+    const code = line.slice(0, 2);
+    const file = line.slice(3);
+    if (code === "??") {
+      untracked.push(file);
+    } else {
+      if (code[0] !== " " && code[0] !== "?")
+        staged.push(file);
+      if (code[1] !== " " && code[1] !== "?")
+        unstaged.push(file);
     }
-    if (!evidence.candidateId || !current)
-      return {
-        evidenceId: entry.id,
-        status: evidence.result,
-        reason: "evidence has no candidate binding"
-      };
-    const observed = task.candidates.find((item) => item.id === evidence.candidateId) ?? (current.id === evidence.candidateId ? current : undefined);
-    if (!observed || observed.completeness === "uncertain" || current.completeness === "uncertain")
-      return { evidenceId: entry.id, status: "stale", reason: "candidate is missing or uncertain" };
-    if (observed.id === current.id)
-      return { evidenceId: entry.id, status: evidence.result, reason: "candidate is unchanged" };
-    const scopes = evidenceScopes(task, evidence.requirementIds);
-    const changed = changedPaths(observed, current);
-    const environmentChanged = JSON.stringify(observed.environment) !== JSON.stringify(current.environment);
-    if (!scopes.length || environmentChanged || changed.some((item) => scopes.some((scope) => pathRelevant(item, scope))))
-      return { evidenceId: entry.id, status: "stale", reason: "relevant candidate state changed" };
-    return {
-      evidenceId: entry.id,
-      status: evidence.result,
-      reason: "candidate changed outside evidence scope"
-    };
-  });
-}
-var scopeCovers2 = scopeCovers;
-var checkPin = (assignment, beforeCandidateId, candidateId) => {
-  const pin = assignment.candidateId ?? null;
-  if (pin === null)
-    return true;
-  return (beforeCandidateId ?? null) === pin || (candidateId ?? null) === pin;
-};
-var resolveBinding = (evidence, pin, currentCandidateId) => {
-  const bound = evidence.kind === "check" || evidence.kind === "review";
-  const fallback = bound ? pin ?? currentCandidateId : null;
+  }
+  const pathArgs = paths.length ? ["--", ...paths] : [];
+  const diff_stat = runHere(["diff", "--stat", ...pathArgs]);
+  const cached_stat = runHere(["diff", "--cached", "--stat", ...pathArgs]);
+  const stagedSet = new Set(staged);
+  const unstagedSet = new Set(unstaged);
+  const partial_staged = [...stagedSet].filter((f) => unstagedSet.has(f));
   return {
-    beforeCandidateId: evidence.beforeCandidateId ?? fallback,
-    candidateId: evidence.candidateId ?? fallback
+    workspace_root: cwd,
+    branch,
+    status_short,
+    staged,
+    unstaged,
+    untracked,
+    diff_stat: [diff_stat, cached_stat].filter(Boolean).join(`
+`),
+    partial_staged: partial_staged.length > 0,
+    partial_staged_files: partial_staged,
+    ...failure ? { stderr: failure.stderr, exitCode: failure.exitCode } : {}
   };
 };
-var findingVerificationPasses = (findingCandidateId, evidence) => evidence.status === "passed" && (evidence.kind === "check" || evidence.kind === "review") && ((findingCandidateId ?? null) === null || evidence.candidateId === findingCandidateId);
-var applicableDecision2 = (task, workspace, requirement, checkoutRoot) => task.decisions.filter((entry) => entry.provenance.kind !== "imported").map((entry) => entry.data).filter((decision) => decision.purpose === "limitation" && decision.response === "approved" && decision.revoked === null && decision.binding.taskId === task.id && decision.binding.workspaceId === workspace.id && decision.requirementIds.includes(requirement.id) && decision.binding.scope && scopeCovers2(decision.binding.scope, requirement.scope) && decision.digest === decisionDigest(decision) && (checkoutRoot ? verifyDecisionContentAtRoot(checkoutRoot, decision.binding).ok : decision.binding.contentRefs.every((reference) => reference.kind !== "file")));
-var applicableRequirementDecision = (task, workspace, requirement, checkoutRoot) => task.decisions.filter(({ data, provenance }) => provenance.kind !== "imported" && data.purpose !== "limitation" && (data.response === "approved" || data.response === "stated") && data.revoked === null && data.binding.taskId === task.id && data.binding.workspaceId === workspace.id && data.requirementIds.includes(requirement.id) && scopeCovers2(data.binding.scope, requirement.scope) && data.digest === decisionDigest(data) && (checkoutRoot ? verifyDecisionContentAtRoot(checkoutRoot, data.binding).ok : data.binding.contentRefs.every((reference) => reference.kind !== "file"))).map(({ id }) => ({ id }));
-var evidenceMatchesRequirement = (kind, evidenceKind, dimension, ruleId) => {
-  if (kind !== "passed")
-    return false;
-  if (dimension === "testing" || dimension === "verification")
-    return evidenceKind === "check" || ruleId === "pre-pr-cleanup" && evidenceKind === "artifact";
-  if (dimension === "review")
-    return evidenceKind === "review";
-  if (dimension === "investigation" || dimension === "challenge")
-    return evidenceKind === "investigation";
-  if (dimension === "artifacts" || dimension === "continuity")
-    return evidenceKind === "artifact";
-  return false;
-};
-var expectedKinds = (dimension, ruleId) => {
-  if (dimension === "testing")
-    return "check";
-  if (dimension === "verification")
-    return ruleId === "pre-pr-cleanup" ? "check or artifact" : "check";
-  if (dimension === "review")
-    return "review";
-  if (dimension === "investigation" || dimension === "challenge")
-    return "investigation";
-  if (dimension === "artifacts" || dimension === "continuity")
-    return "artifact";
-  if (dimension === "decisions")
-    return "decision";
-  return "worker report";
-};
-function evaluateRequirements(task, workspace, capabilities, candidate, checkoutRoot, _caller) {
-  const evidence = evaluateEvidence(task, candidate);
-  if (task.policy && task.policy.policyVersion !== POLICY_VERSION)
-    return task.policy.requirements.map((requirement) => ({
-      requirementId: requirement.id,
-      status: "unsatisfied",
-      evidenceIds: [],
-      decisionIds: [],
-      reason: "stored policy version is unsupported; reassessment is required"
-    }));
-  return (task.policy?.requirements ?? []).map((requirement) => {
-    const related = task.evidence.map((entry, index) => ({ entry, evaluation: evidence[index] })).filter(({ entry }) => entry.data.requirementIds.includes(requirement.id));
-    const passed = related.filter(({ entry, evaluation }) => {
-      if (!evidenceMatchesRequirement(evaluation.status, entry.data.kind, requirement.dimension, requirement.ruleId))
-        return false;
-      if ((entry.data.kind === "check" || entry.data.kind === "review") && (!entry.data.beforeCandidateId || !entry.data.candidateId || entry.data.beforeCandidateId !== entry.data.candidateId))
-        return false;
-      if (requirement.dimension !== "review")
-        return true;
-      const reviewSession = sessionFromRef(entry.data.reviewContext);
-      const sameImplementation = sameSession(reviewSession, task.intent.provenance.session);
-      const sameEvidenceSession = related.some(({ entry: other }) => other.id !== entry.id && other.data.kind === "review" && other.data.candidateId !== null && other.data.candidateId === entry.data.candidateId && sameSession(reviewSession, other.provenance.session));
-      return entry.data.kind === "review" && reviewSession !== null && sameSession(reviewSession, entry.provenance.session) && (requirement.ruleId === "self-review" || !sameImplementation && !sameEvidenceSession);
-    });
-    if (passed.length) {
-      const currentId = candidate?.id ?? null;
-      const withRed = requirement.dimension === "testing" ? passed.filter(({ entry }) => related.some((other) => other.entry.data.kind === "check" && other.evaluation.status === "failed" && other.entry.data.requirementIds.includes(requirement.id) && other.entry.recordedAt <= entry.recordedAt) || related.some((baseline) => baseline.entry.id !== entry.id && baseline.entry.data.kind === "check" && baseline.entry.data.result === "passed" && baseline.entry.data.candidateId !== null && currentId !== null && baseline.entry.data.candidateId !== currentId)) : passed;
-      if (withRed.length)
-        return {
-          requirementId: requirement.id,
-          status: "satisfied",
-          evidenceIds: withRed.map(({ entry }) => entry.id),
-          decisionIds: [],
-          reason: "fresh applicable evidence passed"
-        };
-      if (requirement.dimension === "testing")
-        return {
-          requirementId: requirement.id,
-          status: "unsatisfied",
-          evidenceIds: [],
-          decisionIds: [],
-          reason: "testing requirement has GREEN evidence but no preceding RED"
-        };
-    }
-    if (requirement.dimension === "delegation") {
-      const dot = (scope) => scope.paths.length > 0 ? scope : { ...scope, paths: ["."] };
-      const reconciled = task.workers.some((worker) => worker.data.report?.outcome === "completed" && (worker.data.assignment.requirementIds.includes(requirement.id) || scopeCovers2(dot(requirement.scope), dot(worker.data.assignment.scope))));
-      if (reconciled)
-        return {
-          requirementId: requirement.id,
-          status: "satisfied",
-          evidenceIds: [],
-          decisionIds: [],
-          reason: "bounded helper completed and its result is recorded"
-        };
-    }
-    const decisions = requirement.dimension === "decisions" ? applicableRequirementDecision(task, workspace, requirement, checkoutRoot) : [];
-    if (decisions.length)
-      return {
-        requirementId: requirement.id,
-        status: "satisfied",
-        evidenceIds: [],
-        decisionIds: decisions.map((decision) => decision.id),
-        reason: "an applicable approved or stated decision satisfies the requirement"
-      };
-    const limitations = requirement.acceptanceAllowed ? applicableDecision2(task, workspace, requirement, checkoutRoot) : [];
-    if (limitations.length)
-      return {
-        requirementId: requirement.id,
-        status: "accepted_limitation",
-        evidenceIds: [],
-        decisionIds: limitations.map((decision) => task.decisions.find((entry) => entry.data === decision).id),
-        reason: "an applicable approved limitation permits the missing evidence"
-      };
-    const unavailable = capabilities.some((capability) => capability.assurance === "unavailable" && (capability.name === requirement.dimension || capability.surface === requirement.dimension));
-    if (!unavailable && related.length > 0 && !passed.length)
-      return {
-        requirementId: requirement.id,
-        status: "unsatisfied",
-        evidenceIds: related.map(({ entry }) => entry.id),
-        decisionIds: [],
-        reason: `no passing evidence (needs kind:${expectedKinds(requirement.dimension, requirement.ruleId)})`
-      };
+
+// packages/workit-core/src/core/vcs-config.ts
+import fs5 from "node:fs";
+import path7 from "node:path";
+import { spawnSync } from "node:child_process";
+var TOKEN_PLACEHOLDER = "YOUR_TOKEN_HERE";
+var vcsConfigPath = () => process.env.WORKFLOW_VCS_CONFIG ?? path7.join(configDir(), "vcs.json");
+var vcsCwd = (cwd) => cwd ?? process.env.WORKFLOW_WORKSPACE_ROOT ?? process.cwd();
+var remoteProvider = (cwd) => {
+  const r = spawnSync("git", ["remote", "get-url", "origin"], { cwd, encoding: "utf8" });
+  if (r.status !== 0)
+    return null;
+  const url = (r.stdout ?? "").trim();
+  if (/github\.com[:/]/.test(url))
+    return "github";
+  if (/gitlab\.com[:/]/.test(url))
+    return "gitlab";
+  return null;
+};
+var readVcsConfig = () => {
+  const file = vcsConfigPath();
+  let raw;
+  try {
+    raw = fs5.readFileSync(file, "utf8");
+  } catch {
+    return { status: "missing", path: file, config: {} };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return { status: "malformed", path: file, config: {}, error: `${file} is not valid JSON` };
+  }
+  if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+    return { status: "valid", path: file, config: parsed };
+  }
+  return { status: "malformed", path: file, config: {}, error: `${file} is not a JSON object` };
+};
+function vcsConfig(mode, cwd) {
+  const ws = resolveWorkspace(vcsCwd(cwd));
+  const wsVcs = ws?.vcs ?? {};
+  const wsYt = ws?.youtrack ?? {};
+  const wsIssues = ws?.issues ?? {};
+  const { status: cfgStatus, path: cfgPath, config: cfg, error: cfgError } = readVcsConfig();
+  const root = vcsCwd(cwd);
+  const determinateRoot = cwd !== undefined || process.env.WORKFLOW_WORKSPACE_ROOT !== undefined;
+  const rawProvider = wsVcs.provider ?? (determinateRoot ? remoteProvider(root) : null) ?? cfg.provider ?? null;
+  const provider = rawProvider === null || rawProvider === undefined ? null : String(rawProvider).toLowerCase() || null;
+  const wp = ws?.branchPolicy ?? {};
+  const hasWorkspacePolicy = typeof wp.preset === "string" && Object.hasOwn(PRESETS, wp.preset);
+  const policyDefault = resolveBranchPolicyFor(root).defaultTargetBranch;
+  const defaultTarget = String(wsVcs.defaultTargetBranch ?? (hasWorkspacePolicy ? policyDefault : cfg.defaultTargetBranch ?? policyDefault) ?? "develop");
+  const linkIssues = typeof wsYt.link_issues === "boolean" ? wsYt.link_issues : null;
+  const youtrackBaseUrl = typeof wsYt.baseUrl === "string" ? wsYt.baseUrl : null;
+  let issuesProvider = null;
+  let linkOnPr = null;
+  if (provider === "github" && typeof wsIssues.provider === "string" && wsIssues.provider.toLowerCase() === "github") {
+    issuesProvider = "github";
+    linkOnPr = typeof wsIssues.link_on_pr === "boolean" ? wsIssues.link_on_pr : null;
+  }
+  if (mode === "resolve") {
+    if (cfgStatus === "malformed")
+      return { ok: false, error: cfgError, configPath: cfgPath };
     return {
-      requirementId: requirement.id,
-      status: unavailable ? "unavailable" : "unsatisfied",
-      evidenceIds: related.map(({ entry }) => entry.id),
-      decisionIds: [],
-      reason: unavailable ? "required capability is unavailable" : "no fresh passing evidence"
+      ok: true,
+      workspace_name: ws?.name ?? null,
+      provider,
+      defaultTargetBranch: defaultTarget,
+      link_issues: linkIssues,
+      youtrack_base_url: youtrackBaseUrl,
+      issues_provider: issuesProvider,
+      link_on_pr: linkOnPr
     };
-  });
+  }
+  if (cfgStatus === "malformed") {
+    return { ok: false, error: cfgError, configPath: cfgPath };
+  }
+  if (cfgStatus === "missing") {
+    return { ok: false, error: `vcs.json is missing: ${cfgPath}`, configPath: cfgPath };
+  }
+  if (provider === null) {
+    return {
+      ok: false,
+      error: `no vcs provider configured (set vcs.provider in ${cfgPath}, match a workspace entry, or run inside a checkout with a recognized origin remote)`,
+      configPath: cfgPath
+    };
+  }
+  const prov = cfg[provider] ?? {};
+  const wsTokenFile = typeof wsVcs.tokenFile === "string" && wsVcs.tokenFile.trim() !== "" ? wsVcs.tokenFile : null;
+  const tokenFile = String(wsTokenFile ?? prov.tokenFile ?? path7.join(configDir(), `${provider}.token`));
+  const tokenPath = path7.resolve(tokenFile);
+  let tokenOk = false;
+  if (fs5.existsSync(tokenPath)) {
+    const token = fs5.readFileSync(tokenPath, "utf8").trim();
+    const placeholder = !token || token === TOKEN_PLACEHOLDER || token.startsWith(TOKEN_PLACEHOLDER);
+    tokenOk = !placeholder;
+  }
+  const out = {
+    ok: true,
+    configPath: path7.resolve(cfgPath),
+    provider,
+    defaultTargetBranch: defaultTarget,
+    pr: cfg.pr ?? {},
+    tokenPath,
+    tokenPresent: fs5.existsSync(tokenPath),
+    tokenReady: tokenOk,
+    workspace_name: ws?.name ?? null,
+    link_issues: linkIssues,
+    youtrack_base_url: youtrackBaseUrl,
+    issues_provider: issuesProvider,
+    link_on_pr: linkOnPr
+  };
+  if (provider === "gitlab") {
+    out.gitlab = {
+      host: prov.host ?? "gitlab.com",
+      apiUrl: prov.apiUrl ?? "https://gitlab.com/api/v4"
+    };
+  } else if (provider === "github") {
+    out.github = { host: prov.host ?? "github.com" };
+  }
+  if (mode === "summary")
+    delete out.tokenPath;
+  return out;
 }
-function evaluateClosure(requestedOutcome, view) {
-  if (requestedOutcome !== "stopped" && !view.task.policy)
-    return failure("requirements_unsatisfied", "task has not been assessed");
-  if (view.task.policy && view.task.policy.policyVersion !== POLICY_VERSION)
-    return failure("requirements_unsatisfied", "stored policy version is unsupported; reassessment is required");
-  const evaluations = view.requirements;
-  const openFindings = view.task.findings.filter((entry) => entry.data.disposition === "open");
-  if (requestedOutcome !== "stopped" && openFindings.length)
-    return failure("requirements_unsatisfied", "open findings must be resolved before closure");
-  if (requestedOutcome !== "stopped") {
-    const evidenceById = new Map(view.evidence.map((entry) => [entry.evidenceId, entry.status]));
-    for (const entry of view.task.findings) {
-      if (entry.data.disposition === "fixed") {
-        const verified = entry.data.resolution?.evidenceIds.some((id) => {
-          const evidence = view.task.evidence.find((item) => item.id === id);
-          if (!evidence)
-            return false;
-          return findingVerificationPasses(entry.data.candidateId, {
-            kind: evidence.data.kind,
-            candidateId: evidence.data.candidateId,
-            status: evidenceById.get(id) ?? "missing"
-          });
-        });
-        if (!verified)
-          return failure("requirements_unsatisfied", "fixed findings require current verification");
-      }
-      if (entry.data.disposition === "deferred") {
-        const valid = entry.data.resolution?.decisionIds.some((id) => {
-          const decisionEntry = view.task.decisions.find((item) => item.id === id);
-          const decision = decisionEntry?.data;
-          return Boolean(decision && decisionEntry?.provenance.kind !== "imported" && decision.purpose === "limitation" && decision.response === "approved" && decision.revoked === null && decision.digest === decisionDigest(decision) && verifyDecisionContentAtRoot(view.workspace.root, decision.binding).ok && decision.binding.taskId === view.task.id && decision.binding.workspaceId === view.workspace.id && scopeCovers2(decision.binding.scope, entry.data.scope) && decision.requirementIds.some((requirementId) => view.task.policy?.requirements.some((requirement) => requirement.id === requirementId && requirement.acceptanceAllowed)));
-        });
-        if (!valid)
-          return failure("requirements_unsatisfied", "deferred findings require an approved limitation decision that references an acceptanceAllowed requirement and covers the finding scope");
-      }
+function mergedPrStyle(limit = 6, cwd) {
+  const cfg = vcsConfig("load", cwd);
+  if (!cfg.ok || !cfg.tokenReady)
+    return { ok: false, error: "vcs not configured" };
+  const provider = cfg.provider;
+  const token = fs5.readFileSync(cfg.tokenPath, "utf8").trim();
+  const examples = [];
+  const descInfo = (desc, caseInsensitiveNotes = false) => ({
+    hasNotesSection: caseInsensitiveNotes ? /##\s*notes/i.test(desc) : /##\s*Notes/.test(desc),
+    sections: desc.split(`
+`).filter((l) => l.startsWith("## ")).map((l) => l.trim()),
+    descriptionPreview: desc.slice(0, 600)
+  });
+  if (provider === "gitlab") {
+    const remote = spawnSync("git", ["remote", "get-url", "origin"], { cwd, encoding: "utf8" });
+    if (remote.status !== 0)
+      return { ok: false, error: "no origin remote" };
+    const url = (remote.stdout ?? "").trim();
+    const m = /gitlab\.com[:/](.+?)(?:\.git)?$/.exec(url);
+    if (!m)
+      return { ok: false, error: "not a gitlab.com origin" };
+    const project = m[1];
+    const env = { ...process.env, GITLAB_TOKEN: token };
+    const run = (args) => spawnSync("glab", ["api", ...args], { cwd, encoding: "utf8", env });
+    let r = run([
+      `projects/${project.replaceAll("/", "%2F")}/merge_requests?state=merged&per_page=${limit}&order_by=updated_at&sort=desc`
+    ]);
+    if (r.status !== 0) {
+      r = run([`merge_requests?state=merged&per_page=${limit}&order_by=updated_at&sort=desc`]);
+    }
+    if (r.status !== 0)
+      return { ok: false, error: "could not list merge requests" };
+    for (const mr of JSON.parse(r.stdout ?? "[]")) {
+      const desc = String(mr.description ?? "").trim();
+      examples.push({
+        title: mr.title,
+        url: mr.web_url,
+        squash: mr.squash,
+        ...descInfo(desc, true)
+      });
+    }
+  } else if (provider === "github") {
+    const r = spawnSync("gh", ["pr", "list", "--state", "merged", "--limit", String(limit), "--json", "title,url,body"], { cwd, encoding: "utf8", env: { ...process.env, GH_TOKEN: token } });
+    if (r.status !== 0)
+      return { ok: false, error: "could not list pull requests" };
+    for (const pr of JSON.parse(r.stdout ?? "[]")) {
+      const desc = String(pr.body ?? "").trim();
+      examples.push({ title: pr.title, url: pr.url, ...descInfo(desc) });
     }
   }
-  const blocking = evaluations.filter((item) => {
-    if (item.status !== "unsatisfied" && item.status !== "unavailable")
-      return false;
-    const requirement = view.task.policy?.requirements.find((candidate) => candidate.id === item.requirementId);
-    return !requirement || requirement.before === "close";
-  });
-  if (requestedOutcome !== "stopped" && blocking.length)
-    return failure("requirements_unsatisfied", "applicable requirements are unsatisfied", {
-      requirementIds: blocking.map((item) => item.requirementId),
-      requirements: blocking.map((item) => {
-        const requirement = view.task.policy?.requirements.find((candidate) => candidate.id === item.requirementId);
-        return {
-          requirementId: item.requirementId,
-          ruleId: requirement?.ruleId ?? "unknown",
-          reason: item.reason,
-          satisfaction: requirement?.satisfaction ?? "",
-          dependentAction: requirement?.dependentAction ?? null
-        };
-      })
-    });
-  const accepted = evaluations.filter((item) => item.status === "accepted_limitation");
-  if (requestedOutcome === "verified" && accepted.length)
-    return failure("requirements_unsatisfied", "accepted limitations cannot be reported as verified", {
-      requirementIds: accepted.map((item) => item.requirementId)
-    });
-  const evidenceIds = [
-    ...new Set([
-      ...evaluations.flatMap((item) => item.evidenceIds),
-      ...view.task.findings.flatMap((item) => item.data.resolution?.evidenceIds ?? [])
-    ])
-  ];
-  const decisionIds = [
-    ...new Set([
-      ...evaluations.flatMap((item) => item.decisionIds),
-      ...view.task.findings.flatMap((item) => item.data.resolution?.decisionIds ?? [])
-    ])
-  ];
-  return success(null, null, {
-    outcome: requestedOutcome === "stopped" ? "stopped" : accepted.length ? "accepted_limitations" : "verified",
-    evidenceIds,
-    decisionIds,
-    requirementIds: evaluations.map((item) => item.requirementId)
-  });
+  return {
+    ok: true,
+    provider,
+    count: examples.length,
+    styleHints: [
+      "Prefer ## Summary bullets + ## Validation or ## Test plan only",
+      "Do not add ## Notes with branch names, commit counts, or diff stats",
+      "Do not paste commit log or diff stat into the body"
+    ],
+    examples
+  };
 }
 
-// packages/workit-core/src/core/methods.ts
-var METHODS = {
-  "workit-challenge": { dimensions: ["challenge", "decisions"] },
-  "workit-behavioral-tdd": { dimensions: ["testing"], ruleIds: ["mechanical-existing-checks"] },
-  "workit-review": { dimensions: ["review"], ruleIds: ["fresh-context-review", "self-review"] },
-  "workit-plan": { dimensions: ["artifacts", "continuity"] },
-  "workit-implement": { dimensions: ["delegation"] },
-  "workit-debug": {},
-  "workit-handoff": {},
-  "workit-deslop": { ruleIds: ["pre-pr-cleanup"] }
+// packages/workit-core/src/core/branch.ts
+var resolveBranchPolicyFor = (workspaceRoot) => resolveBranchPolicy(readConfig(), resolveWorkspace(workspaceRoot));
+var resolveCommitPolicyFor = (workspaceRoot) => resolveCommitPolicy(readConfig(), resolveWorkspace(workspaceRoot));
+var policy = (root) => resolveBranchPolicyFor(root);
+var allowedBranch = (root, name) => policy(root).allowed.some((r) => r.test(name));
+var isProtected = (root, name) => policy(root).protected.has(name.toLowerCase());
+var verifyPushIdentity = (root, provider, account) => {
+  if (!account || typeof account !== "string")
+    return { ok: false, error: "push identity requires a configured area account" };
+  const probe = provider === "gitlab" ? ["api", "user", "--jq", ".username"] : ["api", "user", "--jq", ".login"];
+  const bin = provider === "gitlab" ? "glab" : "gh";
+  let login;
+  try {
+    login = execFileSync2(bin, [...probe], {
+      cwd: root,
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+  } catch {
+    return { ok: false, error: `${bin} identity could not be resolved` };
+  }
+  if (!login || login.toLowerCase() !== account.toLowerCase())
+    return {
+      ok: false,
+      error: `push identity ${login || "(unknown)"} does not match area account ${account}`
+    };
+  return { ok: true };
 };
-var methodMatches = (definition, requirement) => definition.dimensions?.includes(requirement.dimension) === true || definition.ruleIds?.includes(requirement.ruleId) === true;
-var assuranceFor = (id, definition, capabilities) => {
-  const keys = new Set([
-    id,
-    ...definition.dimensions ?? [],
-    ...definition.ruleIds ?? []
-  ]);
-  const matches = capabilities.filter((capability) => keys.has(capability.name) || keys.has(capability.surface));
-  if (id === "workit-review" && matches.length === 0)
-    return { assurance: "unavailable", reasons: ["independent review capability is unavailable"] };
-  if (matches.some((capability) => capability.assurance === "unavailable"))
+var baseBranch = (cwd) => {
+  const resolved = vcsConfig("resolve", cwd);
+  if (resolved.ok === false)
+    return { error: String(resolved.error) };
+  return { base: String(resolved.defaultTargetBranch ?? "develop") };
+};
+var originBaseReady = (cwd, base) => {
+  const run = (args) => execFileSync2("git", args, { cwd, encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] });
+  try {
+    try {
+      run(["fetch", "origin", base, "--prune"]);
+    } catch {
+      run(["fetch", "origin", "--prune"]);
+    }
+    try {
+      execFileSync2("git", ["show-ref", "--verify", "--quiet", `refs/remotes/origin/${base}`], {
+        cwd,
+        stdio: "pipe"
+      });
+    } catch {
+      return {
+        ok: false,
+        error: `origin/${base} missing — push ${base} before creating feature/* or bugfix/* branches`
+      };
+    }
+    return { ok: true };
+  } catch (error) {
     return {
-      assurance: "unavailable",
-      reasons: matches.filter((capability) => capability.assurance === "unavailable").map((capability) => capability.reason)
+      ok: false,
+      error: error instanceof Error ? error.message : "ensure-base-branch failed"
     };
-  if (matches.some((capability) => capability.assurance === "enforced"))
-    return { assurance: "enforced", reasons: matches.map((capability) => capability.reason) };
-  return { assurance: "agent_guided", reasons: matches.map((capability) => capability.reason) };
+  }
 };
-function selectMethods(policy, capabilities) {
-  return Object.entries(METHODS).flatMap(([id, definition]) => {
-    const requirements = policy.requirements.filter((requirement) => methodMatches(definition, requirement));
-    if (requirements.length === 0)
-      return [];
-    const capability = assuranceFor(id, definition, capabilities);
-    const reasons = [
-      ...new Set(requirements.map((requirement) => requirement.reason)),
-      ...capability.reasons
-    ];
-    if (capability.assurance === "unavailable")
-      reasons.unshift("required capability is unavailable");
-    return [{ id, reason: reasons.join("; "), assurance: capability.assurance }];
-  });
-}
-var invariantBootstrap = () => `
-Workit keeps one accountable lead and one shared task state. Inspect current task
-state before acting. An empty task.list means no session yet, not permission to
-skip Workit; for user-requested product, debug, or behavior work with no active
-or paused task, run task.start then policy.assess before other product mutations.
-Omitted expectedRevision, expectedWorkspaceRevision, and writer workerId default
-to the current records; explicit values are still concurrency-checked, so never
-copy revisions between calls. Happy path: task.list, task.start {intent} with no
-revisions, policy.assess {assessment: {facts, signals, consequences,
-verification}} where facts are inferred or observed with file refs,
-writer.acquire {taskId} before product writes, evidence.record {evidence} where
-check and review kinds auto-bind the current tree and need no digests. Record
-self-review requirements with kind review and reviewContext matching your own
-host session; the lead may also record checks. Fresh-context review requires a
-session distinct from the task creator and every other evidence recorder. Record
-verification evidence last: later evidence or commits can reopen fixed findings
-for re-verification, so verify, resolve, then close with nothing in between.
-decision.record {binding with taskId/workspaceId from inspect plus presented and
-approvedContent} only through a native approval question asked receipt-shaped:
-header Workit decision: <purpose>, the same label repeated in the question
-text (some host UIs do not render headers), exactly two options approved and
-rejected; ask once, never re-ask to mint a receipt. Before asking, present the
-item in the conversation (durable artifacts: complete digest plus exact path;
-inline plans: the content) and keep the question to one short scoped sentence;
-never ask to approve something unseen. An answer with custom text is steering,
-not approval: adjust, re-present, then ask a new scoped question. After the user
-approves a spec or plan, execute the remaining tasks continuously with one
-atomic commit per task and do not ask whether to continue; stop only for a new
-product decision, a failed safety or verification gate, a conflicting edit, or
-missing authority. Record the plan's commit list once through the plan-scoped
-action approval (git.commit with plan_steps and plan_branch) so each listed
-commit executes without a new question; an unlisted message needs a fresh
-approval. task.close {outcome,
-summary, decisionIds}. A completed native subagent run stops its bound worker
-by itself; if a worker strands in cancelling with its run verifiably over,
-repeat worker.cancel {reason} to confirm the stop. Check and review evidence
-without a bound candidate goes stale; findings close only as fixed with passing
-verification, dismissed with supporting evidence, or deferred under an approved
-limitation. Use only the
-shared operations for task, policy, evidence, finding, decision, worker, writer,
-and state changes. Authority is bounded by the requested scope, current
-revision, caller/session provenance, and observed capabilities. Never claim host
-enforcement or evidence that the host cannot provide. Shell-executed writes are
-unattested agent-guided work even when a writer is held. Preserve unresolved
-requirements, gaps, and uncertain workers. Skill routing: slash aliases /wk-*
-always load on demand. Model-invoked: new instructions, interruptions, or
-forgotten items mid-task → load workit-steer before responding; about to open
-a PR or fresh from implementing → load workit-deslop; CI red → load
-workit-green-run; small-looking change before close or merge → load
-workit-blast-radius; ambiguous, consequential, or disputed proposal before
-recommending → load workit-challenge; spec or plan needs a flow diagram →
-load workit-diagram, a UI sketch → load workit-mockup. Load the skill; never
-act from memory of it.
-`.trim();
-
-// packages/workit-core/src/core/task-context.ts
-function reconcileResume(view, observations = []) {
-  if (observations.length > 0)
-    return failure("permission_denied", "worker observations require native host verification");
-  const candidate = captureCandidate(view.workspace.root, view.task.intent.data.scope, []);
-  if (!candidate.ok)
-    return candidate;
-  const staleEvidenceIds = evaluateEvidence(view.task, candidate.data).filter((entry) => entry.status === "stale").map((entry) => entry.evidenceId);
-  const blockers = [...view.task.progress.blockers];
-  if (view.task.workers.some((entry) => isUncertainWorker(entry.data.state)))
-    blockers.push({
-      reason: "worker state requires reconciliation",
-      dependentAction: "resume",
-      refs: []
+var fastForwardBase = (cwd, base) => {
+  const run = (args) => execFileSync2("git", args, { cwd, encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] });
+  try {
+    let hasLocalBase = true;
+    try {
+      execFileSync2("git", ["show-ref", "--verify", "--quiet", `refs/heads/${base}`], {
+        cwd,
+        stdio: "pipe"
+      });
+    } catch {
+      hasLocalBase = false;
+    }
+    if (hasLocalBase) {
+      run(["checkout", base]);
+      try {
+        run(["merge", "--ff-only", `origin/${base}`]);
+      } catch {}
+    } else {
+      run(["checkout", "-b", base, "--track", `origin/${base}`]);
+    }
+    return { ok: true };
+  } catch (error) {
+    return {
+      ok: false,
+      error: error instanceof Error ? error.message : "ensure-base-branch failed"
+    };
+  }
+};
+var ensureBaseBranch = (cwd, base) => {
+  const git = gitContext(cwd);
+  if (!git.branch || git.branch === "unknown")
+    return { ok: false, error: "not in a git repository" };
+  const ready = originBaseReady(cwd, base);
+  if (!ready.ok)
+    return ready;
+  return fastForwardBase(cwd, base);
+};
+var classifyBranchDirt = (workspaceRoot) => {
+  let raw;
+  try {
+    raw = execFileSync2("git", ["status", "--porcelain=v1"], {
+      cwd: path8.resolve(workspaceRoot),
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "pipe"]
     });
-  return success(null, null, {
-    candidate: candidate.data,
-    staleEvidenceIds,
-    workerUpdates: [],
-    blockers,
-    reassessmentRequired: view.task.policy?.policyVersion !== POLICY_VERSION
-  });
-}
-var COMPACT_MAX_BYTES = 4096;
-var COMPACT_MAX_ITEMS = 8;
-var COMPACT_TEXT_BYTES = 128;
-var sensitiveUrl = /\bhttps?:\/\/[^/\s:@]+:[^@\s]+@/gi;
-var sensitiveValue = /(?:token|secret|password|passwd|api[-_ ]?key|private[-_ ]?key|authorization)\s*[:=]\s*(?:bearer\s+)?\S+|\bbearer\s+\S+/gi;
-var privateKey = /-----BEGIN [^-]*PRIVATE KEY-----[\s\S]*?-----END [^-]*PRIVATE KEY-----/gi;
-var compactText = (value, limit) => value === null ? null : value.replace(privateKey, "<redacted-private-key>").replace(sensitiveUrl, "<redacted-url>").replace(sensitiveValue, (match) => {
-  const separator = match.search(/[:=]/u);
-  if (separator >= 0)
-    return `${match.slice(0, separator)}=<redacted>`;
-  const space = match.search(/\s/u);
-  return `${match.slice(0, space)} <redacted>`;
-}).slice(0, limit);
-var compactBytes = (value) => new TextEncoder().encode(value).byteLength;
-var compactReference = (ref) => {
-  if (ref.kind === "file")
+  } catch {
+    return "clean";
+  }
+  let dirty = false;
+  for (const line of raw.split(`
+`)) {
+    if (!line.trim())
+      continue;
+    dirty = true;
+    const code = line.slice(0, 2);
+    if (code === "??")
+      continue;
+    let entry = line.slice(3);
+    const arrow = entry.indexOf(" -> ");
+    if (arrow >= 0)
+      entry = entry.slice(arrow + 4);
+    const unquoted = entry.startsWith('"') && entry.endsWith('"') ? entry.slice(1, -1) : entry;
+    if (unquoted !== "docs" && !unquoted.startsWith("docs/"))
+      return "stash-required";
+  }
+  return dirty ? "carry" : "clean";
+};
+var branchSetup = ({
+  action,
+  sdd_dir,
+  target_branch,
+  stash,
+  workspace_root,
+  log
+}) => {
+  const cwd = path8.resolve(workspace_root);
+  const exec = (args) => execFileSync2("git", args, { cwd, encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] });
+  const current = gitContext(cwd).branch;
+  if (!current || current === "unknown")
+    return { error: "not in a git repository", phase: "preflight" };
+  const sdd = sdd_dir ?? "docs";
+  const manifestPath = path8.isAbsolute(sdd) ? path8.join(sdd, "manifest.json") : path8.join(cwd, sdd, "manifest.json");
+  const ensureManifestDir = () => {
+    const dir = path8.dirname(manifestPath);
+    if (!existsSync4(dir))
+      mkdirSync3(dir, { recursive: true, mode: 493 });
+  };
+  const readManifest = () => {
+    try {
+      return JSON.parse(readFileSync4(manifestPath, "utf8"));
+    } catch {
+      return {};
+    }
+  };
+  const writeManifest = (data) => {
+    ensureManifestDir();
+    writeFileSync3(manifestPath, JSON.stringify(data, null, 2) + `
+`, "utf8");
+  };
+  const journal = (message) => log?.(`branch-setup: ${message}`);
+  if (action === "reapply_stash") {
+    const manifest = readManifest();
+    const ref = manifest.stash_ref;
+    if (!ref)
+      return { error: "no stash_ref in manifest", phase: "preflight" };
+    journal(`pre-pop: ${String(ref)}`);
+    try {
+      exec(["stash", "pop", String(ref)]);
+    } catch (error) {
+      journal("pop: failed");
+      return {
+        error: error instanceof Error ? error.message : "stash pop failed",
+        phase: "post_mutation"
+      };
+    }
+    journal("pop: ok");
+    delete manifest.stash_ref;
+    delete manifest.stash_created_at;
+    writeManifest(manifest);
+    return { action: "reapply_stash", ok: true };
+  }
+  const target = target_branch ?? "";
+  if (!target)
     return {
-      kind: "file",
-      path: compactText(ref.path, COMPACT_TEXT_BYTES) ?? ""
+      error: "target_branch (the working branch to create or switch to) is required for setup",
+      phase: "preflight"
     };
-  if (ref.kind === "record")
+  if (isProtected(cwd, target))
+    return { error: `protected branch ${target}`, phase: "preflight" };
+  if (!allowedBranch(cwd, target))
     return {
-      kind: "record",
-      collection: ref.collection,
-      id: ref.id
+      error: `target branch ${target} is not allowed by the branch policy`,
+      phase: "preflight"
     };
-  return { kind: ref.kind };
-};
-function compactTaskContext(view) {
-  const decisions = view.task.decisions.slice().sort((left, right) => left.id < right.id ? -1 : left.id > right.id ? 1 : 0).slice(0, COMPACT_MAX_ITEMS).map((entry) => ({
-    id: entry.id,
-    purpose: entry.data.purpose,
-    status: entry.data.response,
-    digest: entry.data.digest,
-    references: entry.data.binding.contentRefs.slice(0, 1).map(compactReference)
-  }));
-  const methods = view.task.policy ? selectMethods(view.task.policy, view.capabilities).map((method) => ({
-    id: method.id,
-    assurance: method.assurance,
-    reason: compactText(method.reason, COMPACT_TEXT_BYTES) ?? ""
-  })) : [];
-  const gaps = Array.from(new Set([
-    ...view.evidence.filter((entry) => entry.status === "stale").map((entry) => `stale evidence: ${entry.evidenceId}`),
-    ...view.requirements.filter((entry) => entry.status !== "satisfied").map((entry) => entry.reason),
-    ...view.task.progress.blockers.map((entry) => entry.reason)
-  ])).sort().slice(0, COMPACT_MAX_ITEMS).map((gap) => compactText(gap, COMPACT_TEXT_BYTES));
-  const context = {
-    objective: compactText(view.task.intent.data.objective, COMPACT_TEXT_BYTES) ?? "",
-    status: view.task.status,
-    decisions,
-    methods,
-    gaps,
-    nextAction: compactText(view.task.progress.nextAction, COMPACT_TEXT_BYTES)
+  let base;
+  let targetExists = true;
+  try {
+    exec(["rev-parse", "--verify", "--quiet", `refs/heads/${target}`]);
+  } catch {
+    targetExists = false;
+  }
+  if (!targetExists) {
+    const baseResolved = baseBranch(cwd);
+    if ("error" in baseResolved)
+      return { error: baseResolved.error, phase: "preflight" };
+    base = baseResolved.base;
+  }
+  journal(`entry: current=${current} target=${target} base=${base ?? "-"}`);
+  let stash_ref;
+  const failAfterStash = (message, phase = "post_mutation") => {
+    let suffix = "";
+    if (stash_ref) {
+      journal(`pre-pop: ${stash_ref}`);
+      try {
+        exec(["stash", "pop", stash_ref]);
+        stash_ref = undefined;
+        journal("pop: ok");
+      } catch {
+        journal("pop: failed");
+        suffix = " (changes preserved in stash)";
+      }
+    }
+    return { error: `${message}${suffix}`, phase: stash_ref ? "post_mutation" : phase };
   };
-  let encoded = JSON.stringify(context);
-  while (compactBytes(encoded) > COMPACT_MAX_BYTES && (context.decisions.length || context.methods.length || context.gaps.length)) {
-    if (context.gaps.length)
-      context.gaps.pop();
-    else if (context.decisions.length)
-      context.decisions.pop();
-    else
-      context.methods.pop();
-    encoded = JSON.stringify(context);
+  if (current !== target) {
+    const dirty = Boolean(gitContext(cwd).status_short.trim());
+    if (classifyBranchDirt(cwd) === "stash-required" && stash !== "yes") {
+      return {
+        error: "dirty working tree — ask with native question, then call workit_branch_setup with stash=yes",
+        phase: "preflight"
+      };
+    }
+    let validatedBase;
+    if (!targetExists && base !== undefined) {
+      const ready = originBaseReady(cwd, base);
+      if (!ready.ok)
+        return { error: ready.error ?? "ensure-base-branch failed", phase: "preflight" };
+      validatedBase = base;
+    }
+    if (dirty && stash === "yes") {
+      try {
+        exec(["stash", "push", "-u", "-m", `workit: pre-checkout ${target}`]);
+      } catch (error) {
+        return {
+          error: error instanceof Error ? error.message : "stash push failed",
+          phase: "post_mutation"
+        };
+      }
+      stash_ref = "stash@{0}";
+      journal(`stash push: ${stash_ref}`);
+    }
+    try {
+      exec(["checkout", target]);
+      journal("post-checkout");
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "checkout failed";
+      if (/worktree/i.test(message)) {
+        return failAfterStash(`branch ${target} is locked by an existing git worktree — remove it first (we do not use worktrees)`, "preflight");
+      }
+      try {
+        let effectiveBase = base;
+        if (effectiveBase === undefined) {
+          const lateResolved = baseBranch(cwd);
+          if ("error" in lateResolved)
+            return failAfterStash(lateResolved.error, "preflight");
+          effectiveBase = lateResolved.base;
+        }
+        const baseResult = validatedBase !== undefined ? fastForwardBase(cwd, effectiveBase) : ensureBaseBranch(cwd, effectiveBase);
+        if (!baseResult.ok)
+          return failAfterStash(baseResult.error ?? "ensure-base-branch failed");
+        exec(["checkout", "-b", target]);
+        journal("post-create");
+      } catch (createError) {
+        return failAfterStash(createError instanceof Error ? createError.message : "branch create failed");
+      }
+    }
   }
-  if (compactBytes(encoded) > COMPACT_MAX_BYTES) {
-    context.objective = compactText(context.objective, 64) ?? "";
-    context.nextAction = compactText(context.nextAction, 64);
-    encoded = JSON.stringify(context);
+  try {
+    const manifest = readManifest();
+    manifest.branch = target;
+    manifest.previous_branch = current;
+    if (stash_ref) {
+      manifest.stash_ref = stash_ref;
+      manifest.stash_created_at = new Date().toISOString();
+    }
+    writeManifest(manifest);
+  } catch (error) {
+    const result = failAfterStash(error instanceof Error ? `manifest update failed: ${error.message}` : "manifest update failed");
+    if (stash_ref === undefined && gitContext(cwd).branch !== current) {
+      try {
+        exec(["checkout", current]);
+      } catch {
+        try {
+          exec(["checkout", "-m", current]);
+        } catch {}
+      }
+    }
+    return result;
   }
-  return encoded;
-}
-var exportDigest = (bundle) => sha256({
-  schemaVersion: bundle.schemaVersion,
-  exportedAt: bundle.exportedAt,
-  sourceWorkspaceId: bundle.sourceWorkspaceId,
-  task: bundle.task
-});
-// packages/workit-core/src/core/route-intent.ts
-var GUIDANCE = {
-  "git.branch_setup": "use the Workit git.branch_setup action (workit_external_action in hosts, or `workit action git.branch_setup --payload '{}' --confirm --json` in the CLI)",
-  "hosting.pull_request": "use the Workit hosting.pull_request action (workit_external_action in hosts, or `workit action hosting.pull_request --payload '{...}' --confirm --json` in the CLI), then drive the created PR through workit-babysit"
-};
-var unbalancedQuotes = (segment) => {
-  const text = segment.replace(/\\./gu, "");
-  return (text.match(/"/gu)?.length ?? 0) % 2 !== 0 || (text.match(/'/gu)?.length ?? 0) % 2 !== 0;
+  return {
+    action: "setup",
+    ok: true,
+    branch: target,
+    previous_branch: current,
+    stash_ref: stash_ref ?? null,
+    manifest: manifestPath
+  };
 };
-var segmentTokens = (segment) => {
-  if (segment.includes("`") || segment.includes("$("))
-    return null;
-  if (unbalancedQuotes(segment))
+
+// packages/workit-core/src/core/auto-approval.ts
+var AUTO_CLASSES = ["branch", "commit", "push", "pr", "merge"];
+var OPERATION_CLASS = {
+  "git.branch_setup": "branch",
+  "git.commit": "commit",
+  "git.push": "push",
+  "hosting.pull_request": "pr",
+  "hosting.merge": "merge"
+};
+var operationAutoClass = (operation) => typeof operation === "string" ? OPERATION_CLASS[operation] ?? null : null;
+var digestOf = (configDirPath) => {
+  try {
+    const raw = readFileSync5(`${configDirPath}/workspaces.json`, "utf8");
+    return createHash3("sha256").update(raw).digest("hex");
+  } catch {
     return null;
-  const parts = segment.trim().split(/\s+/u);
-  while (parts.length > 0 && /^[A-Za-z_][A-Za-z0-9_]*=/u.test(parts[0]))
-    parts.shift();
-  return parts.length > 0 ? parts : null;
+  }
 };
-var unquote = (token) => token.replace(/^['"]|['"]$/gu, "");
-function shellRouteIntent(command) {
-  if (typeof command !== "string" || command.trim() === "")
-    return null;
-  for (const raw of command.split(/&&|\|\||;|\n/u)) {
-    const parts = segmentTokens(raw);
-    if (!parts)
-      continue;
-    const head = unquote(parts[0]);
-    const second = unquote(parts[1] ?? "");
-    const third = unquote(parts[2] ?? "");
-    if (head === "git" && second === "switch" && (third === "-c" || third === "--create"))
-      return { route: "git.branch_setup", guidance: GUIDANCE["git.branch_setup"] };
-    if (head === "git" && second === "checkout" && (third === "-b" || third === "-B"))
-      return { route: "git.branch_setup", guidance: GUIDANCE["git.branch_setup"] };
-    if (head === "gh" && second === "pr" && third === "create")
-      return { route: "hosting.pull_request", guidance: GUIDANCE["hosting.pull_request"] };
-    if (head === "glab" && second === "mr" && third === "create")
-      return { route: "hosting.pull_request", guidance: GUIDANCE["hosting.pull_request"] };
+var normalizeClasses = (value) => {
+  if (value === true)
+    return [...AUTO_CLASSES];
+  if (!Array.isArray(value))
+    return [];
+  const seen = new Set;
+  for (const item of value) {
+    if (typeof item === "string" && AUTO_CLASSES.includes(item))
+      seen.add(item);
   }
-  return null;
-}
-function hasLiveWorkitTask(dir) {
+  return [...seen];
+};
+var resolveAutoApproval = (root, dir = configDir()) => {
+  let match;
+  try {
+    match = resolveWorkspaceFrom(root, dir);
+  } catch {
+    return { status: "off" };
+  }
+  if (!match)
+    return { status: "off" };
+  const classes = normalizeClasses(match.autoApprove);
+  if (classes.length === 0)
+    return { status: "off" };
+  return {
+    status: "on",
+    workspace: match.name,
+    classes,
+    account: typeof match.vcs?.account === "string" && match.vcs.account ? match.vcs.account : null,
+    configDigest: digestOf(dir)
+  };
+};
+var autoApproves = (root, cls, dir) => {
+  if (typeof cls !== "string" || !AUTO_CLASSES.includes(cls))
+    return false;
+  const resolved = resolveAutoApproval(root, dir);
+  return resolved.status === "on" && resolved.classes.includes(cls);
+};
+var isStandingReceipt = (value) => typeof value === "object" && value !== null && value.kind === "standing";
+var standingApprovalLive = (root, receipt, cls, dir) => {
+  if (!isStandingReceipt(receipt))
+    return false;
+  if (typeof cls !== "string" || !AUTO_CLASSES.includes(cls))
+    return false;
+  if (receipt.class !== cls)
+    return false;
+  const resolved = resolveAutoApproval(root, dir);
+  if (resolved.status !== "on")
+    return false;
+  if (resolved.workspace !== receipt.workspace)
+    return false;
+  return resolved.classes.includes(cls);
+};
+var standingReceiptFor = (root, workspace, cls, dir) => {
+  const resolved = resolveAutoApproval(root, dir);
+  return {
+    kind: "standing",
+    workspace,
+    class: cls,
+    configDigest: resolved.status === "on" && resolved.workspace === workspace ? resolved.configDigest : null
+  };
+};
+var verifyStandingApproval = (root, task, caller, binding) => {
+  if (task.status !== "active")
+    return failure("invalid_transition", "only active tasks can authorize actions");
+  const session = task.intent?.provenance?.session;
+  if (!session || session.kind !== "host" || session.host !== caller.host || session.handle !== caller.actor)
+    return failure("permission_denied", "standing approval requires the lead session");
+  const standing = binding.standing;
+  if (!standing || typeof standing.workspace !== "string" || typeof standing.class !== "string")
+    return failure("invalid_input", "standing approval needs a workspace and class");
+  let operation;
   try {
-    if (typeof dir !== "string" || dir === "")
-      return false;
-    const listed = new TaskStore(dir).listTasks();
-    if (!listed.ok)
-      return false;
-    return listed.data.some((task) => task.status === "active" || task.status === "paused");
+    operation = typeof binding.approvedContent === "string" ? JSON.parse(binding.approvedContent).operation : null;
   } catch {
-    return false;
+    operation = null;
+  }
+  const cls = operationAutoClass(operation);
+  if (!cls || cls !== standing.class)
+    return failure("permission_denied", "standing approval does not cover this operation");
+  const resolved = resolveAutoApproval(root);
+  if (resolved.status !== "on" || resolved.workspace !== standing.workspace || !resolved.classes.includes(cls))
+    return failure("permission_denied", "standing auto-approval is not live for this operation");
+  if (cls === "push") {
+    const workspace = resolveWorkspaceFrom(root, configDir());
+    const provider = workspace?.vcs?.provider;
+    const account = resolved.account;
+    if (!provider || !account)
+      return failure("permission_denied", "auto-push requires a workspace provider and area account");
+    const identity = verifyPushIdentity(root, provider, account);
+    if (!identity.ok)
+      return failure("permission_denied", identity.error);
   }
-}
-function shouldDenyShellRoute(dir, command) {
-  if (!hasLiveWorkitTask(dir))
-    return null;
-  return shellRouteIntent(command);
-}
-// packages/workit-core/src/core/branch.ts
-import { existsSync as existsSync5, mkdirSync as mkdirSync3, readFileSync as readFileSync6, writeFileSync as writeFileSync3 } from "node:fs";
-import { execFileSync as execFileSync2 } from "node:child_process";
-import path10 from "node:path";
-
-// packages/workit-core/src/core/git.ts
-import { execFileSync } from "node:child_process";
-var run = (cwd, args) => {
+  return success(null, null, {
+    kind: "host_observed",
+    host: caller.host,
+    session: { kind: "host", host: caller.host, handle: caller.actor },
+    workerId: null,
+    receipts: [standingReceiptFor(root, standing.workspace, cls)]
+  });
+};
+var standingAutoApplies = (store, host, actor, operation) => {
+  let descriptor;
   try {
-    const stdout = execFileSync("git", args, {
-      cwd,
-      encoding: "utf8",
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-    return { stdout: stdout.trimEnd(), stderr: "", exitCode: 0 };
-  } catch (error) {
-    const e = error;
-    return {
-      stdout: (e.stdout ?? "").trimEnd(),
-      stderr: (e.stderr ?? "").trimEnd(),
-      exitCode: e.status ?? 1
-    };
+    descriptor = JSON.parse(operation);
+  } catch {
+    return null;
   }
-};
-var gitContext = (workspaceRoot, paths = []) => {
-  const cwd = workspaceRoot;
-  let failure;
-  const runHere = (args) => {
-    const result = run(cwd, args);
-    if (!failure && result.exitCode !== 0) {
-      failure = { stderr: result.stderr, exitCode: result.exitCode };
-    }
-    return result.stdout;
+  const cls = operationAutoClass(descriptor.operation);
+  if (!cls || !autoApproves(store.root, cls))
+    return null;
+  const listed = store.listTasks();
+  const workspace = store.readWorkspace();
+  if (!listed.ok || !workspace.ok || !workspace.data)
+    return null;
+  const matches = listed.data.filter((task) => task.status === "active" && task.workspaceId === workspace.data.id && task.intent?.provenance?.session?.kind === "host" && task.intent.provenance.session.host === host && task.intent.provenance.session.handle === actor);
+  if (matches.length !== 1)
+    return null;
+  const resolved = resolveAutoApproval(store.root);
+  if (resolved.status !== "on")
+    return null;
+  return {
+    task: matches[0],
+    workspaceId: workspace.data.id,
+    workspaceRevision: workspace.data.revision,
+    cls,
+    workspaceName: resolved.workspace
   };
-  const branch = runHere(["rev-parse", "--abbrev-ref", "HEAD"]) || "unknown";
-  const status_short = runHere(["status", "--porcelain"]);
-  const staged = [];
-  const unstaged = [];
-  const untracked = [];
-  for (const line of status_short.split(`
-`).filter(Boolean)) {
-    const code = line.slice(0, 2);
-    const file = line.slice(3);
-    if (code === "??") {
-      untracked.push(file);
-    } else {
-      if (code[0] !== " " && code[0] !== "?")
-        staged.push(file);
-      if (code[1] !== " " && code[1] !== "?")
-        unstaged.push(file);
-    }
+};
+var standingAutoBinding = (core, store, host, actor, operation) => {
+  let descriptor;
+  try {
+    descriptor = JSON.parse(operation);
+  } catch {
+    return null;
   }
-  const pathArgs = paths.length ? ["--", ...paths] : [];
-  const diff_stat = runHere(["diff", "--stat", ...pathArgs]);
-  const cached_stat = runHere(["diff", "--cached", "--stat", ...pathArgs]);
-  const stagedSet = new Set(staged);
-  const unstagedSet = new Set(unstaged);
-  const partial_staged = [...stagedSet].filter((f) => unstagedSet.has(f));
+  const cls = operationAutoClass(descriptor.operation);
+  if (!cls || !autoApproves(store.root, cls))
+    return null;
+  const applies = standingAutoApplies(store, host, actor, operation);
+  if (!applies)
+    return null;
+  const { task } = applies;
+  const resolved = resolveAutoApproval(store.root);
+  if (resolved.status !== "on")
+    return null;
+  const presented = `Workit decision: action — auto-approved ${String(descriptor.operation)} ` + `under workspace rule "${resolved.workspace}" (no question asked).`;
+  const recorded = core.observeStandingDecision({
+    schemaVersion: 1,
+    action: "record",
+    taskId: task.id,
+    expectedRevision: task.revision,
+    purpose: "action",
+    binding: {
+      taskId: task.id,
+      workspaceId: applies.workspaceId,
+      scope: task.intent.data.scope,
+      presented,
+      approvedContent: operation,
+      contentRefs: [],
+      standing: { workspace: resolved.workspace, class: cls }
+    },
+    response: "approved",
+    requirementIds: []
+  });
+  if (!recorded.ok)
+    return null;
+  const fresh = store.readTask(task.id);
+  if (!fresh.ok)
+    return null;
   return {
-    workspace_root: cwd,
-    branch,
-    status_short,
-    staged,
-    unstaged,
-    untracked,
-    diff_stat: [diff_stat, cached_stat].filter(Boolean).join(`
-`),
-    partial_staged: partial_staged.length > 0,
-    partial_staged_files: partial_staged,
-    ...failure ? { stderr: failure.stderr, exitCode: failure.exitCode } : {}
+    taskId: task.id,
+    decisionId: recorded.data.id,
+    binding: recorded.data.data.binding,
+    expectedRevision: fresh.data.revision,
+    expectedWorkspaceRevision: applies.workspaceRevision
   };
 };
 
-// packages/workit-core/src/core/config.ts
-import {
-  copyFileSync,
-  cpSync,
-  existsSync as existsSync4,
-  mkdirSync as mkdirSync2,
-  readFileSync as readFileSync4,
-  readdirSync as readdirSync3,
-  writeFileSync as writeFileSync2
-} from "node:fs";
-import os from "node:os";
-import path7 from "node:path";
-
-// packages/workit-core/src/core/boundary.ts
-var EVENT = {
-  initialization: "initialization",
-  provenance: "provenance",
-  assets: "assets",
-  configurationSource: "configuration_source",
-  hooks: "hooks",
-  mcpConnection: "mcp_connection",
-  migration: "migration",
-  installSteps: "install_steps",
-  uncaughtFailure: "uncaught_failure",
-  toolsFailed: "tools_failed",
-  doctor: "doctor"
+// packages/workit-core/src/core/authority.ts
+var verifiedAuthorities = new WeakMap;
+var trustedAuthority = (kind, provenance, expected, binding, caller) => {
+  const token = {};
+  verifiedAuthorities.set(token, { kind, provenance, ...expected, ...binding, caller });
+  return token;
 };
-var errorDetail = (err) => {
-  if (err instanceof Error) {
-    return { error_name: err.name, error: err.message };
+var chainStepKey = (step) => step.kind === "commit" ? step.message : step.kind === "branch" ? `branch:${step.target}` : "pr";
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var normalizeChainSteps = (steps) => {
+  if (!Array.isArray(steps) || steps.length === 0 || steps.length > 32)
+    return null;
+  const normalized = [];
+  for (const step of steps) {
+    if (typeof step === "string") {
+      if (!step.trim())
+        return null;
+      normalized.push({ kind: "commit", message: step });
+      continue;
+    }
+    if (!isRecord(step))
+      return null;
+    if (typeof step.branch === "string" && step.branch.trim() && Object.keys(step).length === 1) {
+      normalized.push({ kind: "branch", target: step.branch });
+      continue;
+    }
+    if (step.pr === true && Object.keys(step).length === 1) {
+      normalized.push({ kind: "pr" });
+      continue;
+    }
+    return null;
   }
-  return { error_name: "unknown", error: String(err) };
+  const keys = normalized.map(chainStepKey);
+  if (new Set(keys).size !== keys.length)
+    return null;
+  return normalized;
+};
+var scopeEqual = (left, right) => canonicalJson(left) === canonicalJson(right);
+var parseSteps = (content) => {
+  let value;
+  try {
+    value = JSON.parse(content);
+  } catch {
+    return [];
+  }
+  if (typeof value !== "object" || value === null || !("steps" in value))
+    return [];
+  const steps = value.steps;
+  if (!Array.isArray(steps))
+    return null;
+  const normalized = normalizeChainSteps(steps);
+  return normalized;
+};
+var decisionMatches = (entry, purpose, binding) => {
+  const decision = entry.data;
+  return binding.taskId === decision.binding.taskId && binding.workspaceId === decision.binding.workspaceId && decision.purpose === purpose && decision.response === "approved" && decision.revoked === null && (purpose !== "action" || decision.consumption === null) && decision.digest === decisionDigest(decision) && scopeEqual(decision.binding.scope, binding.scope) && canonicalJson(decision.binding) === canonicalJson(binding);
+};
+var sameRef = (left, right) => canonicalJson(left) === canonicalJson(right);
+var validProvenance = (value, caller) => {
+  if (!provenanceSchema.safeParse(value).success)
+    return false;
+  const provenance = value;
+  return provenance.kind === "host_observed" && provenance.host === caller.host && provenance.session?.kind === "host" && provenance.session.host === caller.host && provenance.session.handle === caller.actor && provenance.receipts.some((receipt) => receipt.kind === "host" && receipt.host === caller.host);
+};
+var verifyNativeDecision = (verifier, input, binding) => {
+  if (!verifier)
+    return failure("permission_denied", "native authority verifier is unavailable");
+  const result = verifier.verifyDecision(input);
+  if (!result.ok || !validProvenance(result.data, input.caller))
+    return failure("permission_denied", "native decision observation was not attested");
+  return success(null, null, trustedAuthority("decision", result.data, {
+    taskId: input.expected.taskId,
+    workspaceId: input.expected.workspaceId,
+    purpose: input.expected.purpose,
+    response: input.expected.response,
+    binding: input.expected.binding,
+    bindingBytes: input.expected.bindingBytes,
+    digest: input.expected.digest,
+    requirementIds: [...input.expected.requirementIds]
+  }, binding, input.caller));
+};
+var verifyNativeAction = (verifier, input, binding) => {
+  if (!verifier)
+    return failure("permission_denied", "native authority verifier is unavailable");
+  const result = verifier.verifyAction(input);
+  if (!result.ok || !validProvenance(result.data, input.caller))
+    return failure("permission_denied", "native action observation was not attested");
+  return success(null, null, trustedAuthority("action", result.data, {
+    taskId: input.expected.taskId,
+    workspaceId: input.expected.workspaceId,
+    decisionId: input.expected.decisionId,
+    actionRef: input.expected.actionRef,
+    taskRevision: input.expected.taskRevision,
+    workspaceRevision: input.expected.workspaceRevision,
+    outcome: input.expected.outcome,
+    purpose: input.expected.decision.purpose,
+    response: input.expected.decision.response,
+    binding: input.expected.decision.binding,
+    digest: input.expected.decision.digest,
+    requirementIds: [...input.expected.decision.requirementIds]
+  }, binding, input.caller));
+};
+var verifyNativeReconciliation = (verifier, input, binding) => {
+  if (!verifier?.verifyReconciliation)
+    return failure("permission_denied", "native reconciliation authority is unavailable");
+  const result = verifier.verifyReconciliation(input);
+  if (!result.ok || !validProvenance(result.data, input.caller))
+    return failure("permission_denied", "native reconciliation observation was not attested");
+  return success(null, null, trustedAuthority("reconciliation", result.data, {
+    taskId: input.expected.taskId,
+    workspaceId: input.expected.workspaceId,
+    decisionId: input.expected.decisionId,
+    actionRef: input.expected.actionRef,
+    taskRevision: input.expected.taskRevision,
+    workspaceRevision: input.expected.workspaceRevision,
+    outcome: input.expected.outcome,
+    evidenceDigest: input.expected.evidenceDigest,
+    step: input.expected.step,
+    purpose: input.expected.decision.purpose,
+    response: input.expected.decision.response,
+    binding: input.expected.decision.binding,
+    digest: input.expected.decision.digest,
+    requirementIds: [...input.expected.decision.requirementIds]
+  }, binding, input.caller));
 };
-
-// packages/workit-core/src/core/config.ts
-var diagnosticLogger;
-var PRESETS = {
-  gitflow: {
-    allowed: ["feature/*", "bugfix/*", "hotfix/*", "release/*"],
-    protected: ["main", "develop", "master", "prod", "production"]
-  },
-  "github-flow": { allowed: ["*"], protected: ["main"] },
-  "trunk-based": { allowed: ["*"], protected: ["main"] },
-  custom: { allowed: [], protected: [] }
+var takeAuthority = (authority, binding, caller) => {
+  const record = verifiedAuthorities.get(authority);
+  verifiedAuthorities.delete(authority);
+  if (!record)
+    return null;
+  if (record.owner !== binding.owner || record.store !== binding.store || record.root !== binding.root || record.root !== record.store.root || canonicalJson(record.caller) !== canonicalJson(caller))
+    return null;
+  return record;
 };
-var mergePreset = (preset, input = {}, current = {
-  branchPolicy: { preset, allowed: [], protected: [] }
-}) => {
-  const defs = PRESETS[preset];
-  return {
-    preset,
-    allowed: preset === "custom" ? input.allowed ?? current.branchPolicy.allowed : [...defs.allowed],
-    protected: preset === "custom" ? input.protectedNames ?? current.branchPolicy.protected : [...defs.protected]
-  };
+var retireNativeAuthority = (authority) => {
+  const record = verifiedAuthorities.get(authority);
+  verifiedAuthorities.delete(authority);
+  return record?.provenance ?? null;
 };
-var resolveConfigDir = () => process.env.WORKFLOW_TOOLKIT_CONFIG ?? process.env.WORKFLOW_TOOLKIT_CONFIG_DIR ?? path7.join(process.env.XDG_CONFIG_HOME || path7.join(os.homedir(), ".config"), "workit");
-var migratedDir = null;
-var migrationFailed = false;
-var ensureConfigDir = (dir = resolveConfigDir()) => {
-  if (migratedDir === dir)
-    return dir;
-  if (process.env.WORKFLOW_TOOLKIT_CONFIG || process.env.WORKFLOW_TOOLKIT_CONFIG_DIR) {
-    migratedDir = dir;
-    return dir;
-  }
-  const legacy = path7.join(process.env.XDG_CONFIG_HOME || path7.join(os.homedir(), ".config"), "workflow-toolkit");
-  if (!existsSync4(legacy)) {
-    migratedDir = dir;
-    return dir;
-  }
-  if (!migrationFailed && existsSync4(dir)) {
-    migratedDir = dir;
-    return dir;
+var authorityMatches = (authority, expected) => authority.kind === "action" && authority.taskId === expected.taskId && authority.workspaceId === expected.workspaceId && authority.decisionId === expected.decisionId && sameRef(authority.actionRef, expected.actionRef) && authority.taskRevision === expected.taskRevision && authority.workspaceRevision === expected.workspaceRevision && authority.outcome === expected.outcome;
+var authorityDecisionMatches = (authority, decision) => authority.purpose === decision.purpose && authority.response === decision.response && authority.digest === decision.digest && canonicalJson(authority.binding) === canonicalJson(decision.binding) && canonicalJson(authority.requirementIds) === canonicalJson(decision.requirementIds);
+var provenanceMatches = (left, right) => left.kind === "host_observed" && right.kind === "host_observed" && left.host === right.host && canonicalJson(left.session) === canonicalJson(right.session);
+function applicableDecision(task, purpose, binding, checkoutRoot) {
+  if (binding.taskId !== task.id || binding.workspaceId !== task.workspaceId)
+    return [];
+  return task.decisions.filter((entry) => entry.provenance.kind !== "imported" && decisionMatches(entry, purpose, binding) && (checkoutRoot ? verifyDecisionContentAtRoot(checkoutRoot, entry.data.binding).ok : entry.data.binding.contentRefs.every((reference) => reference.kind !== "file"))).map((entry) => entry.data);
+}
+var digestBytes2 = (bytes) => createHash4("sha256").update(bytes).digest("hex");
+var verifyDecisionContentAtRoot = (checkoutRoot, binding) => {
+  let root;
+  try {
+    root = fs6.realpathSync(checkoutRoot);
+  } catch {
+    return failure("permission_denied", "checkout root is unavailable");
   }
-  migrationFailed = false;
-  mkdirSync2(dir, { recursive: true });
-  diagnosticLogger?.info(EVENT.migration, { from: legacy, to: dir });
-  for (const entry of readdirSync3(legacy, { withFileTypes: true })) {
-    const src = path7.join(legacy, entry.name);
-    const dest = path7.join(dir, entry.name);
-    if (existsSync4(dest))
+  for (const reference of binding.contentRefs) {
+    if (reference.kind !== "file")
       continue;
+    if (!reference.digest)
+      return failure("invalid_input", "document references require a byte digest");
+    const target = path9.resolve(root, reference.path);
+    if (target !== root && !target.startsWith(`${root}${path9.sep}`))
+      return failure("invalid_input", "document reference escapes checkout; cite it as an external file:// reference instead", {
+        fields: [
+          { path: "contentRefs.path", reason: `${reference.path} is outside the checkout` }
+        ]
+      });
     try {
-      if (entry.isDirectory())
-        cpSync(src, dest, { recursive: true });
-      else if (entry.isFile())
-        copyFileSync(src, dest);
-    } catch (err) {
-      migrationFailed = true;
-      diagnosticLogger?.warn(EVENT.migration, { from: src, ok: false, ...errorDetail(err) });
-      console.warn(`[workit] config migration: a file could not be copied to ${dir}; it will be retried on the next run`);
+      const relative = path9.relative(root, target);
+      let current = root;
+      for (const segment of relative.split(path9.sep)) {
+        if (!segment)
+          continue;
+        current = path9.join(current, segment);
+        const stat = fs6.lstatSync(current);
+        const real = fs6.realpathSync(current);
+        if (real !== root && !real.startsWith(`${root}${path9.sep}`))
+          return failure("invalid_input", "document reference escapes checkout; cite it as an external file:// reference instead", {
+            fields: [
+              {
+                path: "contentRefs.path",
+                reason: `${reference.path} resolves outside the checkout`
+              }
+            ]
+          });
+        if (stat.isSymbolicLink())
+          return failure("invalid_input", "document reference uses a symlink");
+        if (current === target && !stat.isFile())
+          return failure("invalid_input", "document reference is not a regular file");
+        if (current !== target && !stat.isDirectory())
+          return failure("invalid_input", "document reference ancestor is not a directory");
+      }
+      if (digestBytes2(fs6.readFileSync(target)) !== reference.digest)
+        return failure("permission_denied", "approved document bytes have changed");
+    } catch {
+      return failure("invalid_input", "approved document is unavailable");
+    }
+  }
+  return success(null, null, null);
+};
+var verifyContentRefs = (store, binding) => verifyDecisionContentAtRoot(store.root, binding);
+var storedDecisionApplicable = (store, task, purpose, binding) => task.decisions.filter((entry) => entry.provenance.kind !== "imported" && decisionMatches(entry, purpose, binding) && verifyDecisionContentAtRoot(store.root, entry.data.binding).ok);
+var validateAction = (store, task, workspaceId, input, authority) => {
+  if (task.status !== "active")
+    return failure("invalid_transition", "only active tasks can authorize actions");
+  if (!refSchema.safeParse(input.actionRef).success)
+    return failure("invalid_input", "action reference is invalid");
+  const entry = task.decisions.find((candidate) => candidate.id === input.decisionId);
+  if (!entry)
+    return failure("not_found", "decision not found");
+  const decision = entry.data;
+  if (decision.purpose !== "action")
+    return failure("permission_denied", "decision is not an action approval");
+  if (!authorityMatches(authority, {
+    taskId: task.id,
+    workspaceId,
+    decisionId: input.decisionId,
+    actionRef: input.actionRef,
+    taskRevision: input.expectedRevision,
+    workspaceRevision: input.expectedWorkspaceRevision,
+    outcome: "reserve"
+  }))
+    return failure("permission_denied", "native reservation authority is not bound");
+  if (!authorityDecisionMatches(authority, decision))
+    return failure("permission_denied", "native reservation authority does not match decision");
+  if (decision.response !== "approved")
+    return failure("permission_denied", "decision was rejected");
+  if (entry.provenance.kind !== "host_observed" || entry.provenance.receipts.length === 0 || !provenanceMatches(entry.provenance, authority.provenance))
+    return failure("permission_denied", "action approval lacks native receipt assurance");
+  const receipts = entry.provenance.receipts;
+  const standing = receipts.filter((receipt) => typeof receipt === "object" && receipt !== null && receipt.kind === "standing");
+  const questionBacked = receipts.some((receipt) => typeof receipt === "object" && receipt !== null && receipt.kind === "host");
+  if (!questionBacked && standing.length > 0) {
+    let operation;
+    try {
+      operation = JSON.parse(decision.binding.approvedContent).operation;
+    } catch {
+      operation = null;
+    }
+    const cls = operationAutoClass(operation);
+    if (!cls || !standing.some((receipt) => standingApprovalLive(store.root, receipt, cls)))
+      return failure("permission_denied", "standing auto-approval is not live for this operation");
+  }
+  if (decision.revoked)
+    return failure("permission_denied", "decision is revoked");
+  if (decision.digest !== decisionDigest(decision))
+    return failure("permission_denied", "decision binding is invalid");
+  if (decision.binding.taskId !== task.id || decision.binding.workspaceId !== workspaceId)
+    return failure("permission_denied", "decision task or workspace binding is invalid");
+  if (input.binding && canonicalJson(input.binding) !== canonicalJson(decision.binding))
+    return failure("permission_denied", "action binding does not match the approved decision");
+  const content = verifyContentRefs(store, decision.binding);
+  if (!content.ok)
+    return content;
+  const requestedSteps = parseSteps(decision.binding.approvedContent);
+  if (requestedSteps === null)
+    return failure("invalid_input", "bounded action steps must be a unique non-empty array");
+  if (input.steps && canonicalJson(input.steps) !== canonicalJson(requestedSteps.map(chainStepKey)))
+    return failure("permission_denied", "bounded action steps do not match approved content");
+  const stored = task.actionProgress?.find((item) => item.decisionId === input.decisionId);
+  const workflow = stored ? { steps: stored.steps, completed: stored.completedSteps } : { steps: requestedSteps.map(chainStepKey), completed: [] };
+  if (workflow.steps.length && requestedSteps.length && canonicalJson(workflow.steps) !== canonicalJson(requestedSteps.map(chainStepKey)))
+    return failure("permission_denied", "bounded action scope changed");
+  return success(null, null, { entry, workflow });
+};
+function reserveAction(input) {
+  if (!input.store || !input.expectedRevision || !input.expectedWorkspaceRevision)
+    return failure("invalid_input", "action reservation preconditions are required");
+  const authority = takeAuthority(input.authority, {
+    owner: input.authorityOwner,
+    store: input.store,
+    root: input.store.root
+  }, input.authorityCaller);
+  if (!authority)
+    return failure("permission_denied", "native reservation authority is not verified");
+  const changed = input.store.mutateTask(input.taskId, input.expectedRevision, (current, mutation) => {
+    const workspace = input.store.readWorkspace();
+    if (!workspace.ok)
+      return workspace;
+    if (!workspace.data)
+      return failure("not_found", "workspace not found");
+    if (workspace.data.revision !== input.expectedWorkspaceRevision)
+      return failure("revision_conflict", "workspace revision does not match", {
+        expectedWorkspaceRevision: input.expectedWorkspaceRevision,
+        actualWorkspaceRevision: workspace.data.revision
+      });
+    const valid = validateAction(input.store, current, workspace.data.id, input, authority);
+    if (!valid.ok)
+      return valid;
+    const { entry, workflow } = valid.data;
+    const existing = entry.data.consumption;
+    if (existing?.state === "uncertain")
+      return failure("external_outcome_unknown", "previous action outcome is unknown", {
+        operation: "reserve_action",
+        outcome: "unknown"
+      });
+    if (existing?.state === "consumed")
+      return failure("permission_denied", "action approval is consumed");
+    if (existing?.state === "reserved" && workflow.completed.length === 0)
+      return failure("permission_denied", "action approval is already reserved");
+    const requestedStep = input.step ?? workflow.steps[workflow.completed.length];
+    if (workflow.steps.length && (!requestedStep || requestedStep !== workflow.steps[workflow.completed.length]))
+      return failure("permission_denied", "action step is outside the approved remaining workflow");
+    if (requestedStep && workflow.completed.includes(requestedStep))
+      return failure("permission_denied", "action step was already completed");
+    const nextDecision = {
+      ...entry.data,
+      consumption: { state: "reserved", at: mutation.now, actionRef: input.actionRef }
+    };
+    const actionProgress = workflow.steps.length ? [
+      ...(current.actionProgress ?? []).filter((progress) => progress.decisionId !== input.decisionId),
+      {
+        decisionId: input.decisionId,
+        steps: [...workflow.steps],
+        completedSteps: [...workflow.completed]
+      }
+    ] : current.actionProgress ?? [];
+    return success(mutation.revision, null, {
+      ...current,
+      actionProgress,
+      decisions: current.decisions.map((candidate) => candidate.id === input.decisionId ? { ...candidate, data: nextDecision } : candidate)
+    });
+  }, input.native?.now);
+  if (!changed.ok)
+    return changed;
+  const workspace = input.store.readWorkspace();
+  if (!workspace.ok || !workspace.data)
+    return failure("recovery_required", "workspace disappeared after reservation");
+  const entry = changed.data.decisions.find((candidate) => candidate.id === input.decisionId);
+  if (!entry)
+    return failure("recovery_required", "reserved decision disappeared");
+  const workflow = changed.data.actionProgress?.find((progress) => progress.decisionId === input.decisionId) ?? {
+    steps: [],
+    completedSteps: []
+  };
+  return success(changed.data.revision, workspace.data.revision, {
+    taskId: input.taskId,
+    decisionId: input.decisionId,
+    actionRef: input.actionRef,
+    taskRevision: changed.data.revision,
+    workspaceRevision: workspace.data.revision,
+    completedSteps: [...workflow.completedSteps],
+    remainingSteps: workflow.steps.slice(workflow.completedSteps.length)
+  });
+}
+function settleAction(input) {
+  if (!input.store || !input.taskRevision || !input.workspaceRevision)
+    return failure("invalid_input", "action settlement preconditions are required");
+  const authority = takeAuthority(input.authority, {
+    owner: input.authorityOwner,
+    store: input.store,
+    root: input.store.root
+  }, input.authorityCaller);
+  if (!authority)
+    return failure("permission_denied", "native settlement authority is not verified");
+  if (!refSchema.safeParse(input.actionRef).success)
+    return failure("invalid_input", "action reference is invalid");
+  if (!authorityMatches(authority, {
+    taskId: input.taskId,
+    workspaceId: authority.workspaceId,
+    decisionId: input.decisionId,
+    actionRef: input.actionRef,
+    taskRevision: input.taskRevision,
+    workspaceRevision: input.workspaceRevision,
+    outcome: input.outcome
+  }))
+    return failure("permission_denied", "native settlement authority is not verified");
+  let outcomeResult = null;
+  const changed = input.store.mutateTask(input.taskId, input.taskRevision, (current, mutation) => {
+    const workspace = input.store.readWorkspace();
+    if (!workspace.ok)
+      return workspace;
+    if (!workspace.data)
+      return failure("not_found", "workspace not found");
+    if (!authorityMatches(authority, {
+      taskId: input.taskId,
+      workspaceId: workspace.data.id,
+      decisionId: input.decisionId,
+      actionRef: input.actionRef,
+      taskRevision: input.taskRevision,
+      workspaceRevision: input.workspaceRevision,
+      outcome: input.outcome
+    }))
+      return failure("permission_denied", "native settlement authority does not match context");
+    if (workspace.data.revision !== input.workspaceRevision)
+      return failure("revision_conflict", "workspace revision does not match", {
+        expectedWorkspaceRevision: input.workspaceRevision,
+        actualWorkspaceRevision: workspace.data.revision
+      });
+    const entry = current.decisions.find((candidate) => candidate.id === input.decisionId);
+    if (!entry)
+      return failure("not_found", "decision not found");
+    if (!authorityDecisionMatches(authority, entry.data))
+      return failure("permission_denied", "native settlement authority does not match decision");
+    if (!provenanceMatches(entry.provenance, authority.provenance))
+      return failure("permission_denied", "native settlement caller does not match approval");
+    if (entry.data.purpose !== "action" || entry.data.digest !== decisionDigest(entry.data))
+      return failure("permission_denied", "decision binding is invalid");
+    if (entry.data.consumption?.state === "uncertain")
+      return failure("external_outcome_unknown", "previous action outcome is unknown", {
+        operation: "settle_action",
+        outcome: "unknown"
+      });
+    if (entry.data.consumption?.state !== "reserved")
+      return failure("permission_denied", "action is not reserved");
+    if (canonicalJson(entry.data.consumption.actionRef) !== canonicalJson(input.actionRef))
+      return failure("permission_denied", "settlement reference does not match reservation");
+    const stored = current.actionProgress?.find((progress) => progress.decisionId === input.decisionId);
+    const workflow = stored ? { steps: stored.steps, completed: stored.completedSteps } : { steps: [], completed: [] };
+    if (entry.data.binding.approvedContent && !stored && (parseSteps(entry.data.binding.approvedContent) ?? []).length)
+      return failure("recovery_required", "bounded action progress is missing");
+    const currentStep = input.step ?? workflow.steps[workflow.completed.length];
+    if (workflow.steps.length && (!currentStep || currentStep !== workflow.steps[workflow.completed.length]))
+      return failure("permission_denied", "settlement step is outside the approved workflow");
+    if (input.outcome === "unknown") {
+      outcomeResult = failure("external_outcome_unknown", "external action outcome is unknown", {
+        operation: "settle_action",
+        outcome: "unknown"
+      });
+      const uncertain = {
+        ...entry.data,
+        consumption: { ...entry.data.consumption, state: "uncertain", at: mutation.now }
+      };
+      return success(mutation.revision, null, {
+        ...current,
+        decisions: current.decisions.map((candidate) => candidate.id === input.decisionId ? { ...candidate, data: uncertain } : candidate)
+      });
     }
-  }
-  if (!migrationFailed)
-    migratedDir = dir;
-  return dir;
-};
-var configDir = () => ensureConfigDir();
-var LOCALE_RE = /^[a-z]{2,3}(-(?:[A-Z]{2}|[0-9]{3}))?$/;
-var DEFAULTS = {
-  locale: "en",
-  localeOptions: ["en", "es-CL", "es-MX", "es-AR", "pt-BR"],
-  timezone: "America/Santiago",
-  branchPolicy: {
-    preset: "gitflow",
-    allowed: [...PRESETS.gitflow.allowed],
-    protected: [...PRESETS.gitflow.protected]
-  },
-  commitPolicy: { preset: "conventional" }
-};
-var readSafe = (p) => {
-  try {
-    return readFileSync4(p, "utf8");
-  } catch {
-    return null;
-  }
-};
-var isConfigObject = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
-var parseConfigResult = (raw, file) => {
-  if (raw === null)
-    return { status: "missing", path: file };
-  let parsed;
-  try {
-    parsed = JSON.parse(raw);
-  } catch {
-    return { status: "malformed", path: file, error: `${file} is not valid JSON` };
-  }
-  if (!isConfigObject(parsed)) {
-    return { status: "malformed", path: file, error: `${file} is not a JSON object` };
-  }
-  const input = parsed;
-  const locale = LOCALE_RE.test(String(input.locale ?? "")) ? input.locale : DEFAULTS.locale;
-  const preset = Object.hasOwn(PRESETS, input.branchPolicy?.preset) ? input.branchPolicy?.preset : "gitflow";
-  const commitPreset = COMMIT_PRESETS.includes(String(input.commitPolicy?.preset ?? "")) ? input.commitPolicy?.preset : "conventional";
-  return {
-    status: "valid",
-    path: file,
-    config: {
-      locale,
-      localeOptions: Array.isArray(input.localeOptions) ? input.localeOptions : DEFAULTS.localeOptions,
-      timezone: input.timezone ?? DEFAULTS.timezone,
-      branchPolicy: mergePreset(preset, {
-        allowed: Array.isArray(input.branchPolicy?.allowed) ? input.branchPolicy.allowed : undefined,
-        protectedNames: Array.isArray(input.branchPolicy?.protected) ? input.branchPolicy.protected : undefined
-      }, DEFAULTS),
-      commitPolicy: {
-        preset: commitPreset,
-        ...typeof input.commitPolicy?.pattern === "string" ? { pattern: input.commitPolicy.pattern } : {}
+    if (input.outcome === "not_started") {
+      const released = { ...entry.data, consumption: null };
+      return success(mutation.revision, null, {
+        ...current,
+        decisions: current.decisions.map((candidate) => candidate.id === input.decisionId ? { ...candidate, data: released } : candidate)
+      });
+    }
+    if (currentStep)
+      workflow.completed.push(currentStep);
+    const complete = !workflow.steps.length || workflow.completed.length >= workflow.steps.length;
+    const settled = {
+      ...entry.data,
+      consumption: complete ? { ...entry.data.consumption, state: "consumed", at: mutation.now } : null
+    };
+    const actionProgress = workflow.steps.length ? [
+      ...(current.actionProgress ?? []).filter((progress) => progress.decisionId !== input.decisionId),
+      {
+        decisionId: input.decisionId,
+        steps: [...workflow.steps],
+        completedSteps: [...workflow.completed]
       }
+    ] : current.actionProgress ?? [];
+    const next = {
+      ...current,
+      actionProgress,
+      decisions: current.decisions.map((candidate) => candidate.id === input.decisionId ? { ...candidate, data: settled } : candidate)
+    };
+    if (!complete) {
+      outcomeResult = success(mutation.revision, input.workspaceRevision, {
+        ...entry,
+        data: settled
+      });
     }
-  };
-};
-var readConfigTyped = (dir) => {
-  const file = path7.join(dir ?? configDir(), "config.json");
-  return parseConfigResult(readSafe(file), file);
-};
-var readConfig = () => {
-  const result = readConfigTyped();
-  if (result.status === "malformed")
-    throw new Error(result.error);
-  return result.config ?? DEFAULTS;
+    return success(mutation.revision, null, next);
+  }, input.native?.now);
+  if (!changed.ok)
+    return changed;
+  const entry = changed.data.decisions.find((candidate) => candidate.id === input.decisionId);
+  if (!entry)
+    return failure("recovery_required", "settled decision disappeared");
+  if (outcomeResult)
+    return outcomeResult;
+  return success(changed.data.revision, input.workspaceRevision, entry);
+}
+function reconcileAction(input) {
+  if (!input.store || !input.taskRevision || !input.workspaceRevision || !input.evidenceDigest)
+    return failure("invalid_input", "action reconciliation preconditions are required");
+  const authority = takeAuthority(input.authority, { owner: input.authorityOwner, store: input.store, root: input.store.root }, input.authorityCaller);
+  if (!authority || authority.kind !== "reconciliation")
+    return failure("permission_denied", "native reconciliation authority is not verified");
+  if (authority.taskId !== input.taskId || authority.decisionId !== input.decisionId || !sameRef(authority.actionRef, input.actionRef) || authority.taskRevision !== input.taskRevision || authority.workspaceRevision !== input.workspaceRevision || authority.outcome !== input.outcome || authority.evidenceDigest !== input.evidenceDigest || authority.step !== input.step)
+    return failure("permission_denied", "native reconciliation authority is not bound");
+  const changed = input.store.mutateTask(input.taskId, input.taskRevision, (current, mutation) => {
+    const workspace = input.store.readWorkspace();
+    if (!workspace.ok)
+      return workspace;
+    if (!workspace.data)
+      return failure("not_found", "workspace not found");
+    if (authority.workspaceId !== workspace.data.id)
+      return failure("permission_denied", "native reconciliation workspace does not match");
+    if (workspace.data.revision !== input.workspaceRevision)
+      return failure("revision_conflict", "workspace revision does not match");
+    const entry = current.decisions.find((candidate) => candidate.id === input.decisionId);
+    if (!entry || entry.data.purpose !== "action")
+      return failure("not_found", "decision not found");
+    if (!authorityDecisionMatches(authority, entry.data) || !provenanceMatches(entry.provenance, authority.provenance))
+      return failure("permission_denied", "native reconciliation caller does not match approval");
+    if (entry.data.response !== "approved" || entry.data.revoked !== null || entry.data.digest !== decisionDigest(entry.data) || entry.data.binding.taskId !== current.id || entry.data.binding.workspaceId !== current.workspaceId || entry.data.binding.workspaceId !== workspace.data.id)
+      return failure("permission_denied", "reconciliation decision binding is invalid");
+    if (entry.data.consumption?.state !== "uncertain")
+      return failure("external_outcome_unknown", "only an uncertain action can be reconciled");
+    if (!sameRef(entry.data.consumption.actionRef, input.actionRef))
+      return failure("permission_denied", "reconciliation reference does not match reservation");
+    const stored = current.actionProgress?.find((progress) => progress.decisionId === input.decisionId);
+    const workflow = stored ? { steps: [...stored.steps], completed: [...stored.completedSteps] } : { steps: [], completed: [] };
+    const currentStep = input.step ?? workflow.steps[workflow.completed.length];
+    if (workflow.steps.length && (!currentStep || currentStep !== workflow.steps[workflow.completed.length]))
+      return failure("permission_denied", "reconciliation step is outside the approved workflow");
+    if (input.outcome === "not_started") {
+      return success(mutation.revision, null, {
+        ...current,
+        decisions: current.decisions.map((candidate) => candidate.id === input.decisionId ? { ...candidate, data: { ...candidate.data, consumption: null } } : candidate)
+      });
+    }
+    if (currentStep)
+      workflow.completed.push(currentStep);
+    const complete = !workflow.steps.length || workflow.completed.length >= workflow.steps.length;
+    const nextDecision = {
+      ...entry.data,
+      consumption: complete ? { ...entry.data.consumption, state: "consumed", at: mutation.now } : null
+    };
+    const actionProgress = workflow.steps.length ? [
+      ...(current.actionProgress ?? []).filter((progress) => progress.decisionId !== input.decisionId),
+      {
+        decisionId: input.decisionId,
+        steps: workflow.steps,
+        completedSteps: workflow.completed
+      }
+    ] : current.actionProgress ?? [];
+    return success(mutation.revision, null, {
+      ...current,
+      actionProgress,
+      decisions: current.decisions.map((candidate) => candidate.id === input.decisionId ? { ...candidate, data: nextDecision } : candidate)
+    });
+  }, input.native?.now);
+  if (!changed.ok)
+    return changed;
+  const entry = changed.data.decisions.find((candidate) => candidate.id === input.decisionId);
+  return entry ? success(changed.data.revision, input.workspaceRevision, entry) : failure("recovery_required", "reconciled decision disappeared");
+}
+var bindingCovers = scopeCovers;
+var verifyDecisionContent = verifyContentRefs;
+
+// packages/workit-core/src/core/task-evaluation.ts
+var digestBytes3 = (value) => createHash5("sha256").update(value).digest("hex");
+var inside = (root, candidate) => candidate === root || candidate.startsWith(`${root}${path10.sep}`);
+var relative = (root, candidate) => path10.relative(root, candidate).split(path10.sep).join("/") || ".";
+var canonicalPath = (value) => {
+  if (typeof value !== "string" || !value)
+    return null;
+  if (value.includes("\\") || value.split("/").includes(".."))
+    return null;
+  const normalized = path10.posix.normalize(value);
+  if (normalized === ".." || normalized.startsWith("../") || normalized.startsWith("/"))
+    return null;
+  return normalized === "." ? "." : normalized.replace(/\/$/, "");
 };
-var resolveBranchPolicy = (config, workspace) => {
-  const wp = workspace?.branchPolicy ?? {};
-  const preset = Object.hasOwn(PRESETS, wp.preset) ? wp.preset : config.branchPolicy?.preset ?? "gitflow";
-  const merged = mergePreset(preset, {
-    allowed: wp.allowed,
-    protectedNames: wp.protected
-  }, config);
-  const allowed = merged.allowed.map((p) => new RegExp(`^${p.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*")}$`, "i"));
+var canonicalScope = (scope) => {
+  const paths = scope.paths.length ? scope.paths : ["."];
+  const normalizedPaths = paths.map(canonicalPath);
+  const normalizedExclusions = scope.exclusions.map(canonicalPath);
+  if (normalizedPaths.some((value) => value === null) || normalizedExclusions.some((value) => value === null))
+    return null;
   return {
-    preset,
-    allowed,
-    protected: new Set(merged.protected.map((p) => p.toLowerCase())),
-    integration: wp.integration === "merge" ? "merge" : "pr",
-    defaultTargetBranch: preset === "github-flow" ? "main" : preset === "trunk-based" ? "master" : "develop"
+    description: scope.description,
+    paths: [...new Set(normalizedPaths)],
+    exclusions: [...new Set(normalizedExclusions)]
   };
 };
-var COMMIT_PRESETS = [
-  "conventional",
-  "gitmoji",
-  "ticket-prefix",
-  "freeform",
-  "custom",
-  "auto"
-];
-var resolveCommitPolicy = (config, workspace) => {
-  const wp = workspace?.commitPolicy ?? {};
-  if (COMMIT_PRESETS.includes(String(wp.preset ?? ""))) {
+var excluded = (value, exclusions) => exclusions.some((item) => item === value || item !== "." && value.startsWith(`${item}/`));
+var scopeMatches = (value, scope) => {
+  const normalized = canonicalScope(scope);
+  if (!normalized)
+    return false;
+  const paths = normalized.paths;
+  return paths.some((item) => item === "." || value === item || value.startsWith(`${item}/`)) && !excluded(value, normalized.exclusions);
+};
+var pathRelevant = (value, scope) => scopeMatches(value, scope);
+var compareCodeUnits2 = (left, right) => {
+  const length = Math.min(left.length, right.length);
+  for (let index = 0;index < length; index += 1) {
+    const difference = left.charCodeAt(index) - right.charCodeAt(index);
+    if (difference !== 0)
+      return difference;
+  }
+  return left.length - right.length;
+};
+var gitPaths = (root) => {
+  const result = spawnSync2("git", ["ls-files", "-z", "--cached", "--others", "--exclude-standard"], {
+    cwd: root,
+    encoding: "buffer"
+  });
+  if (result.status !== 0) {
+    const stderr = result.stderr?.toString("utf8") ?? "";
     return {
-      preset: wp.preset,
-      ...typeof wp.pattern === "string" ? { pattern: wp.pattern } : {}
+      paths: [],
+      uncertain: !/not a git repository/i.test(stderr),
+      git: /not a git repository/i.test(stderr) ? false : true
     };
   }
-  return config.commitPolicy ?? { preset: "conventional" };
-};
-
-// packages/workit-core/src/core/workspaces.ts
-import { readFileSync as readFileSync5, realpathSync as realpathSync4 } from "node:fs";
-import path8 from "node:path";
-var readWorkspacesResult = (dir = configDir()) => {
-  const file = path8.join(dir, "workspaces.json");
-  let raw;
-  try {
-    raw = readFileSync5(file, "utf8");
-  } catch {
-    return { status: "missing", path: file, entries: [] };
+  const paths = result.stdout ? result.stdout.toString("utf8").split("\x00").filter(Boolean).map((item) => item.split(path10.sep).join("/")) : [];
+  const stagedDeleted = spawnSync2("git", ["diff", "--cached", "--name-only", "--diff-filter=D", "-z"], { cwd: root, encoding: "buffer" });
+  if (stagedDeleted.status !== 0) {
+    const stderr = stagedDeleted.stderr?.toString("utf8") ?? "";
+    if (!/not a git repository/i.test(stderr))
+      return { paths, uncertain: true, git: true };
+  } else if (stagedDeleted.stdout) {
+    paths.push(...stagedDeleted.stdout.toString("utf8").split("\x00").filter(Boolean).map((item) => item.split(path10.sep).join("/")));
   }
-  let parsed;
+  return { paths: [...new Set(paths)], uncertain: false, git: true };
+};
+var walk = (root, directory, output) => {
+  let names;
   try {
-    parsed = JSON.parse(raw);
+    names = fs7.readdirSync(directory);
   } catch {
-    return { status: "malformed", path: file, entries: [], error: `${file} is not valid JSON` };
+    return true;
   }
-  if (!isConfigObject(parsed)) {
-    return { status: "malformed", path: file, entries: [], error: `${file} is not a JSON object` };
+  let uncertain = false;
+  for (const name of names) {
+    if (name === ".git" || name === ".workit")
+      continue;
+    const target = path10.join(directory, name);
+    let stat;
+    try {
+      stat = fs7.lstatSync(target);
+    } catch {
+      uncertain = true;
+      continue;
+    }
+    const item = relative(root, target);
+    output.add(item);
+    if (stat.isDirectory() && !stat.isSymbolicLink())
+      uncertain = walk(root, target, output) || uncertain;
   }
-  const list = parsed.workspaces;
-  return {
-    status: "valid",
-    path: file,
-    entries: Array.isArray(list) ? list : []
-  };
+  return uncertain;
 };
-var loadWorkspacesFrom = (dir) => readWorkspacesResult(dir).entries;
-var globToRegExp = (glob) => {
-  let out = "";
-  for (let i = 0;i < glob.length; i++) {
-    const c = glob[i];
-    if (c === "*") {
-      if (glob[i + 1] === "*") {
-        if (glob[i + 2] === "/") {
-          if (out === "")
-            out += "/?";
-          out += "(?:[^/]+/)*";
-          i += 2;
-        } else {
-          if (i + 2 >= glob.length) {
-            if (out.endsWith("/")) {
-              out = out.slice(0, -1);
-              out += "(?:/.*)?";
-            } else {
-              out += ".*";
-            }
-          } else {
-            out += ".*";
-          }
-          i++;
-        }
-      } else {
-        out += "[^/]*";
-      }
-    } else {
-      out += c.replace(/[.+?^${}()|[\]\\]/g, "\\$&");
+var scopeRoots = (root, scope) => {
+  const roots = [];
+  for (const item of scope.paths.length ? scope.paths : ["."]) {
+    const target = path10.resolve(root, item);
+    if (!inside(root, target))
+      return failure("invalid_input", `candidate scope escapes checkout: ${item} — keep one task per repository and coordinate a separate linked task in the other checkout`, { fields: [{ path: "scope.paths", reason: `${item} is outside the checkout` }] });
+    let ancestor = target;
+    while (!fs7.existsSync(ancestor) && ancestor !== root)
+      ancestor = path10.dirname(ancestor);
+    try {
+      if (!inside(root, fs7.realpathSync(ancestor)))
+        return failure("invalid_input", `candidate scope escapes checkout through a symlink: ${item} — keep one task per repository and coordinate a separate linked task in the other checkout`, { fields: [{ path: "scope.paths", reason: `${item} resolves outside the checkout` }] });
+    } catch {
+      return failure("invalid_input", `candidate scope cannot be inspected: ${item}`);
     }
+    roots.push(target);
   }
-  return new RegExp(`^${out}$`);
+  return success(null, null, roots);
 };
-var matchWorkspace = (glob, target) => globToRegExp(glob.replaceAll("\\", "/")).test(target.replaceAll("\\", "/"));
-var realpathOf = (p) => {
-  const real = realpathSync4.native ?? realpathSync4;
+function captureCandidate(root, scope, environment = []) {
+  let checkout;
   try {
-    return real(p);
+    checkout = fs7.realpathSync(root);
   } catch {
-    return p;
+    return failure("invalid_input", "candidate root does not exist");
   }
-};
-var canonicalGlob = (glob) => {
-  const m = /[*?[\]{]/.exec(glob);
-  const prefix = m ? glob.slice(0, m.index) : glob;
-  const rest = m ? glob.slice(m.index) : "";
-  if (!prefix)
-    return glob;
-  const real = realpathOf(prefix.replace(/\/+$/, "") || "/");
-  return real + (prefix.endsWith("/") ? "/" : "") + rest;
-};
-var resolveWorkspaceFrom = (cwd, dir) => {
-  const targets = [cwd, realpathOf(cwd)].map((p) => p.replaceAll("\\", "/"));
-  for (const entry of loadWorkspacesFrom(dir)) {
-    if (!entry || typeof entry !== "object")
+  const normalizedScope = canonicalScope(scope);
+  if (!normalizedScope)
+    return failure("invalid_input", "candidate scope is invalid: paths must be checkout-relative — to work in another repository, keep this task here and coordinate a separate linked task in that checkout", { fields: [{ path: "scope.paths", reason: "must be checkout-relative" }] });
+  const roots = scopeRoots(checkout, normalizedScope);
+  if (!roots.ok)
+    return roots;
+  const git = gitPaths(checkout);
+  const names = new Set;
+  let uncertain = git.uncertain;
+  for (const target of roots.data) {
+    const item = relative(checkout, target);
+    if (item === ".git" || item === ".workit")
       continue;
-    const ws = entry;
-    if (typeof ws.glob !== "string" || !ws.glob)
+    names.add(item);
+    if (!fs7.existsSync(target))
+      continue;
+    let stat;
+    try {
+      stat = fs7.lstatSync(target);
+    } catch {
+      uncertain = true;
       continue;
-    const glob = ws.glob.replaceAll("\\", "/");
-    const canonical = canonicalGlob(glob);
-    for (const target of targets) {
-      if (matchWorkspace(glob, target))
-        return ws;
-      if (canonical !== glob && matchWorkspace(canonical, target))
-        return ws;
     }
+    if (!git.git && stat.isDirectory() && !stat.isSymbolicLink())
+      uncertain = walk(checkout, target, names) || uncertain;
   }
-  return null;
+  for (const item of git.paths)
+    if (scopeMatches(item, normalizedScope))
+      names.add(item);
+  const files = [];
+  let completeness = uncertain ? "uncertain" : "known";
+  for (const item of [...names].sort()) {
+    if (!scopeMatches(item, normalizedScope))
+      continue;
+    const target = path10.join(checkout, item);
+    try {
+      const stat = fs7.lstatSync(target);
+      if (stat.isSymbolicLink()) {
+        const link = fs7.readlinkSync(target);
+        files.push({ path: item, kind: "symlink", digest: digestBytes3(link), executable: null });
+      } else if (stat.isFile()) {
+        files.push({
+          path: item,
+          kind: "file",
+          digest: digestBytes3(fs7.readFileSync(target)),
+          executable: (stat.mode & 73) !== 0
+        });
+      } else if (!stat.isDirectory()) {
+        completeness = "uncertain";
+      } else if (git.git && git.paths.includes(item)) {
+        completeness = "uncertain";
+      }
+    } catch (error) {
+      if (error?.code === "ENOENT") {
+        files.push({ path: item, kind: "absent", digest: null, executable: null });
+      } else
+        completeness = "uncertain";
+    }
+  }
+  const supplied = Array.isArray(environment) ? environment.map((value) => typeof value === "string" ? { name: value, value: process.env[value] ?? null } : { name: value.name, value: value.value ?? null }) : Object.keys(environment).map((name) => ({
+    name,
+    value: environment[name] ?? null
+  }));
+  const namesByEnvironment = supplied.map(({ name }) => name);
+  if (new Set(namesByEnvironment).size !== namesByEnvironment.length || namesByEnvironment.some((name) => typeof name !== "string" || !name))
+    return failure("invalid_input", "candidate environment names must be unique and non-empty");
+  const values = supplied.sort((left, right) => compareCodeUnits2(left.name, right.name)).map(({ name, value }) => ({ name, value, refs: [] }));
+  if (values.some(({ value }) => value === null))
+    completeness = "uncertain";
+  const headResult = spawnSync2("git", ["rev-parse", "HEAD"], { cwd: checkout, encoding: "utf8" });
+  if (headResult.status !== 0 && !/not a git repository/i.test(headResult.stderr ?? ""))
+    completeness = "uncertain";
+  const head = headResult.status === 0 ? headResult.stdout.trim() : null;
+  const partial = {
+    id: "0".repeat(64),
+    scope: normalizedScope,
+    completeness,
+    files,
+    environment: values,
+    head
+  };
+  const candidate = { ...partial, id: candidateDigest(partial) };
+  const parsed = candidateSchema.safeParse(candidate);
+  return parsed.success ? success(null, null, parsed.data) : failure("invalid_input", "captured candidate is invalid");
+}
+var fileMap = (candidate) => new Map(candidate.files.map((file) => [file.path, file]));
+var changedPaths = (before, after) => {
+  const paths = new Set([...before.files, ...after.files].map((file) => file.path));
+  const left = fileMap(before);
+  const right = fileMap(after);
+  const changed = [...paths].filter((item) => JSON.stringify(left.get(item) ?? null) !== JSON.stringify(right.get(item) ?? null));
+  if (before.head !== after.head)
+    changed.push(".");
+  if (JSON.stringify(before.environment) !== JSON.stringify(after.environment))
+    changed.push(".");
+  return changed;
 };
-var resolveWorkspace = (cwd) => resolveWorkspaceFrom(cwd, configDir());
-
-// packages/workit-core/src/core/vcs-config.ts
-import fs7 from "node:fs";
-import path9 from "node:path";
-import { spawnSync as spawnSync2 } from "node:child_process";
-var TOKEN_PLACEHOLDER = "YOUR_TOKEN_HERE";
-var vcsConfigPath = () => process.env.WORKFLOW_VCS_CONFIG ?? path9.join(configDir(), "vcs.json");
-var vcsCwd = (cwd) => cwd ?? process.env.WORKFLOW_WORKSPACE_ROOT ?? process.cwd();
-var remoteProvider = (cwd) => {
-  const r = spawnSync2("git", ["remote", "get-url", "origin"], { cwd, encoding: "utf8" });
-  if (r.status !== 0)
+var sessionFromRef = (value) => {
+  if (typeof value !== "object" || value === null || value.kind !== "host")
     return null;
-  const url = (r.stdout ?? "").trim();
-  if (/github\.com[:/]/.test(url))
-    return "github";
-  if (/gitlab\.com[:/]/.test(url))
-    return "gitlab";
-  return null;
+  return typeof value.host === "string" && typeof value.handle === "string" ? { host: value.host, handle: value.handle } : null;
 };
-var readVcsConfig = () => {
-  const file = vcsConfigPath();
-  let raw;
-  try {
-    raw = fs7.readFileSync(file, "utf8");
-  } catch {
-    return { status: "missing", path: file, config: {} };
-  }
-  let parsed;
-  try {
-    parsed = JSON.parse(raw);
-  } catch {
-    return { status: "malformed", path: file, config: {}, error: `${file} is not valid JSON` };
-  }
-  if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
-    return { status: "valid", path: file, config: parsed };
-  }
-  return { status: "malformed", path: file, config: {}, error: `${file} is not a JSON object` };
+var sameSession = (left, right) => {
+  const other = sessionFromRef(right);
+  return left !== null && other !== null && left.host === other.host && left.handle === other.handle;
 };
-function vcsConfig(mode, cwd) {
-  const ws = resolveWorkspace(vcsCwd(cwd));
-  const wsVcs = ws?.vcs ?? {};
-  const wsYt = ws?.youtrack ?? {};
-  const wsIssues = ws?.issues ?? {};
-  const { status: cfgStatus, path: cfgPath, config: cfg, error: cfgError } = readVcsConfig();
-  const root = vcsCwd(cwd);
-  const determinateRoot = cwd !== undefined || process.env.WORKFLOW_WORKSPACE_ROOT !== undefined;
-  const rawProvider = wsVcs.provider ?? (determinateRoot ? remoteProvider(root) : null) ?? cfg.provider ?? null;
-  const provider = rawProvider === null || rawProvider === undefined ? null : String(rawProvider).toLowerCase() || null;
-  const wp = ws?.branchPolicy ?? {};
-  const hasWorkspacePolicy = typeof wp.preset === "string" && Object.hasOwn(PRESETS, wp.preset);
-  const policyDefault = resolveBranchPolicyFor(root).defaultTargetBranch;
-  const defaultTarget = String(wsVcs.defaultTargetBranch ?? (hasWorkspacePolicy ? policyDefault : cfg.defaultTargetBranch ?? policyDefault) ?? "develop");
-  const linkIssues = typeof wsYt.link_issues === "boolean" ? wsYt.link_issues : null;
-  const youtrackBaseUrl = typeof wsYt.baseUrl === "string" ? wsYt.baseUrl : null;
-  let issuesProvider = null;
-  let linkOnPr = null;
-  if (provider === "github" && typeof wsIssues.provider === "string" && wsIssues.provider.toLowerCase() === "github") {
-    issuesProvider = "github";
-    linkOnPr = typeof wsIssues.link_on_pr === "boolean" ? wsIssues.link_on_pr : null;
-  }
-  if (mode === "resolve") {
-    if (cfgStatus === "malformed")
-      return { ok: false, error: cfgError, configPath: cfgPath };
-    return {
-      ok: true,
-      workspace_name: ws?.name ?? null,
-      provider,
-      defaultTargetBranch: defaultTarget,
-      link_issues: linkIssues,
-      youtrack_base_url: youtrackBaseUrl,
-      issues_provider: issuesProvider,
-      link_on_pr: linkOnPr
-    };
-  }
-  if (cfgStatus === "malformed") {
-    return { ok: false, error: cfgError, configPath: cfgPath };
-  }
-  if (cfgStatus === "missing") {
-    return { ok: false, error: `vcs.json is missing: ${cfgPath}`, configPath: cfgPath };
-  }
-  if (provider === null) {
+var evidenceScopes = (task, ids) => (task.policy?.requirements ?? []).filter((requirement) => ids.includes(requirement.id)).map((requirement) => requirement.scope);
+function evaluateEvidence(task, candidate) {
+  const current = candidate ?? task.candidates.at(-1) ?? null;
+  return task.evidence.map((entry) => {
+    const evidence = entry.data;
+    if (evidence.result === "failed")
+      return {
+        evidenceId: entry.id,
+        status: "failed",
+        reason: "failed evidence remains historical"
+      };
+    if (evidence.kind === "check" || evidence.kind === "review") {
+      if (!evidence.beforeCandidateId || !evidence.candidateId)
+        return {
+          evidenceId: entry.id,
+          status: "stale",
+          reason: "check or review evidence lacks start and end candidates"
+        };
+      if (evidence.beforeCandidateId !== evidence.candidateId)
+        return {
+          evidenceId: entry.id,
+          status: "stale",
+          reason: "candidate changed during the check or review"
+        };
+    }
+    if (!evidence.candidateId || !current)
+      return {
+        evidenceId: entry.id,
+        status: evidence.result,
+        reason: "evidence has no candidate binding"
+      };
+    const observed = task.candidates.find((item) => item.id === evidence.candidateId) ?? (current.id === evidence.candidateId ? current : undefined);
+    if (!observed || observed.completeness === "uncertain" || current.completeness === "uncertain")
+      return { evidenceId: entry.id, status: "stale", reason: "candidate is missing or uncertain" };
+    if (observed.id === current.id)
+      return { evidenceId: entry.id, status: evidence.result, reason: "candidate is unchanged" };
+    const scopes = evidenceScopes(task, evidence.requirementIds);
+    const changed = changedPaths(observed, current);
+    const environmentChanged = JSON.stringify(observed.environment) !== JSON.stringify(current.environment);
+    if (!scopes.length || environmentChanged || changed.some((item) => scopes.some((scope) => pathRelevant(item, scope))))
+      return { evidenceId: entry.id, status: "stale", reason: "relevant candidate state changed" };
     return {
-      ok: false,
-      error: `no vcs provider configured (set vcs.provider in ${cfgPath}, match a workspace entry, or run inside a checkout with a recognized origin remote)`,
-      configPath: cfgPath
-    };
-  }
-  const prov = cfg[provider] ?? {};
-  const wsTokenFile = typeof wsVcs.tokenFile === "string" && wsVcs.tokenFile.trim() !== "" ? wsVcs.tokenFile : null;
-  const tokenFile = String(wsTokenFile ?? prov.tokenFile ?? path9.join(configDir(), `${provider}.token`));
-  const tokenPath = path9.resolve(tokenFile);
-  let tokenOk = false;
-  if (fs7.existsSync(tokenPath)) {
-    const token = fs7.readFileSync(tokenPath, "utf8").trim();
-    const placeholder = !token || token === TOKEN_PLACEHOLDER || token.startsWith(TOKEN_PLACEHOLDER);
-    tokenOk = !placeholder;
-  }
-  const out = {
-    ok: true,
-    configPath: path9.resolve(cfgPath),
-    provider,
-    defaultTargetBranch: defaultTarget,
-    pr: cfg.pr ?? {},
-    tokenPath,
-    tokenPresent: fs7.existsSync(tokenPath),
-    tokenReady: tokenOk,
-    workspace_name: ws?.name ?? null,
-    link_issues: linkIssues,
-    youtrack_base_url: youtrackBaseUrl,
-    issues_provider: issuesProvider,
-    link_on_pr: linkOnPr
-  };
-  if (provider === "gitlab") {
-    out.gitlab = {
-      host: prov.host ?? "gitlab.com",
-      apiUrl: prov.apiUrl ?? "https://gitlab.com/api/v4"
+      evidenceId: entry.id,
+      status: evidence.result,
+      reason: "candidate changed outside evidence scope"
     };
-  } else if (provider === "github") {
-    out.github = { host: prov.host ?? "github.com" };
-  }
-  if (mode === "summary")
-    delete out.tokenPath;
-  return out;
-}
-function mergedPrStyle(limit = 6, cwd) {
-  const cfg = vcsConfig("load", cwd);
-  if (!cfg.ok || !cfg.tokenReady)
-    return { ok: false, error: "vcs not configured" };
-  const provider = cfg.provider;
-  const token = fs7.readFileSync(cfg.tokenPath, "utf8").trim();
-  const examples = [];
-  const descInfo = (desc, caseInsensitiveNotes = false) => ({
-    hasNotesSection: caseInsensitiveNotes ? /##\s*notes/i.test(desc) : /##\s*Notes/.test(desc),
-    sections: desc.split(`
-`).filter((l) => l.startsWith("## ")).map((l) => l.trim()),
-    descriptionPreview: desc.slice(0, 600)
   });
-  if (provider === "gitlab") {
-    const remote = spawnSync2("git", ["remote", "get-url", "origin"], { cwd, encoding: "utf8" });
-    if (remote.status !== 0)
-      return { ok: false, error: "no origin remote" };
-    const url = (remote.stdout ?? "").trim();
-    const m = /gitlab\.com[:/](.+?)(?:\.git)?$/.exec(url);
-    if (!m)
-      return { ok: false, error: "not a gitlab.com origin" };
-    const project = m[1];
-    const env = { ...process.env, GITLAB_TOKEN: token };
-    const run = (args) => spawnSync2("glab", ["api", ...args], { cwd, encoding: "utf8", env });
-    let r = run([
-      `projects/${project.replaceAll("/", "%2F")}/merge_requests?state=merged&per_page=${limit}&order_by=updated_at&sort=desc`
-    ]);
-    if (r.status !== 0) {
-      r = run([`merge_requests?state=merged&per_page=${limit}&order_by=updated_at&sort=desc`]);
-    }
-    if (r.status !== 0)
-      return { ok: false, error: "could not list merge requests" };
-    for (const mr of JSON.parse(r.stdout ?? "[]")) {
-      const desc = String(mr.description ?? "").trim();
-      examples.push({
-        title: mr.title,
-        url: mr.web_url,
-        squash: mr.squash,
-        ...descInfo(desc, true)
-      });
-    }
-  } else if (provider === "github") {
-    const r = spawnSync2("gh", ["pr", "list", "--state", "merged", "--limit", String(limit), "--json", "title,url,body"], { cwd, encoding: "utf8", env: { ...process.env, GH_TOKEN: token } });
-    if (r.status !== 0)
-      return { ok: false, error: "could not list pull requests" };
-    for (const pr of JSON.parse(r.stdout ?? "[]")) {
-      const desc = String(pr.body ?? "").trim();
-      examples.push({ title: pr.title, url: pr.url, ...descInfo(desc) });
-    }
-  }
-  return {
-    ok: true,
-    provider,
-    count: examples.length,
-    styleHints: [
-      "Prefer ## Summary bullets + ## Validation or ## Test plan only",
-      "Do not add ## Notes with branch names, commit counts, or diff stats",
-      "Do not paste commit log or diff stat into the body"
-    ],
-    examples
-  };
 }
-
-// packages/workit-core/src/core/branch.ts
-var resolveBranchPolicyFor = (workspaceRoot) => resolveBranchPolicy(readConfig(), resolveWorkspace(workspaceRoot));
-var resolveCommitPolicyFor = (workspaceRoot) => resolveCommitPolicy(readConfig(), resolveWorkspace(workspaceRoot));
-var policy = (root) => resolveBranchPolicyFor(root);
-var allowedBranch = (root, name) => policy(root).allowed.some((r) => r.test(name));
-var isProtected = (root, name) => policy(root).protected.has(name.toLowerCase());
-var baseBranch = (cwd) => {
-  const resolved = vcsConfig("resolve", cwd);
-  if (resolved.ok === false)
-    return { error: String(resolved.error) };
-  return { base: String(resolved.defaultTargetBranch ?? "develop") };
+var scopeCovers2 = scopeCovers;
+var checkPin = (assignment, beforeCandidateId, candidateId) => {
+  const pin = assignment.candidateId ?? null;
+  if (pin === null)
+    return true;
+  return (beforeCandidateId ?? null) === pin || (candidateId ?? null) === pin;
+};
+var resolveBinding = (evidence, pin, currentCandidateId) => {
+  const bound = evidence.kind === "check" || evidence.kind === "review";
+  const fallback = bound ? pin ?? currentCandidateId : null;
+  return {
+    beforeCandidateId: evidence.beforeCandidateId ?? fallback,
+    candidateId: evidence.candidateId ?? fallback
+  };
 };
-var originBaseReady = (cwd, base) => {
-  const run = (args) => execFileSync2("git", args, { cwd, encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] });
-  try {
-    try {
-      run(["fetch", "origin", base, "--prune"]);
-    } catch {
-      run(["fetch", "origin", "--prune"]);
+var findingVerificationPasses = (findingCandidateId, evidence) => evidence.status === "passed" && (evidence.kind === "check" || evidence.kind === "review") && ((findingCandidateId ?? null) === null || evidence.candidateId === findingCandidateId);
+var applicableDecision2 = (task, workspace, requirement, checkoutRoot) => task.decisions.filter((entry) => entry.provenance.kind !== "imported").map((entry) => entry.data).filter((decision) => decision.purpose === "limitation" && decision.response === "approved" && decision.revoked === null && decision.binding.taskId === task.id && decision.binding.workspaceId === workspace.id && decision.requirementIds.includes(requirement.id) && decision.binding.scope && scopeCovers2(decision.binding.scope, requirement.scope) && decision.digest === decisionDigest(decision) && (checkoutRoot ? verifyDecisionContentAtRoot(checkoutRoot, decision.binding).ok : decision.binding.contentRefs.every((reference) => reference.kind !== "file")));
+var applicableRequirementDecision = (task, workspace, requirement, checkoutRoot) => task.decisions.filter(({ data, provenance }) => provenance.kind !== "imported" && data.purpose !== "limitation" && (data.response === "approved" || data.response === "stated") && data.revoked === null && data.binding.taskId === task.id && data.binding.workspaceId === workspace.id && data.requirementIds.includes(requirement.id) && scopeCovers2(data.binding.scope, requirement.scope) && data.digest === decisionDigest(data) && (checkoutRoot ? verifyDecisionContentAtRoot(checkoutRoot, data.binding).ok : data.binding.contentRefs.every((reference) => reference.kind !== "file"))).map(({ id }) => ({ id }));
+var evidenceMatchesRequirement = (kind, evidenceKind, dimension, ruleId) => {
+  if (kind !== "passed")
+    return false;
+  if (dimension === "testing" || dimension === "verification")
+    return evidenceKind === "check" || ruleId === "pre-pr-cleanup" && evidenceKind === "artifact";
+  if (dimension === "review")
+    return evidenceKind === "review";
+  if (dimension === "investigation" || dimension === "challenge")
+    return evidenceKind === "investigation";
+  if (dimension === "artifacts" || dimension === "continuity")
+    return evidenceKind === "artifact";
+  return false;
+};
+var expectedKinds = (dimension, ruleId) => {
+  if (dimension === "testing")
+    return "check";
+  if (dimension === "verification")
+    return ruleId === "pre-pr-cleanup" ? "check or artifact" : "check";
+  if (dimension === "review")
+    return "review";
+  if (dimension === "investigation" || dimension === "challenge")
+    return "investigation";
+  if (dimension === "artifacts" || dimension === "continuity")
+    return "artifact";
+  if (dimension === "decisions")
+    return "decision";
+  return "worker report";
+};
+function evaluateRequirements(task, workspace, capabilities, candidate, checkoutRoot, _caller) {
+  const evidence = evaluateEvidence(task, candidate);
+  if (task.policy && task.policy.policyVersion !== POLICY_VERSION)
+    return task.policy.requirements.map((requirement) => ({
+      requirementId: requirement.id,
+      status: "unsatisfied",
+      evidenceIds: [],
+      decisionIds: [],
+      reason: "stored policy version is unsupported; reassessment is required"
+    }));
+  return (task.policy?.requirements ?? []).map((requirement) => {
+    const related = task.evidence.map((entry, index) => ({ entry, evaluation: evidence[index] })).filter(({ entry }) => entry.data.requirementIds.includes(requirement.id));
+    const passed = related.filter(({ entry, evaluation }) => {
+      if (!evidenceMatchesRequirement(evaluation.status, entry.data.kind, requirement.dimension, requirement.ruleId))
+        return false;
+      if ((entry.data.kind === "check" || entry.data.kind === "review") && (!entry.data.beforeCandidateId || !entry.data.candidateId || entry.data.beforeCandidateId !== entry.data.candidateId))
+        return false;
+      if (requirement.dimension !== "review")
+        return true;
+      const reviewSession = sessionFromRef(entry.data.reviewContext);
+      const sameImplementation = sameSession(reviewSession, task.intent.provenance.session);
+      const sameEvidenceSession = related.some(({ entry: other }) => other.id !== entry.id && other.data.kind === "review" && other.data.candidateId !== null && other.data.candidateId === entry.data.candidateId && sameSession(reviewSession, other.provenance.session));
+      return entry.data.kind === "review" && reviewSession !== null && sameSession(reviewSession, entry.provenance.session) && (requirement.ruleId === "self-review" || !sameImplementation && !sameEvidenceSession);
+    });
+    if (passed.length) {
+      const currentId = candidate?.id ?? null;
+      const withRed = requirement.dimension === "testing" ? passed.filter(({ entry }) => related.some((other) => other.entry.data.kind === "check" && other.evaluation.status === "failed" && other.entry.data.requirementIds.includes(requirement.id) && other.entry.recordedAt <= entry.recordedAt) || related.some((baseline) => baseline.entry.id !== entry.id && baseline.entry.data.kind === "check" && baseline.entry.data.result === "passed" && baseline.entry.data.candidateId !== null && currentId !== null && baseline.entry.data.candidateId !== currentId)) : passed;
+      if (withRed.length)
+        return {
+          requirementId: requirement.id,
+          status: "satisfied",
+          evidenceIds: withRed.map(({ entry }) => entry.id),
+          decisionIds: [],
+          reason: "fresh applicable evidence passed"
+        };
+      if (requirement.dimension === "testing")
+        return {
+          requirementId: requirement.id,
+          status: "unsatisfied",
+          evidenceIds: [],
+          decisionIds: [],
+          reason: "testing requirement has GREEN evidence but no preceding RED"
+        };
     }
-    try {
-      execFileSync2("git", ["show-ref", "--verify", "--quiet", `refs/remotes/origin/${base}`], {
-        cwd,
-        stdio: "pipe"
-      });
-    } catch {
+    if (requirement.dimension === "delegation") {
+      const dot = (scope) => scope.paths.length > 0 ? scope : { ...scope, paths: ["."] };
+      const reconciled = task.workers.some((worker) => worker.data.report?.outcome === "completed" && (worker.data.assignment.requirementIds.includes(requirement.id) || scopeCovers2(dot(requirement.scope), dot(worker.data.assignment.scope))));
+      if (reconciled)
+        return {
+          requirementId: requirement.id,
+          status: "satisfied",
+          evidenceIds: [],
+          decisionIds: [],
+          reason: "bounded helper completed and its result is recorded"
+        };
+    }
+    const decisions = requirement.dimension === "decisions" ? applicableRequirementDecision(task, workspace, requirement, checkoutRoot) : [];
+    if (decisions.length)
       return {
-        ok: false,
-        error: `origin/${base} missing — push ${base} before creating feature/* or bugfix/* branches`
+        requirementId: requirement.id,
+        status: "satisfied",
+        evidenceIds: [],
+        decisionIds: decisions.map((decision) => decision.id),
+        reason: "an applicable approved or stated decision satisfies the requirement"
+      };
+    const limitations = requirement.acceptanceAllowed ? applicableDecision2(task, workspace, requirement, checkoutRoot) : [];
+    if (limitations.length)
+      return {
+        requirementId: requirement.id,
+        status: "accepted_limitation",
+        evidenceIds: [],
+        decisionIds: limitations.map((decision) => task.decisions.find((entry) => entry.data === decision).id),
+        reason: "an applicable approved limitation permits the missing evidence"
+      };
+    const unavailable = capabilities.some((capability) => capability.assurance === "unavailable" && (capability.name === requirement.dimension || capability.surface === requirement.dimension));
+    if (!unavailable && related.length > 0 && !passed.length)
+      return {
+        requirementId: requirement.id,
+        status: "unsatisfied",
+        evidenceIds: related.map(({ entry }) => entry.id),
+        decisionIds: [],
+        reason: `no passing evidence (needs kind:${expectedKinds(requirement.dimension, requirement.ruleId)})`
       };
-    }
-    return { ok: true };
-  } catch (error) {
     return {
-      ok: false,
-      error: error instanceof Error ? error.message : "ensure-base-branch failed"
+      requirementId: requirement.id,
+      status: unavailable ? "unavailable" : "unsatisfied",
+      evidenceIds: related.map(({ entry }) => entry.id),
+      decisionIds: [],
+      reason: unavailable ? "required capability is unavailable" : "no fresh passing evidence"
     };
+  });
+}
+function evaluateClosure(requestedOutcome, view) {
+  if (requestedOutcome !== "stopped" && !view.task.policy)
+    return failure("requirements_unsatisfied", "task has not been assessed");
+  if (view.task.policy && view.task.policy.policyVersion !== POLICY_VERSION)
+    return failure("requirements_unsatisfied", "stored policy version is unsupported; reassessment is required");
+  const evaluations = view.requirements;
+  const openFindings = view.task.findings.filter((entry) => entry.data.disposition === "open");
+  if (requestedOutcome !== "stopped" && openFindings.length)
+    return failure("requirements_unsatisfied", "open findings must be resolved before closure");
+  if (requestedOutcome !== "stopped") {
+    const evidenceById = new Map(view.evidence.map((entry) => [entry.evidenceId, entry.status]));
+    for (const entry of view.task.findings) {
+      if (entry.data.disposition === "fixed") {
+        const verified = entry.data.resolution?.evidenceIds.some((id) => {
+          const evidence = view.task.evidence.find((item) => item.id === id);
+          if (!evidence)
+            return false;
+          return findingVerificationPasses(entry.data.candidateId, {
+            kind: evidence.data.kind,
+            candidateId: evidence.data.candidateId,
+            status: evidenceById.get(id) ?? "missing"
+          });
+        });
+        if (!verified)
+          return failure("requirements_unsatisfied", "fixed findings require current verification");
+      }
+      if (entry.data.disposition === "deferred") {
+        const valid = entry.data.resolution?.decisionIds.some((id) => {
+          const decisionEntry = view.task.decisions.find((item) => item.id === id);
+          const decision = decisionEntry?.data;
+          return Boolean(decision && decisionEntry?.provenance.kind !== "imported" && decision.purpose === "limitation" && decision.response === "approved" && decision.revoked === null && decision.digest === decisionDigest(decision) && verifyDecisionContentAtRoot(view.workspace.root, decision.binding).ok && decision.binding.taskId === view.task.id && decision.binding.workspaceId === view.workspace.id && scopeCovers2(decision.binding.scope, entry.data.scope) && decision.requirementIds.some((requirementId) => view.task.policy?.requirements.some((requirement) => requirement.id === requirementId && requirement.acceptanceAllowed)));
+        });
+        if (!valid)
+          return failure("requirements_unsatisfied", "deferred findings require an approved limitation decision that references an acceptanceAllowed requirement and covers the finding scope");
+      }
+    }
   }
+  const blocking = evaluations.filter((item) => {
+    if (item.status !== "unsatisfied" && item.status !== "unavailable")
+      return false;
+    const requirement = view.task.policy?.requirements.find((candidate) => candidate.id === item.requirementId);
+    return !requirement || requirement.before === "close";
+  });
+  if (requestedOutcome !== "stopped" && blocking.length)
+    return failure("requirements_unsatisfied", "applicable requirements are unsatisfied", {
+      requirementIds: blocking.map((item) => item.requirementId),
+      requirements: blocking.map((item) => {
+        const requirement = view.task.policy?.requirements.find((candidate) => candidate.id === item.requirementId);
+        return {
+          requirementId: item.requirementId,
+          ruleId: requirement?.ruleId ?? "unknown",
+          reason: item.reason,
+          satisfaction: requirement?.satisfaction ?? "",
+          dependentAction: requirement?.dependentAction ?? null
+        };
+      })
+    });
+  const accepted = evaluations.filter((item) => item.status === "accepted_limitation");
+  if (requestedOutcome === "verified" && accepted.length)
+    return failure("requirements_unsatisfied", "accepted limitations cannot be reported as verified", {
+      requirementIds: accepted.map((item) => item.requirementId)
+    });
+  const evidenceIds = [
+    ...new Set([
+      ...evaluations.flatMap((item) => item.evidenceIds),
+      ...view.task.findings.flatMap((item) => item.data.resolution?.evidenceIds ?? [])
+    ])
+  ];
+  const decisionIds = [
+    ...new Set([
+      ...evaluations.flatMap((item) => item.decisionIds),
+      ...view.task.findings.flatMap((item) => item.data.resolution?.decisionIds ?? [])
+    ])
+  ];
+  return success(null, null, {
+    outcome: requestedOutcome === "stopped" ? "stopped" : accepted.length ? "accepted_limitations" : "verified",
+    evidenceIds,
+    decisionIds,
+    requirementIds: evaluations.map((item) => item.requirementId)
+  });
+}
+
+// packages/workit-core/src/core/methods.ts
+var METHODS = {
+  "workit-challenge": { dimensions: ["challenge", "decisions"] },
+  "workit-behavioral-tdd": { dimensions: ["testing"], ruleIds: ["mechanical-existing-checks"] },
+  "workit-review": { dimensions: ["review"], ruleIds: ["fresh-context-review", "self-review"] },
+  "workit-plan": { dimensions: ["artifacts", "continuity"] },
+  "workit-implement": { dimensions: ["delegation"] },
+  "workit-debug": {},
+  "workit-handoff": {},
+  "workit-deslop": { ruleIds: ["pre-pr-cleanup"] }
 };
-var fastForwardBase = (cwd, base) => {
-  const run = (args) => execFileSync2("git", args, { cwd, encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] });
-  try {
-    let hasLocalBase = true;
-    try {
-      execFileSync2("git", ["show-ref", "--verify", "--quiet", `refs/heads/${base}`], {
-        cwd,
-        stdio: "pipe"
-      });
-    } catch {
-      hasLocalBase = false;
-    }
-    if (hasLocalBase) {
-      run(["checkout", base]);
-      try {
-        run(["merge", "--ff-only", `origin/${base}`]);
-      } catch {}
-    } else {
-      run(["checkout", "-b", base, "--track", `origin/${base}`]);
-    }
-    return { ok: true };
-  } catch (error) {
+var methodMatches = (definition, requirement) => definition.dimensions?.includes(requirement.dimension) === true || definition.ruleIds?.includes(requirement.ruleId) === true;
+var assuranceFor = (id, definition, capabilities) => {
+  const keys = new Set([
+    id,
+    ...definition.dimensions ?? [],
+    ...definition.ruleIds ?? []
+  ]);
+  const matches = capabilities.filter((capability) => keys.has(capability.name) || keys.has(capability.surface));
+  if (id === "workit-review" && matches.length === 0)
+    return { assurance: "unavailable", reasons: ["independent review capability is unavailable"] };
+  if (matches.some((capability) => capability.assurance === "unavailable"))
     return {
-      ok: false,
-      error: error instanceof Error ? error.message : "ensure-base-branch failed"
+      assurance: "unavailable",
+      reasons: matches.filter((capability) => capability.assurance === "unavailable").map((capability) => capability.reason)
     };
-  }
-};
-var ensureBaseBranch = (cwd, base) => {
-  const git = gitContext(cwd);
-  if (!git.branch || git.branch === "unknown")
-    return { ok: false, error: "not in a git repository" };
-  const ready = originBaseReady(cwd, base);
-  if (!ready.ok)
-    return ready;
-  return fastForwardBase(cwd, base);
+  if (matches.some((capability) => capability.assurance === "enforced"))
+    return { assurance: "enforced", reasons: matches.map((capability) => capability.reason) };
+  return { assurance: "agent_guided", reasons: matches.map((capability) => capability.reason) };
 };
-var classifyBranchDirt = (workspaceRoot) => {
-  let raw;
-  try {
-    raw = execFileSync2("git", ["status", "--porcelain=v1"], {
-      cwd: path10.resolve(workspaceRoot),
-      encoding: "utf8",
-      stdio: ["pipe", "pipe", "pipe"]
+function selectMethods(policy, capabilities) {
+  return Object.entries(METHODS).flatMap(([id, definition]) => {
+    const requirements = policy.requirements.filter((requirement) => methodMatches(definition, requirement));
+    if (requirements.length === 0)
+      return [];
+    const capability = assuranceFor(id, definition, capabilities);
+    const reasons = [
+      ...new Set(requirements.map((requirement) => requirement.reason)),
+      ...capability.reasons
+    ];
+    if (capability.assurance === "unavailable")
+      reasons.unshift("required capability is unavailable");
+    return [{ id, reason: reasons.join("; "), assurance: capability.assurance }];
+  });
+}
+var invariantBootstrap = () => `
+Workit keeps one accountable lead and one shared task state. Inspect current task
+state before acting. An empty task.list means no session yet, not permission to
+skip Workit; for user-requested product, debug, or behavior work with no active
+or paused task, run task.start then policy.assess before other product mutations.
+Omitted expectedRevision, expectedWorkspaceRevision, and writer workerId default
+to the current records; explicit values are still concurrency-checked, so never
+copy revisions between calls. Happy path: task.list, task.start {intent} with no
+revisions, policy.assess {assessment: {facts, signals, consequences,
+verification}} where facts are inferred or observed with file refs,
+writer.acquire {taskId} before product writes, evidence.record {evidence} where
+check and review kinds auto-bind the current tree and need no digests. Record
+self-review requirements with kind review and reviewContext matching your own
+host session; the lead may also record checks. Fresh-context review requires a
+session distinct from the task creator and every other evidence recorder. Record
+verification evidence last: later evidence or commits can reopen fixed findings
+for re-verification, so verify, resolve, then close with nothing in between.
+decision.record {binding with taskId/workspaceId from inspect plus presented and
+approvedContent} only through a native approval question asked receipt-shaped:
+header Workit decision: <purpose>, the same label repeated in the question
+text (some host UIs do not render headers), exactly two options approved and
+rejected; ask once, never re-ask to mint a receipt. Before asking, present the
+item in the conversation (durable artifacts: complete digest plus exact path;
+inline plans: the content) and keep the question to one short scoped sentence;
+never ask to approve something unseen. An answer with custom text is steering,
+not approval: adjust, re-present, then ask a new scoped question. After the user
+approves a spec or plan, execute the remaining tasks continuously with one
+atomic commit per task and do not ask whether to continue; stop only for a new
+product decision, a failed safety or verification gate, a conflicting edit, or
+missing authority. Record the plan's commit list once through the plan-scoped
+action approval (git.commit with plan_steps and plan_branch) so each listed
+commit executes without a new question; an unlisted message needs a fresh
+approval. task.close {outcome,
+summary, decisionIds}. A completed native subagent run stops its bound worker
+by itself; if a worker strands in cancelling with its run verifiably over,
+repeat worker.cancel {reason} to confirm the stop. Check and review evidence
+without a bound candidate goes stale; findings close only as fixed with passing
+verification, dismissed with supporting evidence, or deferred under an approved
+limitation. Use only the
+shared operations for task, policy, evidence, finding, decision, worker, writer,
+and state changes. Authority is bounded by the requested scope, current
+revision, caller/session provenance, and observed capabilities. Never claim host
+enforcement or evidence that the host cannot provide. Shell-executed writes are
+unattested agent-guided work even when a writer is held. Preserve unresolved
+requirements, gaps, and uncertain workers. Skill routing: slash aliases /wk-*
+always load on demand. Model-invoked: new instructions, interruptions, or
+forgotten items mid-task → load workit-steer before responding; about to open
+a PR or fresh from implementing → load workit-deslop; CI red → load
+workit-green-run; small-looking change before close or merge → load
+workit-blast-radius; ambiguous, consequential, or disputed proposal before
+recommending → load workit-challenge; spec or plan needs a flow diagram →
+load workit-diagram, a UI sketch → load workit-mockup. Load the skill; never
+act from memory of it.
+`.trim();
+
+// packages/workit-core/src/core/task-context.ts
+function reconcileResume(view, observations = []) {
+  if (observations.length > 0)
+    return failure("permission_denied", "worker observations require native host verification");
+  const candidate = captureCandidate(view.workspace.root, view.task.intent.data.scope, []);
+  if (!candidate.ok)
+    return candidate;
+  const staleEvidenceIds = evaluateEvidence(view.task, candidate.data).filter((entry) => entry.status === "stale").map((entry) => entry.evidenceId);
+  const blockers = [...view.task.progress.blockers];
+  if (view.task.workers.some((entry) => isUncertainWorker(entry.data.state)))
+    blockers.push({
+      reason: "worker state requires reconciliation",
+      dependentAction: "resume",
+      refs: []
     });
-  } catch {
-    return "clean";
-  }
-  let dirty = false;
-  for (const line of raw.split(`
-`)) {
-    if (!line.trim())
-      continue;
-    dirty = true;
-    const code = line.slice(0, 2);
-    if (code === "??")
-      continue;
-    let entry = line.slice(3);
-    const arrow = entry.indexOf(" -> ");
-    if (arrow >= 0)
-      entry = entry.slice(arrow + 4);
-    const unquoted = entry.startsWith('"') && entry.endsWith('"') ? entry.slice(1, -1) : entry;
-    if (unquoted !== "docs" && !unquoted.startsWith("docs/"))
-      return "stash-required";
-  }
-  return dirty ? "carry" : "clean";
-};
-var branchSetup = ({
-  action,
-  sdd_dir,
-  target_branch,
-  stash,
-  workspace_root,
-  log
-}) => {
-  const cwd = path10.resolve(workspace_root);
-  const exec = (args) => execFileSync2("git", args, { cwd, encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] });
-  const current = gitContext(cwd).branch;
-  if (!current || current === "unknown")
-    return { error: "not in a git repository", phase: "preflight" };
-  const sdd = sdd_dir ?? "docs";
-  const manifestPath = path10.isAbsolute(sdd) ? path10.join(sdd, "manifest.json") : path10.join(cwd, sdd, "manifest.json");
-  const ensureManifestDir = () => {
-    const dir = path10.dirname(manifestPath);
-    if (!existsSync5(dir))
-      mkdirSync3(dir, { recursive: true, mode: 493 });
-  };
-  const readManifest = () => {
-    try {
-      return JSON.parse(readFileSync6(manifestPath, "utf8"));
-    } catch {
-      return {};
-    }
-  };
-  const writeManifest = (data) => {
-    ensureManifestDir();
-    writeFileSync3(manifestPath, JSON.stringify(data, null, 2) + `
-`, "utf8");
-  };
-  const journal = (message) => log?.(`branch-setup: ${message}`);
-  if (action === "reapply_stash") {
-    const manifest = readManifest();
-    const ref = manifest.stash_ref;
-    if (!ref)
-      return { error: "no stash_ref in manifest", phase: "preflight" };
-    journal(`pre-pop: ${String(ref)}`);
-    try {
-      exec(["stash", "pop", String(ref)]);
-    } catch (error) {
-      journal("pop: failed");
-      return {
-        error: error instanceof Error ? error.message : "stash pop failed",
-        phase: "post_mutation"
-      };
-    }
-    journal("pop: ok");
-    delete manifest.stash_ref;
-    delete manifest.stash_created_at;
-    writeManifest(manifest);
-    return { action: "reapply_stash", ok: true };
-  }
-  const target = target_branch ?? "";
-  if (!target)
+  return success(null, null, {
+    candidate: candidate.data,
+    staleEvidenceIds,
+    workerUpdates: [],
+    blockers,
+    reassessmentRequired: view.task.policy?.policyVersion !== POLICY_VERSION
+  });
+}
+var COMPACT_MAX_BYTES = 4096;
+var COMPACT_MAX_ITEMS = 8;
+var COMPACT_TEXT_BYTES = 128;
+var sensitiveUrl = /\bhttps?:\/\/[^/\s:@]+:[^@\s]+@/gi;
+var sensitiveValue = /(?:token|secret|password|passwd|api[-_ ]?key|private[-_ ]?key|authorization)\s*[:=]\s*(?:bearer\s+)?\S+|\bbearer\s+\S+/gi;
+var privateKey = /-----BEGIN [^-]*PRIVATE KEY-----[\s\S]*?-----END [^-]*PRIVATE KEY-----/gi;
+var compactText = (value, limit) => value === null ? null : value.replace(privateKey, "<redacted-private-key>").replace(sensitiveUrl, "<redacted-url>").replace(sensitiveValue, (match) => {
+  const separator = match.search(/[:=]/u);
+  if (separator >= 0)
+    return `${match.slice(0, separator)}=<redacted>`;
+  const space = match.search(/\s/u);
+  return `${match.slice(0, space)} <redacted>`;
+}).slice(0, limit);
+var compactBytes = (value) => new TextEncoder().encode(value).byteLength;
+var compactReference = (ref) => {
+  if (ref.kind === "file")
     return {
-      error: "target_branch (the working branch to create or switch to) is required for setup",
-      phase: "preflight"
+      kind: "file",
+      path: compactText(ref.path, COMPACT_TEXT_BYTES) ?? ""
     };
-  if (isProtected(cwd, target))
-    return { error: `protected branch ${target}`, phase: "preflight" };
-  if (!allowedBranch(cwd, target))
+  if (ref.kind === "record")
     return {
-      error: `target branch ${target} is not allowed by the branch policy`,
-      phase: "preflight"
+      kind: "record",
+      collection: ref.collection,
+      id: ref.id
     };
-  let base;
-  let targetExists = true;
-  try {
-    exec(["rev-parse", "--verify", "--quiet", `refs/heads/${target}`]);
-  } catch {
-    targetExists = false;
+  return { kind: ref.kind };
+};
+function compactTaskContext(view) {
+  const decisions = view.task.decisions.slice().sort((left, right) => left.id < right.id ? -1 : left.id > right.id ? 1 : 0).slice(0, COMPACT_MAX_ITEMS).map((entry) => ({
+    id: entry.id,
+    purpose: entry.data.purpose,
+    status: entry.data.response,
+    digest: entry.data.digest,
+    references: entry.data.binding.contentRefs.slice(0, 1).map(compactReference)
+  }));
+  const methods = view.task.policy ? selectMethods(view.task.policy, view.capabilities).map((method) => ({
+    id: method.id,
+    assurance: method.assurance,
+    reason: compactText(method.reason, COMPACT_TEXT_BYTES) ?? ""
+  })) : [];
+  const gaps = Array.from(new Set([
+    ...view.evidence.filter((entry) => entry.status === "stale").map((entry) => `stale evidence: ${entry.evidenceId}`),
+    ...view.requirements.filter((entry) => entry.status !== "satisfied").map((entry) => entry.reason),
+    ...view.task.progress.blockers.map((entry) => entry.reason)
+  ])).sort().slice(0, COMPACT_MAX_ITEMS).map((gap) => compactText(gap, COMPACT_TEXT_BYTES));
+  const context = {
+    objective: compactText(view.task.intent.data.objective, COMPACT_TEXT_BYTES) ?? "",
+    status: view.task.status,
+    decisions,
+    methods,
+    gaps,
+    nextAction: compactText(view.task.progress.nextAction, COMPACT_TEXT_BYTES)
+  };
+  let encoded = JSON.stringify(context);
+  while (compactBytes(encoded) > COMPACT_MAX_BYTES && (context.decisions.length || context.methods.length || context.gaps.length)) {
+    if (context.gaps.length)
+      context.gaps.pop();
+    else if (context.decisions.length)
+      context.decisions.pop();
+    else
+      context.methods.pop();
+    encoded = JSON.stringify(context);
   }
-  if (!targetExists) {
-    const baseResolved = baseBranch(cwd);
-    if ("error" in baseResolved)
-      return { error: baseResolved.error, phase: "preflight" };
-    base = baseResolved.base;
+  if (compactBytes(encoded) > COMPACT_MAX_BYTES) {
+    context.objective = compactText(context.objective, 64) ?? "";
+    context.nextAction = compactText(context.nextAction, 64);
+    encoded = JSON.stringify(context);
   }
-  journal(`entry: current=${current} target=${target} base=${base ?? "-"}`);
-  let stash_ref;
-  const failAfterStash = (message, phase = "post_mutation") => {
-    let suffix = "";
-    if (stash_ref) {
-      journal(`pre-pop: ${stash_ref}`);
-      try {
-        exec(["stash", "pop", stash_ref]);
-        stash_ref = undefined;
-        journal("pop: ok");
-      } catch {
-        journal("pop: failed");
-        suffix = " (changes preserved in stash)";
-      }
-    }
-    return { error: `${message}${suffix}`, phase: stash_ref ? "post_mutation" : phase };
-  };
-  if (current !== target) {
-    const dirty = Boolean(gitContext(cwd).status_short.trim());
-    if (classifyBranchDirt(cwd) === "stash-required" && stash !== "yes") {
-      return {
-        error: "dirty working tree — ask with native question, then call workit_branch_setup with stash=yes",
-        phase: "preflight"
-      };
-    }
-    let validatedBase;
-    if (!targetExists && base !== undefined) {
-      const ready = originBaseReady(cwd, base);
-      if (!ready.ok)
-        return { error: ready.error ?? "ensure-base-branch failed", phase: "preflight" };
-      validatedBase = base;
-    }
-    if (dirty && stash === "yes") {
-      try {
-        exec(["stash", "push", "-u", "-m", `workit: pre-checkout ${target}`]);
-      } catch (error) {
-        return {
-          error: error instanceof Error ? error.message : "stash push failed",
-          phase: "post_mutation"
-        };
-      }
-      stash_ref = "stash@{0}";
-      journal(`stash push: ${stash_ref}`);
-    }
-    try {
-      exec(["checkout", target]);
-      journal("post-checkout");
-    } catch (error) {
-      const message = error instanceof Error ? error.message : "checkout failed";
-      if (/worktree/i.test(message)) {
-        return failAfterStash(`branch ${target} is locked by an existing git worktree — remove it first (we do not use worktrees)`, "preflight");
-      }
-      try {
-        let effectiveBase = base;
-        if (effectiveBase === undefined) {
-          const lateResolved = baseBranch(cwd);
-          if ("error" in lateResolved)
-            return failAfterStash(lateResolved.error, "preflight");
-          effectiveBase = lateResolved.base;
-        }
-        const baseResult = validatedBase !== undefined ? fastForwardBase(cwd, effectiveBase) : ensureBaseBranch(cwd, effectiveBase);
-        if (!baseResult.ok)
-          return failAfterStash(baseResult.error ?? "ensure-base-branch failed");
-        exec(["checkout", "-b", target]);
-        journal("post-create");
-      } catch (createError) {
-        return failAfterStash(createError instanceof Error ? createError.message : "branch create failed");
-      }
-    }
+  return encoded;
+}
+var exportDigest = (bundle) => sha256({
+  schemaVersion: bundle.schemaVersion,
+  exportedAt: bundle.exportedAt,
+  sourceWorkspaceId: bundle.sourceWorkspaceId,
+  task: bundle.task
+});
+// packages/workit-core/src/core/route-intent.ts
+var GUIDANCE = {
+  "git.branch_setup": "use the Workit git.branch_setup action (workit_external_action in hosts, or `workit action git.branch_setup --payload '{}' --confirm --json` in the CLI)",
+  "hosting.pull_request": "use the Workit hosting.pull_request action (workit_external_action in hosts, or `workit action hosting.pull_request --payload '{...}' --confirm --json` in the CLI), then drive the created PR through workit-babysit",
+  "hosting.merge": "use the Workit hosting.merge action (workit_external_action in hosts, or `workit action hosting.merge --payload '{...}' --confirm --json` in the CLI)"
+};
+var unbalancedQuotes = (segment) => {
+  const text = segment.replace(/\\./gu, "");
+  return (text.match(/"/gu)?.length ?? 0) % 2 !== 0 || (text.match(/'/gu)?.length ?? 0) % 2 !== 0;
+};
+var segmentTokens = (segment) => {
+  if (segment.includes("`") || segment.includes("$("))
+    return null;
+  if (unbalancedQuotes(segment))
+    return null;
+  const parts = segment.trim().split(/\s+/u);
+  while (parts.length > 0 && /^[A-Za-z_][A-Za-z0-9_]*=/u.test(parts[0]))
+    parts.shift();
+  return parts.length > 0 ? parts : null;
+};
+var unquote = (token) => token.replace(/^['"]|['"]$/gu, "");
+function shellRouteIntent(command) {
+  if (typeof command !== "string" || command.trim() === "")
+    return null;
+  for (const raw of command.split(/&&|\|\||;|\n/u)) {
+    const parts = segmentTokens(raw);
+    if (!parts)
+      continue;
+    const head = unquote(parts[0]);
+    const second = unquote(parts[1] ?? "");
+    const third = unquote(parts[2] ?? "");
+    if (head === "git" && second === "switch" && (third === "-c" || third === "--create"))
+      return { route: "git.branch_setup", guidance: GUIDANCE["git.branch_setup"] };
+    if (head === "git" && second === "checkout" && (third === "-b" || third === "-B"))
+      return { route: "git.branch_setup", guidance: GUIDANCE["git.branch_setup"] };
+    if (head === "gh" && second === "pr" && third === "create")
+      return { route: "hosting.pull_request", guidance: GUIDANCE["hosting.pull_request"] };
+    if (head === "glab" && second === "mr" && third === "create")
+      return { route: "hosting.pull_request", guidance: GUIDANCE["hosting.pull_request"] };
+    if (head === "gh" && second === "pr" && third === "merge")
+      return { route: "hosting.merge", guidance: GUIDANCE["hosting.merge"] };
+    if (head === "glab" && second === "mr" && third === "merge")
+      return { route: "hosting.merge", guidance: GUIDANCE["hosting.merge"] };
   }
+  return null;
+}
+function hasLiveWorkitTask(dir) {
   try {
-    const manifest = readManifest();
-    manifest.branch = target;
-    manifest.previous_branch = current;
-    if (stash_ref) {
-      manifest.stash_ref = stash_ref;
-      manifest.stash_created_at = new Date().toISOString();
-    }
-    writeManifest(manifest);
-  } catch (error) {
-    const result = failAfterStash(error instanceof Error ? `manifest update failed: ${error.message}` : "manifest update failed");
-    if (stash_ref === undefined && gitContext(cwd).branch !== current) {
-      try {
-        exec(["checkout", current]);
-      } catch {
-        try {
-          exec(["checkout", "-m", current]);
-        } catch {}
-      }
-    }
-    return result;
+    if (typeof dir !== "string" || dir === "")
+      return false;
+    const listed = new TaskStore(dir).listTasks();
+    if (!listed.ok)
+      return false;
+    return listed.data.some((task) => task.status === "active" || task.status === "paused");
+  } catch {
+    return false;
   }
-  return {
-    action: "setup",
-    ok: true,
-    branch: target,
-    previous_branch: current,
-    stash_ref: stash_ref ?? null,
-    manifest: manifestPath
-  };
-};
+}
+function shouldDenyShellRoute(dir, command) {
+  if (!hasLiveWorkitTask(dir))
+    return null;
+  return shellRouteIntent(command);
+}
 // packages/workit-core/src/core/external-action.ts
 import { execFileSync as execFileSync3 } from "node:child_process";
 var externalActionSchema = discriminatedUnion("operation", [
@@ -12142,6 +12396,13 @@ var externalActionSchema = discriminatedUnion("operation", [
       babysit: boolean2().optional()
     }).strict()
   }).strict(),
+  object({
+    operation: literal("hosting.merge"),
+    payload: object({
+      target_branch: string2().min(1).optional(),
+      source_branch: string2().min(1).optional()
+    }).strict()
+  }).strict(),
   object({
     operation: literal("youtrack.update"),
     payload: object({
@@ -12215,7 +12476,7 @@ var externalActionDescriptor = (operation, payload) => canonicalJson({
   payload,
   ...payload && typeof payload === "object" && !Array.isArray(payload) && "resolved" in payload && payload.resolved && typeof payload.resolved === "object" && Array.isArray(payload.resolved.steps) ? { steps: payload.resolved.steps } : {}
 });
-var externalActionHelp = "Fixed actions: git.branch_setup {action?,sdd_dir?,target_branch(required unless reapply_stash; the working branch to create or switch to),stash?}; git.commit {message}; git.push {branch?}; hosting.pull_request {title,body?,draft?,target_branch?,babysit?}; youtrack.update {issueId,markdown,minutes?}; youtrack.time {issueId,minutes,text?,dateMs?}; youtrack.meeting {issueId,minutes,text}; changelog.apply {entries?,path?,normalize_only?}; context.read {kind,range?,issueId?,issueUrl?,issueRef?,mode?,specPath?,planPath?}. context.read is read-only and needs no approval; all other operations require native approval (CLI uses a TTY; caller-unattested MCP cannot mutate).";
+var externalActionHelp = "Fixed actions: git.branch_setup {action?,sdd_dir?,target_branch(required unless reapply_stash; the working branch to create or switch to),stash?}; git.commit {message}; git.push {branch?}; hosting.pull_request {title,body?,draft?,target_branch?,babysit?}; hosting.merge {target_branch?,source_branch?}; youtrack.update {issueId,markdown,minutes?}; youtrack.time {issueId,minutes,text?,dateMs?}; youtrack.meeting {issueId,minutes,text}; changelog.apply {entries?,path?,normalize_only?}; context.read {kind,range?,issueId?,issueUrl?,issueRef?,mode?,specPath?,planPath?}. context.read is read-only and needs no approval; all other operations require native approval (CLI uses a TTY; caller-unattested MCP cannot mutate).";
 var externalActionRef = (host, actor, descriptor) => ({
   kind: "host",
   host,
@@ -13741,7 +14002,10 @@ class WorkitCore {
   observeDecision(request, observation) {
     return this.recordDecision(request, observation, true);
   }
-  recordDecision(request, nativeObservation, nativeRequired = false) {
+  observeStandingDecision(request) {
+    return this.recordDecision(request, undefined, true, true);
+  }
+  recordDecision(request, nativeObservation, nativeRequired = false, standing = false) {
     const root = this.contextRootError();
     if (!root.ok)
       return root;
@@ -13756,8 +14020,10 @@ class WorkitCore {
       return failure("permission_denied", "stated choices cannot authorize mutating actions");
     if (stated && !input.binding?.statedChoice)
       return failure("invalid_input", "stated choices require binding.statedChoice");
-    if (nativeRequired && nativeObservation === undefined && !stated)
+    if (nativeRequired && nativeObservation === undefined && !stated && !standing)
       return failure("permission_denied", "native decision observation is required");
+    if (standing && (!input.binding?.standing || input.purpose !== "action" || input.response !== "approved"))
+      return failure("invalid_input", "standing approvals need an approved action binding with a standing rule");
     const task = this.store.readTask(input.taskId);
     if (!task.ok)
       return task;
@@ -13789,7 +14055,10 @@ class WorkitCore {
         consumption: null
       };
       const data = { ...base, digest: decisionDigest(base) };
-      const native = nativeRequired && !stated ? verifyNativeDecision(this.context.nativeAuthority, {
+      const standingApproval = standing && !stated ? verifyStandingApproval(this.store.root, task.data, this.context.caller, input.binding) : null;
+      if (standingApproval && !standingApproval.ok)
+        return standingApproval;
+      const native = nativeRequired && !stated && !standingApproval ? verifyNativeDecision(this.context.nativeAuthority, {
         observation: nativeObservation,
         expected: {
           taskId: task.data.id,
@@ -13820,7 +14089,7 @@ class WorkitCore {
         const entry = {
           id: newId(),
           recordedAt: mutation.now,
-          provenance: nativeProvenance ?? provenance(this.context, "agent_reported"),
+          provenance: standingApproval?.ok === true ? standingApproval.data : nativeProvenance ?? provenance(this.context, "agent_reported"),
           data
         };
         return success(mutation.revision, null, {
@@ -15337,10 +15606,58 @@ function prCreate(env, cwd) {
     output: (result.stdout ?? "").trim()
   };
 }
+function mergePr(cwd, opts) {
+  const root = repoRoot(cwd);
+  const cfg = vcsConfig("load", root);
+  if (!cfg.ok)
+    return { error: cfg.error ?? "vcs config missing" };
+  if (!cfg.tokenReady)
+    return { error: "VCS token not ready — run /wk-init and edit token file locally" };
+  const provider = cfg.provider;
+  if (provider !== "gitlab" && provider !== "github")
+    return { error: `unsupported provider: ${provider}` };
+  if (!hostingCliAvailable(provider))
+    return { error: `workflow CLI missing (required for ${provider})` };
+  const pr = cfg.pr ?? {};
+  const token = fs8.readFileSync(cfg.tokenPath, "utf8").trim();
+  const squash = pr.squashOnMerge !== false;
+  const removeBranch = pr.removeSourceBranch !== false;
+  let cmd;
+  let cmdEnv;
+  if (provider === "gitlab") {
+    cmd = ["glab", "mr", "merge", opts.source];
+    cmd.push(squash ? "--squash" : "--squash=false");
+    if (removeBranch)
+      cmd.push("--remove-source-branch");
+    cmd.push("--yes");
+    cmdEnv = { ...process.env, PATH: process.env.PATH ?? "", GITLAB_TOKEN: token };
+  } else {
+    cmd = ["gh", "pr", "merge", opts.source];
+    cmd.push(squash ? "--squash" : "--merge");
+    if (removeBranch)
+      cmd.push("--delete-branch");
+    cmd.push("--yes");
+    cmdEnv = { ...process.env, PATH: process.env.PATH ?? "", GH_TOKEN: token };
+  }
+  const result = spawnSync4(cmd[0], cmd.slice(1), { cwd: root, encoding: "utf8", env: cmdEnv });
+  if (result.status !== 0)
+    return {
+      error: "merge failed",
+      provider,
+      stderr: (result.stderr ?? result.stdout ?? "").trim().slice(0, 800)
+    };
+  return {
+    ok: true,
+    provider,
+    targetBranch: opts.target,
+    sourceBranch: opts.source,
+    output: (result.stdout ?? "").trim()
+  };
+}
 
 // packages/workit-core/src/core/repo-context.ts
 import { spawnSync as spawnSync5 } from "node:child_process";
-import { existsSync as existsSync7, readFileSync as readFileSync7, readdirSync as readdirSync4 } from "node:fs";
+import { existsSync as existsSync7, readFileSync as readFileSync8, readdirSync as readdirSync4 } from "node:fs";
 import path13 from "node:path";
 var isSafeContextRange = (value) => value.length <= 4096 && (() => {
   try {
@@ -15510,7 +15827,7 @@ var packageScripts = (cwd, keys) => {
   if (!existsSync7(pkgPath))
     return [];
   try {
-    const pkg = JSON.parse(readFileSync7(pkgPath, "utf8"));
+    const pkg = JSON.parse(readFileSync8(pkgPath, "utf8"));
     return keys.filter((k) => pkg.scripts && typeof pkg.scripts[k] === "string").map((k) => `${k}: ${pkg.scripts?.[k]}`);
   } catch {
     return [];
@@ -15544,7 +15861,7 @@ var documentationFiles = (cwd) => {
 var readTrimmed = (file, maxLines) => {
   if (!existsSync7(file))
     return "";
-  const lines = readFileSync7(file, "utf8").split(`
+  const lines = readFileSync8(file, "utf8").split(`
 `);
   return lines.slice(0, maxLines).join(`
 `);
@@ -15732,7 +16049,7 @@ function docsRefreshContext(root, range) {
   const pkgPath = path13.join(cwd, "package.json");
   if (existsSync7(pkgPath)) {
     try {
-      const pkg = JSON.parse(readFileSync7(pkgPath, "utf8"));
+      const pkg = JSON.parse(readFileSync8(pkgPath, "utf8"));
       stdout += JSON.stringify({ name: pkg.name, version: pkg.version, scripts: pkg.scripts }, null, 2) + `
 `;
     } catch {}
@@ -16633,7 +16950,7 @@ import path16 from "node:path";
 // packages/workit-core/src/core/changelog.ts
 import fs11 from "node:fs";
 import path15 from "node:path";
-import { createHash as createHash5 } from "node:crypto";
+import { createHash as createHash6 } from "node:crypto";
 var CATEGORIES = ["Added", "Changed", "Deprecated", "Removed", "Fixed", "Security"];
 var CAT_RE = /^###\s+(?:Added|Changed|Deprecated|Removed|Fixed|Security)\s*$/i;
 var UNRELEASED_RE = /^##\s+\[Unreleased\]\s*$/i;
@@ -16650,7 +16967,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ## [Unreleased]
 
 `;
-var digestBytes4 = (value) => createHash5("sha256").update(value).digest("hex");
+var digestBytes4 = (value) => createHash6("sha256").update(value).digest("hex");
 var readChangelogSource = (target) => {
   if (!fs11.existsSync(target)) {
     const bytes = Buffer.from(SKELETON, "utf8");
@@ -17262,6 +17579,11 @@ var actionProposalQuestion = (request, descriptorPayload) => {
         presented: `Workit decision: action — Open a PR from \`${String(resolved.source_branch ?? "")}\` to \`${payloadTarget}\` titled "${String(request.payload.title)}"?`,
         approvedText: `Open the PR: ${String(resolved.source_branch ?? "")} → ${payloadTarget}, "${String(request.payload.title)}".`
       };
+    case "hosting.merge":
+      return {
+        presented: `Workit decision: action — Merge \`${String(resolved.source_branch ?? "")}\` into \`${payloadTarget}\` (squash, delete branch)?`,
+        approvedText: `Merge ${String(resolved.source_branch ?? "")} → ${payloadTarget}.`
+      };
     case "changelog.apply":
       return {
         presented: `Workit decision: action — Apply changelog changes at \`${String(payload.path ?? "CHANGELOG.md")}\`?`,
@@ -17292,7 +17614,7 @@ var actionProposalQuestion = (request, descriptorPayload) => {
 var approvedResolvedExternalAction = (content) => {
   try {
     const value = JSON.parse(content);
-    if (value.operation !== "hosting.pull_request" && value.operation !== "changelog.apply" && value.operation !== "youtrack.update" && value.operation !== "youtrack.time" && value.operation !== "youtrack.meeting")
+    if (value.operation !== "hosting.pull_request" && value.operation !== "hosting.merge" && value.operation !== "changelog.apply" && value.operation !== "youtrack.update" && value.operation !== "youtrack.time" && value.operation !== "youtrack.meeting")
       return failure("invalid_input", "approved action is not a reconciliable external action");
     if (!value.payload || typeof value.payload !== "object")
       return failure("invalid_input", "approved action payload is incomplete");
@@ -17305,6 +17627,8 @@ var approvedResolvedExternalAction = (content) => {
     const target = resolved;
     if (value.operation === "hosting.pull_request" && (typeof target.marker !== "string" || typeof target.source_branch !== "string" || typeof target.source_commit !== "string" || typeof target.remote !== "string" || typeof payload.target_branch !== "string"))
       return failure("invalid_input", "approved hosting target is incomplete");
+    if (value.operation === "hosting.merge" && (typeof target.marker !== "string" || typeof target.source_branch !== "string" || typeof target.source_commit !== "string" || typeof target.remote !== "string" || typeof payload.target_branch !== "string"))
+      return failure("invalid_input", "approved hosting target is incomplete");
     if (value.operation === "changelog.apply" && (typeof target.target !== "string" || typeof target.beforeDigest !== "string" || typeof target.beforeExists !== "boolean" || typeof target.afterDigest !== "string"))
       return failure("invalid_input", "approved changelog target is incomplete");
     if (value.operation !== "hosting.pull_request" && value.operation !== "changelog.apply" && (typeof target.marker !== "string" || typeof target.baseUrl !== "string" || typeof target.issueId !== "string" || !Array.isArray(target.steps)))
@@ -17596,6 +17920,11 @@ var resolveExternalActionRequest = (root, request, preservedDateMs) => {
       }
       case "git.push": {
         const branch = request.payload.branch ?? gitValue(root, ["branch", "--show-current"]);
+        if (branch && isProtectedBranch2(root, branch))
+          return failure("invalid_input", `cannot push protected branch ${branch}`, {
+            outcome: "not_started",
+            fields: [{ path: "branch", reason: "protected branch" }]
+          });
         const commit = branch ? gitValue(root, ["rev-parse", branch]) : null;
         const remote = pushRemote(root);
         const identity = remote ? credentialFreeRemote(remote) : null;
@@ -17693,6 +18022,11 @@ var resolveExternalActionRequest = (root, request, preservedDateMs) => {
       case "hosting.pull_request": {
         const target_branch = request.payload.target_branch ?? resolveBranchPolicyFor(root).defaultTargetBranch;
         const source_branch = gitValue(root, ["branch", "--show-current"]);
+        if (source_branch && isProtectedBranch2(root, source_branch))
+          return failure("invalid_input", `cannot open a PR from protected branch ${source_branch}`, {
+            outcome: "not_started",
+            fields: [{ path: "source_branch", reason: "protected branch" }]
+          });
         const source_commit = gitValue(root, ["rev-parse", "HEAD"]);
         const remote = pushRemote(root);
         const identity = remote ? credentialFreeRemote(remote) : null;
@@ -17724,6 +18058,44 @@ var resolveExternalActionRequest = (root, request, preservedDateMs) => {
           }
         });
       }
+      case "hosting.merge": {
+        const target_branch = request.payload.target_branch ?? resolveBranchPolicyFor(root).defaultTargetBranch;
+        const source_branch = request.payload.source_branch ?? gitValue(root, ["branch", "--show-current"]);
+        if (source_branch && isProtectedBranch2(root, source_branch))
+          return failure("invalid_input", `cannot merge protected branch ${source_branch}`, {
+            outcome: "not_started",
+            fields: [{ path: "source_branch", reason: "protected branch" }]
+          });
+        const source_commit = gitValue(root, ["rev-parse", "HEAD"]);
+        const remote = pushRemote(root);
+        const identity = remote ? credentialFreeRemote(remote) : null;
+        if (!source_branch || !source_commit || !identity || remoteProvider2(identity) !== null && remoteProvider2(identity) !== String(vcsConfig("load", root).provider).toLowerCase())
+          return failure("capability_unavailable", "hosting target is not bound to the configured remote provider", { capability: "hosting.merge" });
+        const vcs = vcsConfig("load", root);
+        if (!vcs.ok || !vcs.tokenReady)
+          return failure("capability_unavailable", "hosting credentials are unavailable", {
+            capability: "hosting.merge",
+            outcome: "not_started"
+          });
+        if (!hostingCliAvailable(String(vcs.provider)))
+          return failure("capability_unavailable", "hosting CLI is unavailable", {
+            capability: "hosting.merge",
+            outcome: "not_started"
+          });
+        const normalized = {
+          operation: request.operation,
+          payload: { ...request.payload, target_branch, source_branch }
+        };
+        const marker = `<!-- workit-action:${sha256({ operation: request.operation, payload: normalized.payload, source_commit, remote: identity })} -->`;
+        return success(null, null, {
+          request: normalized,
+          marker,
+          descriptorPayload: {
+            ...normalized.payload,
+            resolved: { source_branch, source_commit, remote: identity, target_branch, marker }
+          }
+        });
+      }
       case "changelog.apply": {
         const preview = changelogApplyPreview({ ...request.payload, workspace_root: root });
         if (preview.error)
@@ -17899,6 +18271,17 @@ var executeConcreteExternalAction = async (request, root, marker, dateMs, step,
         ...request.payload.babysit ?? true ? { next: prBabysitNext(String(result.output ?? "")) } : {}
       });
     }
+    case "hosting.merge": {
+      const target = String(request.payload.target_branch ?? "");
+      const source = String(request.payload.source_branch ?? "");
+      if (!target || !source)
+        return failure("invalid_input", "hosting.merge requires target and source branches", {
+          outcome: "not_started",
+          fields: [{ path: "target_branch", reason: "required" }]
+        });
+      const result = mergePr(root, { target, source });
+      return result.error || result.ok === false ? unknown2(request.operation) : success(null, null, result);
+    }
     case "changelog.apply": {
       const preview = changelogApplyPreview({ ...request.payload, workspace_root: root });
       if (preview.error || approvedBeforeDigest !== undefined && preview.beforeDigest !== approvedBeforeDigest || approvedBeforeExists !== undefined && preview.beforeExists !== approvedBeforeExists)
@@ -18047,7 +18430,7 @@ var nativeExternalActionRunner = (root, actor, core, step) => createAuthorizedEx
   const store = new TaskStore(root);
   const selected = approvedExternalAction(store, "pi", actor, operation);
   if (!selected.ok) {
-    const plan = planCommitBinding(store, "pi", actor, operation) ?? chainStepBinding(store, "pi", actor, operation);
+    const plan = planCommitBinding(store, "pi", actor, operation) ?? chainStepBinding(store, "pi", actor, operation) ?? standingAutoBinding(core, store, "pi", actor, operation);
     if (plan) {
       const actionRef = externalActionRef("pi", actor, operation);
       return {
@@ -18189,6 +18572,7 @@ var registerWorkitTools = (pi, options = {}) => {
             "git.commit",
             "git.push",
             "hosting.pull_request",
+            "hosting.merge",
             "youtrack.update",
             "youtrack.time",
             "youtrack.meeting",
@@ -18218,7 +18602,7 @@ var registerWorkitTools = (pi, options = {}) => {
         return output(failure("permission_denied", "Pi project is not trusted for external actions"));
       if (context.workerId !== null)
         return output(failure("permission_denied", "supervised Pi children cannot run external actions"));
-      if (!ctx.hasUI)
+      if (!ctx.hasUI && !standingAutoApplies(new TaskStore(ctx.cwd), "pi", context.caller.actor, externalActionDescriptor(resolved.data.request.operation, resolved.data.descriptorPayload)))
         return output(failure("needs_input", "interactive confirmation UI is unavailable", {
           capability: "interactive_decision"
         }));
@@ -18234,6 +18618,7 @@ var registerWorkitTools = (pi, options = {}) => {
         "git.commit",
         "git.push",
         "hosting.pull_request",
+        "hosting.merge",
         "changelog.apply"
       ].includes(resolved.data.request.operation);
       if (localOperation) {
@@ -18295,6 +18680,10 @@ var registerWorkitTools = (pi, options = {}) => {
           const result = await nativeExternalActionRunner(ctx.cwd, actor, core)(descriptor, (step) => executeResolvedExternalAction(resolved.data, ctx.cwd, step, { host: "pi", actor }));
           return output(result);
         }
+        if (standingAutoApplies(store, "pi", actor, descriptor)) {
+          const result = await nativeExternalActionRunner(ctx.cwd, actor, core)(descriptor, (step) => executeResolvedExternalAction(resolved.data, ctx.cwd, step, { host: "pi", actor }));
+          return output(result);
+        }
         const prior = externalActionState(store, "pi", actor, descriptor);
         if (prior.ok && prior.data.entry.data.consumption !== null)
           return output(failure("permission_denied", "external action was already settled"));