@brainervirus/workit-codex 1.0.12 → 1.1.0

package/dist/launch-mcp.js

@@ -14199,7 +14199,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)) {
@@ -14504,7 +14510,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"]),
@@ -16580,1622 +16587,1784 @@ 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 path9 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 path8 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 readFileSync4 } 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
+import { statSync } from "node:fs";
+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) };
+};
+var markSourcesLoaded = (files, loadedAt = Date.now()) => ({
+  loadedAt,
+  files: [...files]
+});
+var changedSourcesSinceLoad = (marker) => {
+  const changed = [];
+  for (const file of marker.files) {
+    try {
+      if (statSync(file).mtimeMs > marker.loadedAt)
+        changed.push(file);
+    } catch {}
+  }
+  return changed;
+};
+
+// 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)
+  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 readFileSync2(p, "utf8");
+  } catch {
     return null;
-  return normalized;
+  }
 };
-var scopeEqual = (left, right) => canonicalJson(left) === canonicalJson(right);
-var parseSteps = (content) => {
-  let value;
+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 {
-    value = JSON.parse(content);
+    parsed = JSON.parse(raw);
   } catch {
-    return [];
+    return { status: "malformed", path: file, error: `${file} is not valid JSON` };
   }
-  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;
+  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 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 readConfigTyped = (dir) => {
+  const file = path5.join(dir ?? configDir(), "config.json");
+  return parseConfigResult(readSafe(file), file);
 };
-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 readConfig = () => {
+  const result = readConfigTyped();
+  if (result.status === "malformed")
+    throw new Error(result.error);
+  return result.config ?? DEFAULTS;
 };
-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 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 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));
-};
-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 COMMIT_PRESETS = [
+  "conventional",
+  "gitmoji",
+  "ticket-prefix",
+  "freeform",
+  "custom",
+  "auto"
+];
+
+// 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 { execFileSync as execFileSync2 } from "node:child_process";
+
+// 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)
-      });
+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 };
     }
-    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)
-      });
+    return result.stdout;
+  };
+  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 (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 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 {
+    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 } : {}
+  };
+};
+
+// 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 {
+      ok: true,
+      workspace_name: ws?.name ?? null,
+      provider,
+      defaultTargetBranch: defaultTarget,
+      link_issues: linkIssues,
+      youtrack_base_url: youtrackBaseUrl,
+      issues_provider: issuesProvider,
+      link_on_pr: linkOnPr
     };
-    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 (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
     };
-    if (!complete) {
-      outcomeResult = success(mutation.revision, input.workspaceRevision, {
-        ...entry,
-        data: settled
+  }
+  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 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)
       });
     }
-    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)
-      });
+  } 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) });
     }
-    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)]
+    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
   };
-};
-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;
+}
+
+// packages/workit-core/src/core/branch.ts
+var resolveBranchPolicyFor = (workspaceRoot) => resolveBranchPolicy(readConfig(), resolveWorkspace(workspaceRoot));
+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` };
   }
-  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") ?? "";
+  if (!login || login.toLowerCase() !== account.toLowerCase())
     return {
-      paths: [],
-      uncertain: !/not a git repository/i.test(stderr),
-      git: /not a git repository/i.test(stderr) ? false : true
+      ok: false,
+      error: `push identity ${login || "(unknown)"} does not match area account ${account}`
     };
-  }
-  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 };
+  return { ok: true };
 };
-var walk = (root, directory, output) => {
-  let names;
+
+// 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 {
-    names = fs6.readdirSync(directory);
+    const raw = readFileSync4(`${configDirPath}/workspaces.json`, "utf8");
+    return createHash3("sha256").update(raw).digest("hex");
   } catch {
-    return true;
+    return null;
   }
-  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;
+};
+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 uncertain;
+  return [...seen];
 };
-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);
+var resolveAutoApproval = (root, dir = configDir()) => {
+  let match;
+  try {
+    match = resolveWorkspaceFrom(root, dir);
+  } catch {
+    return { status: "off" };
   }
-  return success(null, null, roots);
+  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)
+  };
 };
-function captureCandidate(root, scope, environment = []) {
-  let checkout;
+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 {
-    checkout = fs6.realpathSync(root);
+    operation = typeof binding.approvedContent === "string" ? JSON.parse(binding.approvedContent).operation : null;
   } catch {
-    return failure("invalid_input", "candidate root does not exist");
+    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);
   }
-  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;
+  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)]
+  });
+};
+
+// 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 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 (!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))
+    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;
-    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";
     }
+    return null;
   }
-  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
-  };
-  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;
+  const keys = normalized.map(chainStepKey);
+  if (new Set(keys).size !== keys.length)
+    return null;
+  return normalized;
 };
-var sessionFromRef = (value) => {
-  if (typeof value !== "object" || value === null || value.kind !== "host")
+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;
-  return typeof value.host === "string" && typeof value.handle === "string" ? { host: value.host, handle: value.handle } : null;
+  const normalized = normalizeChainSteps(steps);
+  return normalized;
 };
-var sameSession = (left, right) => {
-  const other = sessionFromRef(right);
-  return left !== null && other !== null && left.host === other.host && left.handle === other.handle;
+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 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 {
-      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 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 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 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 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 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 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";
+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));
 };
-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)})`
-      };
-    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"
-    };
-  });
+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 retireNativeAuthority = (authority) => {
+  const record = verifiedAuthorities.get(authority);
+  verifiedAuthorities.delete(authority);
+  return record?.provenance ?? null;
+};
+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);
 }
-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"
+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");
+  }
+  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 = path8.resolve(root, reference.path);
+    if (target !== root && !target.startsWith(`${root}${path8.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 = path8.relative(root, target);
+      let current = root;
+      for (const segment of relative.split(path8.sep)) {
+        if (!segment)
+          continue;
+        current = path8.join(current, segment);
+        const stat = fs6.lstatSync(current);
+        const real = fs6.realpathSync(current);
+        if (real !== root && !real.startsWith(`${root}${path8.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 (!verified)
-          return failure("requirements_unsatisfied", "fixed findings require current verification");
+        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 (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");
+      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]
       }
-    }
-  }
-  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/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: []
+    ] : current.actionProgress ?? [];
+    return success(mutation.revision, null, {
+      ...current,
+      actionProgress,
+      decisions: current.decisions.map((candidate) => candidate.id === input.decisionId ? { ...candidate, data: nextDecision } : candidate)
     });
-  return success(null, null, {
-    candidate: candidate.data,
-    staleEvidenceIds,
-    workerUpdates: [],
-    blockers,
-    reassessmentRequired: view.task.policy?.policyVersion !== POLICY_VERSION
+  }, 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)
   });
 }
-var exportDigest = (bundle) => sha256({
-  schemaVersion: bundle.schemaVersion,
-  exportedAt: bundle.exportedAt,
-  sourceWorkspaceId: bundle.sourceWorkspaceId,
-  task: bundle.task
-});
-// 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 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)
     };
-  }
-};
-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 };
+    if (!complete) {
+      outcomeResult = success(mutation.revision, input.workspaceRevision, {
+        ...entry,
+        data: settled
+      });
     }
-    return result.stdout;
-  };
-  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);
+    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)
+      });
     }
-  }
-  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 {
-    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 } : {}
-  };
-};
-
-// 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
-import { statSync } from "node:fs";
-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 errorDetail = (err) => {
-  if (err instanceof Error) {
-    return { error_name: err.name, error: err.message };
-  }
-  return { error_name: "unknown", error: String(err) };
-};
-var markSourcesLoaded = (files, loadedAt = Date.now()) => ({
-  loadedAt,
-  files: [...files]
-});
-var changedSourcesSinceLoad = (marker) => {
-  const changed = [];
-  for (const file of marker.files) {
-    try {
-      if (statSync(file).mtimeMs > marker.loadedAt)
-        changed.push(file);
-    } catch {}
-  }
-  return changed;
-};
+    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/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 ?? 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;
-  }
-  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))
-      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`);
-    }
-  }
-  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 {
+// 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}${path9.sep}`);
+var relative = (root, candidate) => path9.relative(root, candidate).split(path9.sep).join("/") || ".";
+var canonicalPath = (value) => {
+  if (typeof value !== "string" || !value)
+    return null;
+  if (value.includes("\\") || value.split("/").includes(".."))
+    return null;
+  const normalized = path9.posix.normalize(value);
+  if (normalized === ".." || normalized.startsWith("../") || normalized.startsWith("/"))
     return null;
-  }
+  return normalized === "." ? "." : normalized.replace(/\/$/, "");
 };
-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";
+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 {
-    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 } : {}
-      }
-    }
+    description: scope.description,
+    paths: [...new Set(normalizedPaths)],
+    exclusions: [...new Set(normalizedExclusions)]
   };
 };
-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;
+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 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 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 COMMIT_PRESETS = [
-  "conventional",
-  "gitmoji",
-  "ticket-prefix",
-  "freeform",
-  "custom",
-  "auto"
-];
-
-// 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: [] };
+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 {
+      paths: [],
+      uncertain: !/not a git repository/i.test(stderr),
+      git: /not a git repository/i.test(stderr) ? false : true
+    };
   }
-  let parsed;
+  const paths = result.stdout ? result.stdout.toString("utf8").split("\x00").filter(Boolean).map((item) => item.split(path9.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(path9.sep).join("/")));
+  }
+  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 = path9.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 = path9.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 = path9.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;
-    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;
+    let stat;
+    try {
+      stat = fs7.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 = path9.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";
     }
   }
-  return null;
+  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 };
+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: true,
-      workspace_name: ws?.name ?? null,
-      provider,
-      defaultTargetBranch: defaultTarget,
-      link_issues: linkIssues,
-      youtrack_base_url: youtrackBaseUrl,
-      issues_provider: issuesProvider,
-      link_on_pr: linkOnPr
+      evidenceId: entry.id,
+      status: evidence.result,
+      reason: "candidate changed outside evidence scope"
     };
-  }
-  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 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 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)})`
+      };
     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"
+      requirementId: requirement.id,
+      status: unavailable ? "unavailable" : "unsatisfied",
+      evidenceIds: related.map(({ entry }) => entry.id),
+      decisionIds: [],
+      reason: unavailable ? "required capability is unavailable" : "no fresh passing evidence"
     };
-  } 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) });
+}
+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");
+      }
     }
   }
-  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
-  };
+  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/branch.ts
-var resolveBranchPolicyFor = (workspaceRoot) => resolveBranchPolicy(readConfig(), resolveWorkspace(workspaceRoot));
+// 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: []
+    });
+  return success(null, null, {
+    candidate: candidate.data,
+    staleEvidenceIds,
+    workerUpdates: [],
+    blockers,
+    reassessmentRequired: view.task.policy?.policyVersion !== POLICY_VERSION
+  });
+}
+var exportDigest = (bundle) => sha256({
+  schemaVersion: bundle.schemaVersion,
+  exportedAt: bundle.exportedAt,
+  sourceWorkspaceId: bundle.sourceWorkspaceId,
+  task: bundle.task
+});
 // packages/workit-core/src/core/external-action.ts
 var externalActionSchema = discriminatedUnion("operation", [
   object({
@@ -18229,6 +18398,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({
@@ -19342,7 +19518,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;
@@ -19357,8 +19536,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;
@@ -19390,7 +19571,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,
@@ -19421,7 +19605,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, {
@@ -20567,7 +20751,7 @@ var SUPPORT_MATRIX = {
 };
 
 // packages/workit-mcp/src/server.ts
-import { existsSync as existsSync7, readFileSync as readFileSync7, realpathSync as realpathSync7 } from "node:fs";
+import { existsSync as existsSync7, readFileSync as readFileSync8, realpathSync as realpathSync7 } from "node:fs";
 import path14 from "node:path";
 
 // node_modules/@modelcontextprotocol/sdk/node_modules/zod/v4/core/core.js
@@ -26502,7 +26686,7 @@ var hostingCliAvailable = (provider) => whichOnPath(provider === "gitlab" ? "gla
 
 // packages/workit-core/src/core/repo-context.ts
 import { spawnSync as spawnSync4 } from "node:child_process";
-import { existsSync as existsSync6, readFileSync as readFileSync6, readdirSync as readdirSync4 } from "node:fs";
+import { existsSync as existsSync6, readFileSync as readFileSync7, readdirSync as readdirSync4 } from "node:fs";
 import path12 from "node:path";
 var isSafeContextRange = (value) => value.length <= 4096 && (() => {
   try {
@@ -26672,7 +26856,7 @@ var packageScripts = (cwd, keys) => {
   if (!existsSync6(pkgPath))
     return [];
   try {
-    const pkg = JSON.parse(readFileSync6(pkgPath, "utf8"));
+    const pkg = JSON.parse(readFileSync7(pkgPath, "utf8"));
     return keys.filter((k) => pkg.scripts && typeof pkg.scripts[k] === "string").map((k) => `${k}: ${pkg.scripts?.[k]}`);
   } catch {
     return [];
@@ -26706,7 +26890,7 @@ var documentationFiles = (cwd) => {
 var readTrimmed = (file, maxLines) => {
   if (!existsSync6(file))
     return "";
-  const lines = readFileSync6(file, "utf8").split(`
+  const lines = readFileSync7(file, "utf8").split(`
 `);
   return lines.slice(0, maxLines).join(`
 `);
@@ -26894,7 +27078,7 @@ function docsRefreshContext(root, range) {
   const pkgPath = path12.join(cwd, "package.json");
   if (existsSync6(pkgPath)) {
     try {
-      const pkg = JSON.parse(readFileSync6(pkgPath, "utf8"));
+      const pkg = JSON.parse(readFileSync7(pkgPath, "utf8"));
       stdout += JSON.stringify({ name: pkg.name, version: pkg.version, scripts: pkg.scripts }, null, 2) + `
 `;
     } catch {}
@@ -27592,7 +27776,7 @@ var TOOL_CAPABILITIES = [
 ];
 var VERSION = (() => {
   try {
-    const packageJson = JSON.parse(readFileSync7(new URL("../package.json", import.meta.url), "utf8"));
+    const packageJson = JSON.parse(readFileSync8(new URL("../package.json", import.meta.url), "utf8"));
     return typeof packageJson.version === "string" ? packageJson.version : "0.0.0";
   } catch {
     return "0.0.0";