@brainervirus/workit-cli 1.0.12 → 1.1.0

package/dist/index.js

@@ -50732,7 +50732,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)) {
@@ -51037,7 +51043,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"]),
@@ -56736,7 +56743,7 @@ async function runCutoverCommand(argv, deps = {}) {
 }
 
 // packages/workit-cli/src/task.ts
-import { readFileSync as readFileSync18 } from "node:fs";
+import { readFileSync as readFileSync19 } from "node:fs";
 import { createInterface as createInterface2 } from "node:readline/promises";
 
 // packages/workit-core/src/core.ts
@@ -58285,1727 +58292,1967 @@ function assertProductWriteAllowed(input) {
 }
 
 // packages/workit-core/src/core/task-evaluation.ts
+import { createHash as createHash8 } from "node:crypto";
+import * as fs10 from "node:fs";
+import { spawnSync as spawnSync4 } from "node:child_process";
+import path23 from "node:path";
+
+// packages/workit-core/src/core/authority.ts
 import { createHash as createHash7 } from "node:crypto";
 import * as fs9 from "node:fs";
-import { spawnSync as spawnSync3 } from "node:child_process";
-import path21 from "node:path";
+import path22 from "node:path";
 
-// packages/workit-core/src/core/authority.ts
+// packages/workit-core/src/core/auto-approval.ts
 import { createHash as createHash6 } from "node:crypto";
-import * as fs8 from "node:fs";
-import path20 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;
+import { readFileSync as readFileSync15 } from "node:fs";
+
+// packages/workit-core/src/core/branch.ts
+import { existsSync as existsSync15, mkdirSync as mkdirSync8, readFileSync as readFileSync14, writeFileSync as writeFileSync10 } from "node:fs";
+import { execFileSync as execFileSync3 } from "node:child_process";
+import path21 from "node:path";
+
+// packages/workit-core/src/core/git.ts
+import { execFileSync as execFileSync2 } from "node:child_process";
+var run = (cwd, args) => {
+  try {
+    const stdout = execFileSync2("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
+    };
+  }
 };
-var chainStepKey = (step) => step.kind === "commit" ? step.message : step.kind === "branch" ? `branch:${step.target}` : "pr";
-var isRecord4 = (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 (!isRecord4(step))
-      return null;
-    if (typeof step.branch === "string" && step.branch.trim() && Object.keys(step).length === 1) {
-      normalized.push({ kind: "branch", target: step.branch });
-      continue;
+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 (step.pr === true && Object.keys(step).length === 1) {
-      normalized.push({ kind: "pr" });
-      continue;
+    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 null;
   }
-  const keys = normalized.map(chainStepKey);
-  if (new Set(keys).size !== keys.length)
+  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 fs8 from "node:fs";
+import path20 from "node:path";
+import { spawnSync as spawnSync3 } from "node:child_process";
+var TOKEN_PLACEHOLDER3 = "YOUR_TOKEN_HERE";
+var vcsConfigPath = () => process.env.WORKFLOW_VCS_CONFIG ?? path20.join(configDir(), "vcs.json");
+var vcsCwd = (cwd) => cwd ?? process.env.WORKFLOW_WORKSPACE_ROOT ?? process.cwd();
+var remoteProvider = (cwd) => {
+  const r = spawnSync3("git", ["remote", "get-url", "origin"], { cwd, encoding: "utf8" });
+  if (r.status !== 0)
     return null;
-  return normalized;
+  const url = (r.stdout ?? "").trim();
+  if (/github\.com[:/]/.test(url))
+    return "github";
+  if (/gitlab\.com[:/]/.test(url))
+    return "gitlab";
+  return null;
 };
-var scopeEqual = (left, right) => canonicalJson(left) === canonicalJson(right);
-var parseSteps = (content) => {
-  let value;
+var readVcsConfig = () => {
+  const file = vcsConfigPath();
+  let raw;
   try {
-    value = JSON.parse(content);
+    raw = fs8.readFileSync(file, "utf8");
   } catch {
-    return [];
+    return { status: "missing", path: file, config: {} };
   }
-  if (typeof value !== "object" || value === null || !("steps" in value))
-    return [];
-  const steps = value.steps;
-  if (!Array.isArray(steps))
-    return null;
-  const normalized = normalizeChainSteps(steps);
-  return normalized;
-};
-var decisionMatches = (entry, purpose, binding) => {
-  const decision = entry.data;
-  return binding.taskId === decision.binding.taskId && binding.workspaceId === decision.binding.workspaceId && decision.purpose === purpose && decision.response === "approved" && decision.revoked === null && (purpose !== "action" || decision.consumption === null) && decision.digest === decisionDigest(decision) && scopeEqual(decision.binding.scope, binding.scope) && canonicalJson(decision.binding) === canonicalJson(binding);
-};
-var sameRef = (left, right) => canonicalJson(left) === canonicalJson(right);
-var validProvenance = (value, caller) => {
-  if (!provenanceSchema.safeParse(value).success)
-    return false;
-  const provenance = value;
-  return provenance.kind === "host_observed" && provenance.host === caller.host && provenance.session?.kind === "host" && provenance.session.host === caller.host && provenance.session.handle === caller.actor && provenance.receipts.some((receipt) => receipt.kind === "host" && receipt.host === caller.host);
-};
-var verifyNativeDecision = (verifier, input, binding) => {
-  if (!verifier)
-    return failure("permission_denied", "native authority verifier is unavailable");
-  const result = verifier.verifyDecision(input);
-  if (!result.ok || !validProvenance(result.data, input.caller))
-    return failure("permission_denied", "native decision observation was not attested");
-  return success(null, null, trustedAuthority("decision", result.data, {
-    taskId: input.expected.taskId,
-    workspaceId: input.expected.workspaceId,
-    purpose: input.expected.purpose,
-    response: input.expected.response,
-    binding: input.expected.binding,
-    bindingBytes: input.expected.bindingBytes,
-    digest: input.expected.digest,
-    requirementIds: [...input.expected.requirementIds]
-  }, binding, input.caller));
-};
-var verifyNativeAction = (verifier, input, binding) => {
-  if (!verifier)
-    return failure("permission_denied", "native authority verifier is unavailable");
-  const result = verifier.verifyAction(input);
-  if (!result.ok || !validProvenance(result.data, input.caller))
-    return failure("permission_denied", "native action observation was not attested");
-  return success(null, null, trustedAuthority("action", result.data, {
-    taskId: input.expected.taskId,
-    workspaceId: input.expected.workspaceId,
-    decisionId: input.expected.decisionId,
-    actionRef: input.expected.actionRef,
-    taskRevision: input.expected.taskRevision,
-    workspaceRevision: input.expected.workspaceRevision,
-    outcome: input.expected.outcome,
-    purpose: input.expected.decision.purpose,
-    response: input.expected.decision.response,
-    binding: input.expected.decision.binding,
-    digest: input.expected.decision.digest,
-    requirementIds: [...input.expected.decision.requirementIds]
-  }, binding, input.caller));
-};
-var verifyNativeReconciliation = (verifier, input, binding) => {
-  if (!verifier?.verifyReconciliation)
-    return failure("permission_denied", "native reconciliation authority is unavailable");
-  const result = verifier.verifyReconciliation(input);
-  if (!result.ok || !validProvenance(result.data, input.caller))
-    return failure("permission_denied", "native reconciliation observation was not attested");
-  return success(null, null, trustedAuthority("reconciliation", result.data, {
-    taskId: input.expected.taskId,
-    workspaceId: input.expected.workspaceId,
-    decisionId: input.expected.decisionId,
-    actionRef: input.expected.actionRef,
-    taskRevision: input.expected.taskRevision,
-    workspaceRevision: input.expected.workspaceRevision,
-    outcome: input.expected.outcome,
-    evidenceDigest: input.expected.evidenceDigest,
-    step: input.expected.step,
-    purpose: input.expected.decision.purpose,
-    response: input.expected.decision.response,
-    binding: input.expected.decision.binding,
-    digest: input.expected.decision.digest,
-    requirementIds: [...input.expected.decision.requirementIds]
-  }, binding, input.caller));
-};
-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);
-}
-var digestBytes3 = (bytes) => createHash6("sha256").update(bytes).digest("hex");
-var verifyDecisionContentAtRoot = (checkoutRoot, binding) => {
-  let root;
+  let parsed;
   try {
-    root = fs8.realpathSync(checkoutRoot);
+    parsed = JSON.parse(raw);
   } catch {
-    return failure("permission_denied", "checkout root is unavailable");
+    return { status: "malformed", path: file, config: {}, error: `${file} is not valid JSON` };
   }
-  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 = path20.resolve(root, reference.path);
-    if (target !== root && !target.startsWith(`${root}${path20.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 = path20.relative(root, target);
-      let current = root;
-      for (const segment of relative.split(path20.sep)) {
-        if (!segment)
-          continue;
-        current = path20.join(current, segment);
-        const stat = fs8.lstatSync(current);
-        const real = fs8.realpathSync(current);
-        if (real !== root && !real.startsWith(`${root}${path20.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 (digestBytes3(fs8.readFileSync(target)) !== reference.digest)
-        return failure("permission_denied", "approved document bytes have changed");
-    } catch {
-      return failure("invalid_input", "approved document is unavailable");
-    }
+  if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+    return { status: "valid", path: file, config: parsed };
   }
-  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");
-  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 });
+  return { status: "malformed", path: file, config: {}, error: `${file} is not a JSON object` };
 };
-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 }
+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 ?? [];
-    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: []
+  }
+  if (cfgStatus === "malformed") {
+    return { ok: false, error: cfgError, configPath: cfgPath };
+  }
+  if (cfgStatus === "missing") {
+    return { ok: false, error: `vcs.json is missing: ${cfgPath}`, configPath: cfgPath };
+  }
+  if (provider === null) {
+    return {
+      ok: false,
+      error: `no vcs provider configured (set vcs.provider in ${cfgPath}, match a workspace entry, or run inside a checkout with a recognized origin remote)`,
+      configPath: cfgPath
+    };
+  }
+  const prov = cfg[provider] ?? {};
+  const wsTokenFile = typeof wsVcs.tokenFile === "string" && wsVcs.tokenFile.trim() !== "" ? wsVcs.tokenFile : null;
+  const tokenFile = String(wsTokenFile ?? prov.tokenFile ?? path20.join(configDir(), `${provider}.token`));
+  const tokenPath = path20.resolve(tokenFile);
+  let tokenOk = false;
+  if (fs8.existsSync(tokenPath)) {
+    const token = fs8.readFileSync(tokenPath, "utf8").trim();
+    const placeholder = !token || token === TOKEN_PLACEHOLDER3 || token.startsWith(TOKEN_PLACEHOLDER3);
+    tokenOk = !placeholder;
+  }
+  const out = {
+    ok: true,
+    configPath: path20.resolve(cfgPath),
+    provider,
+    defaultTargetBranch: defaultTarget,
+    pr: cfg.pr ?? {},
+    tokenPath,
+    tokenPresent: fs8.existsSync(tokenPath),
+    tokenReady: tokenOk,
+    workspace_name: ws?.name ?? null,
+    link_issues: linkIssues,
+    youtrack_base_url: youtrackBaseUrl,
+    issues_provider: issuesProvider,
+    link_on_pr: linkOnPr
   };
-  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)
-  });
+  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 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)
-      });
+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 = fs8.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 = spawnSync3("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) => spawnSync3("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 (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 (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)
       });
     }
-    if (currentStep)
-      workflow.completed.push(currentStep);
-    const complete = !workflow.steps.length || workflow.completed.length >= workflow.steps.length;
-    const settled = {
-      ...entry.data,
-      consumption: complete ? { ...entry.data.consumption, state: "consumed", at: mutation.now } : null
-    };
-    const actionProgress = workflow.steps.length ? [
-      ...(current.actionProgress ?? []).filter((progress) => progress.decisionId !== input.decisionId),
-      {
-        decisionId: input.decisionId,
-        steps: [...workflow.steps],
-        completedSteps: [...workflow.completed]
-      }
-    ] : current.actionProgress ?? [];
-    const next = {
-      ...current,
-      actionProgress,
-      decisions: current.decisions.map((candidate) => candidate.id === input.decisionId ? { ...candidate, data: settled } : candidate)
-    };
-    if (!complete) {
-      outcomeResult = success(mutation.revision, input.workspaceRevision, {
-        ...entry,
-        data: settled
-      });
+  } else if (provider === "github") {
+    const r = spawnSync3("gh", ["pr", "list", "--state", "merged", "--limit", String(limit), "--json", "title,url,body"], { cwd, encoding: "utf8", env: { ...process.env, GH_TOKEN: token } });
+    if (r.status !== 0)
+      return { ok: false, error: "could not list pull requests" };
+    for (const pr of JSON.parse(r.stdout ?? "[]")) {
+      const desc = String(pr.body ?? "").trim();
+      examples.push({ title: pr.title, url: pr.url, ...descInfo(desc) });
     }
-    return 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);
+  }
+  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
+  };
 }
-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)
+
+// packages/workit-core/src/core/branch.ts
+var resolveBranchPolicyFor = (workspaceRoot) => resolveBranchPolicy(readConfig(), resolveWorkspace(workspaceRoot));
+var resolveCommitPolicyFor = (workspaceRoot) => resolveCommitPolicy(readConfig(), resolveWorkspace(workspaceRoot));
+var policy = (root) => resolveBranchPolicyFor(root);
+var allowedBranch = (root, name) => policy(root).allowed.some((r) => r.test(name));
+var isProtected = (root, name) => policy(root).protected.has(name.toLowerCase());
+var verifyPushIdentity = (root, provider, account) => {
+  if (!account || typeof account !== "string")
+    return { ok: false, error: "push identity requires a configured area account" };
+  const probe = provider === "gitlab" ? ["api", "user", "--jq", ".username"] : ["api", "user", "--jq", ".login"];
+  const bin = provider === "gitlab" ? "glab" : "gh";
+  let login;
+  try {
+    login = execFileSync3(bin, [...probe], {
+      cwd: root,
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+  } catch {
+    return { ok: false, error: `${bin} identity could not be resolved` };
+  }
+  if (!login || login.toLowerCase() !== account.toLowerCase())
+    return {
+      ok: false,
+      error: `push identity ${login || "(unknown)"} does not match area account ${account}`
+    };
+  return { ok: true };
+};
+var baseBranch = (cwd) => {
+  const resolved = vcsConfig("resolve", cwd);
+  if (resolved.ok === false)
+    return { error: String(resolved.error) };
+  return { base: String(resolved.defaultTargetBranch ?? "develop") };
+};
+var originBaseReady = (cwd, base) => {
+  const run = (args) => execFileSync3("git", args, { cwd, encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] });
+  try {
+    try {
+      run(["fetch", "origin", base, "--prune"]);
+    } catch {
+      run(["fetch", "origin", "--prune"]);
+    }
+    try {
+      execFileSync3("git", ["show-ref", "--verify", "--quiet", `refs/remotes/origin/${base}`], {
+        cwd,
+        stdio: "pipe"
       });
+    } catch {
+      return {
+        ok: false,
+        error: `origin/${base} missing — push ${base} before creating feature/* or bugfix/* branches`
+      };
     }
-    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
+    return { ok: true };
+  } catch (error) {
+    return {
+      ok: false,
+      error: error instanceof Error ? error.message : "ensure-base-branch failed"
     };
-    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 digestBytes4 = (value) => createHash7("sha256").update(value).digest("hex");
-var inside = (root, candidate) => candidate === root || candidate.startsWith(`${root}${path21.sep}`);
-var relative = (root, candidate) => path21.relative(root, candidate).split(path21.sep).join("/") || ".";
-var canonicalPath = (value) => {
-  if (typeof value !== "string" || !value)
-    return null;
-  if (value.includes("\\") || value.split("/").includes(".."))
-    return null;
-  const normalized = path21.posix.normalize(value);
-  if (normalized === ".." || normalized.startsWith("../") || normalized.startsWith("/"))
-    return null;
-  return normalized === "." ? "." : normalized.replace(/\/$/, "");
+  }
 };
-var canonicalScope = (scope) => {
-  const paths = scope.paths.length ? scope.paths : ["."];
-  const normalizedPaths = paths.map(canonicalPath);
-  const normalizedExclusions = scope.exclusions.map(canonicalPath);
-  if (normalizedPaths.some((value) => value === null) || normalizedExclusions.some((value) => value === null))
-    return null;
-  return {
-    description: scope.description,
-    paths: [...new Set(normalizedPaths)],
-    exclusions: [...new Set(normalizedExclusions)]
-  };
+var fastForwardBase = (cwd, base) => {
+  const run = (args) => execFileSync3("git", args, { cwd, encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] });
+  try {
+    let hasLocalBase = true;
+    try {
+      execFileSync3("git", ["show-ref", "--verify", "--quiet", `refs/heads/${base}`], {
+        cwd,
+        stdio: "pipe"
+      });
+    } catch {
+      hasLocalBase = false;
+    }
+    if (hasLocalBase) {
+      run(["checkout", base]);
+      try {
+        run(["merge", "--ff-only", `origin/${base}`]);
+      } catch {}
+    } else {
+      run(["checkout", "-b", base, "--track", `origin/${base}`]);
+    }
+    return { ok: true };
+  } catch (error) {
+    return {
+      ok: false,
+      error: error instanceof Error ? error.message : "ensure-base-branch failed"
+    };
+  }
 };
-var 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 ensureBaseBranch = (cwd, base) => {
+  const git = gitContext(cwd);
+  if (!git.branch || git.branch === "unknown")
+    return { ok: false, error: "not in a git repository" };
+  const ready = originBaseReady(cwd, base);
+  if (!ready.ok)
+    return ready;
+  return fastForwardBase(cwd, base);
 };
-var 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;
+var classifyBranchDirt = (workspaceRoot) => {
+  let raw;
+  try {
+    raw = execFileSync3("git", ["status", "--porcelain=v1"], {
+      cwd: path21.resolve(workspaceRoot),
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+  } catch {
+    return "clean";
   }
-  return left.length - right.length;
+  let dirty = false;
+  for (const line of raw.split(`
+`)) {
+    if (!line.trim())
+      continue;
+    dirty = true;
+    const code = line.slice(0, 2);
+    if (code === "??")
+      continue;
+    let entry = line.slice(3);
+    const arrow = entry.indexOf(" -> ");
+    if (arrow >= 0)
+      entry = entry.slice(arrow + 4);
+    const unquoted = entry.startsWith('"') && entry.endsWith('"') ? entry.slice(1, -1) : entry;
+    if (unquoted !== "docs" && !unquoted.startsWith("docs/"))
+      return "stash-required";
+  }
+  return dirty ? "carry" : "clean";
 };
-var gitPaths = (root) => {
-  const result = spawnSync3("git", ["ls-files", "-z", "--cached", "--others", "--exclude-standard"], {
-    cwd: root,
-    encoding: "buffer"
-  });
-  if (result.status !== 0) {
-    const stderr = result.stderr?.toString("utf8") ?? "";
+var branchSetup = ({
+  action,
+  sdd_dir,
+  target_branch,
+  stash,
+  workspace_root,
+  log
+}) => {
+  const cwd = path21.resolve(workspace_root);
+  const exec = (args) => execFileSync3("git", args, { cwd, encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] });
+  const current = gitContext(cwd).branch;
+  if (!current || current === "unknown")
+    return { error: "not in a git repository", phase: "preflight" };
+  const sdd = sdd_dir ?? "docs";
+  const manifestPath = path21.isAbsolute(sdd) ? path21.join(sdd, "manifest.json") : path21.join(cwd, sdd, "manifest.json");
+  const ensureManifestDir = () => {
+    const dir = path21.dirname(manifestPath);
+    if (!existsSync15(dir))
+      mkdirSync8(dir, { recursive: true, mode: 493 });
+  };
+  const readManifest = () => {
+    try {
+      return JSON.parse(readFileSync14(manifestPath, "utf8"));
+    } catch {
+      return {};
+    }
+  };
+  const writeManifest = (data) => {
+    ensureManifestDir();
+    writeFileSync10(manifestPath, JSON.stringify(data, null, 2) + `
+`, "utf8");
+  };
+  const journal = (message) => log?.(`branch-setup: ${message}`);
+  if (action === "reapply_stash") {
+    const manifest = readManifest();
+    const ref = manifest.stash_ref;
+    if (!ref)
+      return { error: "no stash_ref in manifest", phase: "preflight" };
+    journal(`pre-pop: ${String(ref)}`);
+    try {
+      exec(["stash", "pop", String(ref)]);
+    } catch (error) {
+      journal("pop: failed");
+      return {
+        error: error instanceof Error ? error.message : "stash pop failed",
+        phase: "post_mutation"
+      };
+    }
+    journal("pop: ok");
+    delete manifest.stash_ref;
+    delete manifest.stash_created_at;
+    writeManifest(manifest);
+    return { action: "reapply_stash", ok: true };
+  }
+  const target = target_branch ?? "";
+  if (!target)
     return {
-      paths: [],
-      uncertain: !/not a git repository/i.test(stderr),
-      git: /not a git repository/i.test(stderr) ? false : true
+      error: "target_branch (the working branch to create or switch to) is required for setup",
+      phase: "preflight"
+    };
+  if (isProtected(cwd, target))
+    return { error: `protected branch ${target}`, phase: "preflight" };
+  if (!allowedBranch(cwd, target))
+    return {
+      error: `target branch ${target} is not allowed by the branch policy`,
+      phase: "preflight"
     };
+  let base;
+  let targetExists = true;
+  try {
+    exec(["rev-parse", "--verify", "--quiet", `refs/heads/${target}`]);
+  } catch {
+    targetExists = false;
+  }
+  if (!targetExists) {
+    const baseResolved = baseBranch(cwd);
+    if ("error" in baseResolved)
+      return { error: baseResolved.error, phase: "preflight" };
+    base = baseResolved.base;
+  }
+  journal(`entry: current=${current} target=${target} base=${base ?? "-"}`);
+  let stash_ref;
+  const failAfterStash = (message, phase = "post_mutation") => {
+    let suffix = "";
+    if (stash_ref) {
+      journal(`pre-pop: ${stash_ref}`);
+      try {
+        exec(["stash", "pop", stash_ref]);
+        stash_ref = undefined;
+        journal("pop: ok");
+      } catch {
+        journal("pop: failed");
+        suffix = " (changes preserved in stash)";
+      }
+    }
+    return { error: `${message}${suffix}`, phase: stash_ref ? "post_mutation" : phase };
+  };
+  if (current !== target) {
+    const dirty = Boolean(gitContext(cwd).status_short.trim());
+    if (classifyBranchDirt(cwd) === "stash-required" && stash !== "yes") {
+      return {
+        error: "dirty working tree — ask with native question, then call workit_branch_setup with stash=yes",
+        phase: "preflight"
+      };
+    }
+    let validatedBase;
+    if (!targetExists && base !== undefined) {
+      const ready = originBaseReady(cwd, base);
+      if (!ready.ok)
+        return { error: ready.error ?? "ensure-base-branch failed", phase: "preflight" };
+      validatedBase = base;
+    }
+    if (dirty && stash === "yes") {
+      try {
+        exec(["stash", "push", "-u", "-m", `workit: pre-checkout ${target}`]);
+      } catch (error) {
+        return {
+          error: error instanceof Error ? error.message : "stash push failed",
+          phase: "post_mutation"
+        };
+      }
+      stash_ref = "stash@{0}";
+      journal(`stash push: ${stash_ref}`);
+    }
+    try {
+      exec(["checkout", target]);
+      journal("post-checkout");
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "checkout failed";
+      if (/worktree/i.test(message)) {
+        return failAfterStash(`branch ${target} is locked by an existing git worktree — remove it first (we do not use worktrees)`, "preflight");
+      }
+      try {
+        let effectiveBase = base;
+        if (effectiveBase === undefined) {
+          const lateResolved = baseBranch(cwd);
+          if ("error" in lateResolved)
+            return failAfterStash(lateResolved.error, "preflight");
+          effectiveBase = lateResolved.base;
+        }
+        const baseResult = validatedBase !== undefined ? fastForwardBase(cwd, effectiveBase) : ensureBaseBranch(cwd, effectiveBase);
+        if (!baseResult.ok)
+          return failAfterStash(baseResult.error ?? "ensure-base-branch failed");
+        exec(["checkout", "-b", target]);
+        journal("post-create");
+      } catch (createError) {
+        return failAfterStash(createError instanceof Error ? createError.message : "branch create failed");
+      }
+    }
   }
-  const paths = result.stdout ? result.stdout.toString("utf8").split("\x00").filter(Boolean).map((item) => item.split(path21.sep).join("/")) : [];
-  const stagedDeleted = spawnSync3("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(path21.sep).join("/")));
+  try {
+    const manifest = readManifest();
+    manifest.branch = target;
+    manifest.previous_branch = current;
+    if (stash_ref) {
+      manifest.stash_ref = stash_ref;
+      manifest.stash_created_at = new Date().toISOString();
+    }
+    writeManifest(manifest);
+  } catch (error) {
+    const result = failAfterStash(error instanceof Error ? `manifest update failed: ${error.message}` : "manifest update failed");
+    if (stash_ref === undefined && gitContext(cwd).branch !== current) {
+      try {
+        exec(["checkout", current]);
+      } catch {
+        try {
+          exec(["checkout", "-m", current]);
+        } catch {}
+      }
+    }
+    return result;
   }
-  return { paths: [...new Set(paths)], uncertain: false, git: true };
+  return {
+    action: "setup",
+    ok: true,
+    branch: target,
+    previous_branch: current,
+    stash_ref: stash_ref ?? null,
+    manifest: manifestPath
+  };
 };
-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 = fs9.readdirSync(directory);
+    const raw = readFileSync15(`${configDirPath}/workspaces.json`, "utf8");
+    return createHash6("sha256").update(raw).digest("hex");
   } catch {
-    return true;
-  }
-  let uncertain = false;
-  for (const name of names) {
-    if (name === ".git" || name === ".workit")
-      continue;
-    const target = path21.join(directory, name);
-    let stat;
-    try {
-      stat = fs9.lstatSync(target);
-    } catch {
-      uncertain = true;
-      continue;
-    }
-    const item = relative(root, target);
-    output.add(item);
-    if (stat.isDirectory() && !stat.isSymbolicLink())
-      uncertain = walk(root, target, output) || uncertain;
+    return null;
   }
-  return uncertain;
 };
-var scopeRoots = (root, scope) => {
-  const roots = [];
-  for (const item of scope.paths.length ? scope.paths : ["."]) {
-    const target = path21.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 (!fs9.existsSync(ancestor) && ancestor !== root)
-      ancestor = path21.dirname(ancestor);
-    try {
-      if (!inside(root, fs9.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 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 success(null, null, roots);
+  return [...seen];
 };
-function captureCandidate(root, scope, environment = []) {
-  let checkout;
+var resolveAutoApproval = (root, dir = configDir()) => {
+  let match;
   try {
-    checkout = fs9.realpathSync(root);
+    match = resolveWorkspaceFrom(root, dir);
   } catch {
-    return failure("invalid_input", "candidate root does not exist");
-  }
-  const normalizedScope = canonicalScope(scope);
-  if (!normalizedScope)
-    return failure("invalid_input", "candidate scope is invalid: paths must be checkout-relative — to work in another repository, keep this task here and coordinate a separate linked task in that checkout", { fields: [{ path: "scope.paths", reason: "must be checkout-relative" }] });
-  const roots = scopeRoots(checkout, normalizedScope);
-  if (!roots.ok)
-    return roots;
-  const git = gitPaths(checkout);
-  const names = new Set;
-  let uncertain = git.uncertain;
-  for (const target of roots.data) {
-    const item = relative(checkout, target);
-    if (item === ".git" || item === ".workit")
-      continue;
-    names.add(item);
-    if (!fs9.existsSync(target))
-      continue;
-    let stat;
-    try {
-      stat = fs9.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 = path21.join(checkout, item);
-    try {
-      const stat = fs9.lstatSync(target);
-      if (stat.isSymbolicLink()) {
-        const link = fs9.readlinkSync(target);
-        files.push({ path: item, kind: "symlink", digest: digestBytes4(link), executable: null });
-      } else if (stat.isFile()) {
-        files.push({
-          path: item,
-          kind: "file",
-          digest: digestBytes4(fs9.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 { status: "off" };
   }
-  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 = spawnSync3("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
+  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)
   };
-  const candidate = { ...partial, id: candidateDigest(partial) };
-  const parsed = candidateSchema.safeParse(candidate);
-  return parsed.success ? success(null, null, parsed.data) : failure("invalid_input", "captured candidate is invalid");
-}
-var fileMap = (candidate) => new Map(candidate.files.map((file) => [file.path, file]));
-var changedPaths = (before, after) => {
-  const paths = new Set([...before.files, ...after.files].map((file) => file.path));
-  const left = fileMap(before);
-  const right = fileMap(after);
-  const changed = [...paths].filter((item) => JSON.stringify(left.get(item) ?? null) !== JSON.stringify(right.get(item) ?? null));
-  if (before.head !== after.head)
-    changed.push(".");
-  if (JSON.stringify(before.environment) !== JSON.stringify(after.environment))
-    changed.push(".");
-  return changed;
 };
-var sessionFromRef = (value) => {
-  if (typeof value !== "object" || value === null || value.kind !== "host")
-    return null;
-  return typeof value.host === "string" && typeof value.handle === "string" ? { host: value.host, handle: value.handle } : null;
+var autoApproves = (root, cls, dir) => {
+  if (typeof cls !== "string" || !AUTO_CLASSES.includes(cls))
+    return false;
+  const resolved = resolveAutoApproval(root, dir);
+  return resolved.status === "on" && resolved.classes.includes(cls);
 };
-var sameSession = (left, right) => {
-  const other = sessionFromRef(right);
-  return left !== null && other !== null && left.host === other.host && left.handle === other.handle;
+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 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 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 {
+    operation = typeof binding.approvedContent === "string" ? JSON.parse(binding.approvedContent).operation : null;
+  } catch {
+    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);
+  }
+  return success(null, null, {
+    kind: "host_observed",
+    host: caller.host,
+    session: { kind: "host", host: caller.host, handle: caller.actor },
+    workerId: null,
+    receipts: [standingReceiptFor(root, standing.workspace, cls)]
   });
-}
-var 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;
+var standingAutoApplies = (store, host, actor, operation) => {
+  let descriptor;
+  try {
+    descriptor = JSON.parse(operation);
+  } catch {
+    return null;
+  }
+  const cls = operationAutoClass(descriptor.operation);
+  if (!cls || !autoApproves(store.root, cls))
+    return null;
+  const listed = store.listTasks();
+  const workspace = store.readWorkspace();
+  if (!listed.ok || !workspace.ok || !workspace.data)
+    return null;
+  const matches = listed.data.filter((task) => task.status === "active" && task.workspaceId === workspace.data.id && task.intent?.provenance?.session?.kind === "host" && task.intent.provenance.session.host === host && task.intent.provenance.session.handle === actor);
+  if (matches.length !== 1)
+    return null;
+  const resolved = resolveAutoApproval(store.root);
+  if (resolved.status !== "on")
+    return null;
   return {
-    beforeCandidateId: evidence.beforeCandidateId ?? fallback,
-    candidateId: evidence.candidateId ?? fallback
+    task: matches[0],
+    workspaceId: workspace.data.id,
+    workspaceRevision: workspace.data.revision,
+    cls,
+    workspaceName: resolved.workspace
   };
 };
-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 standingAutoBinding = (core, store, host, actor, operation) => {
+  let descriptor;
+  try {
+    descriptor = JSON.parse(operation);
+  } catch {
+    return null;
+  }
+  const cls = operationAutoClass(descriptor.operation);
+  if (!cls || !autoApproves(store.root, cls))
+    return null;
+  const applies = standingAutoApplies(store, host, actor, operation);
+  if (!applies)
+    return null;
+  const { task } = applies;
+  const resolved = resolveAutoApproval(store.root);
+  if (resolved.status !== "on")
+    return null;
+  const presented = `Workit decision: action — auto-approved ${String(descriptor.operation)} ` + `under workspace rule "${resolved.workspace}" (no question asked).`;
+  const recorded = core.observeStandingDecision({
+    schemaVersion: 1,
+    action: "record",
+    taskId: task.id,
+    expectedRevision: task.revision,
+    purpose: "action",
+    binding: {
+      taskId: task.id,
+      workspaceId: applies.workspaceId,
+      scope: task.intent.data.scope,
+      presented,
+      approvedContent: operation,
+      contentRefs: [],
+      standing: { workspace: resolved.workspace, class: cls }
+    },
+    response: "approved",
+    requirementIds: []
+  });
+  if (!recorded.ok)
+    return null;
+  const fresh = store.readTask(task.id);
+  if (!fresh.ok)
+    return null;
+  return {
+    taskId: task.id,
+    decisionId: recorded.data.id,
+    binding: recorded.data.data.binding,
+    expectedRevision: fresh.data.revision,
+    expectedWorkspaceRevision: applies.workspaceRevision
+  };
 };
-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";
+
+// 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;
 };
-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"
-        };
+var chainStepKey = (step) => step.kind === "commit" ? step.message : step.kind === "branch" ? `branch:${step.target}` : "pr";
+var isRecord4 = (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 (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"
-        };
+    if (!isRecord4(step))
+      return null;
+    if (typeof step.branch === "string" && step.branch.trim() && Object.keys(step).length === 1) {
+      normalized.push({ kind: "branch", target: step.branch });
+      continue;
     }
-    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"
-    };
-  });
+    if (step.pr === true && Object.keys(step).length === 1) {
+      normalized.push({ kind: "pr" });
+      continue;
+    }
+    return null;
+  }
+  const keys = normalized.map(chainStepKey);
+  if (new Set(keys).size !== keys.length)
+    return null;
+  return normalized;
+};
+var scopeEqual = (left, right) => canonicalJson(left) === canonicalJson(right);
+var parseSteps = (content) => {
+  let value;
+  try {
+    value = JSON.parse(content);
+  } catch {
+    return [];
+  }
+  if (typeof value !== "object" || value === null || !("steps" in value))
+    return [];
+  const steps = value.steps;
+  if (!Array.isArray(steps))
+    return null;
+  const normalized = normalizeChainSteps(steps);
+  return normalized;
+};
+var decisionMatches = (entry, purpose, binding) => {
+  const decision = entry.data;
+  return binding.taskId === decision.binding.taskId && binding.workspaceId === decision.binding.workspaceId && decision.purpose === purpose && decision.response === "approved" && decision.revoked === null && (purpose !== "action" || decision.consumption === null) && decision.digest === decisionDigest(decision) && scopeEqual(decision.binding.scope, binding.scope) && canonicalJson(decision.binding) === canonicalJson(binding);
+};
+var sameRef = (left, right) => canonicalJson(left) === canonicalJson(right);
+var validProvenance = (value, caller) => {
+  if (!provenanceSchema.safeParse(value).success)
+    return false;
+  const provenance = value;
+  return provenance.kind === "host_observed" && provenance.host === caller.host && provenance.session?.kind === "host" && provenance.session.host === caller.host && provenance.session.handle === caller.actor && provenance.receipts.some((receipt) => receipt.kind === "host" && receipt.host === caller.host);
+};
+var verifyNativeDecision = (verifier, input, binding) => {
+  if (!verifier)
+    return failure("permission_denied", "native authority verifier is unavailable");
+  const result = verifier.verifyDecision(input);
+  if (!result.ok || !validProvenance(result.data, input.caller))
+    return failure("permission_denied", "native decision observation was not attested");
+  return success(null, null, trustedAuthority("decision", result.data, {
+    taskId: input.expected.taskId,
+    workspaceId: input.expected.workspaceId,
+    purpose: input.expected.purpose,
+    response: input.expected.response,
+    binding: input.expected.binding,
+    bindingBytes: input.expected.bindingBytes,
+    digest: input.expected.digest,
+    requirementIds: [...input.expected.requirementIds]
+  }, binding, input.caller));
+};
+var verifyNativeAction = (verifier, input, binding) => {
+  if (!verifier)
+    return failure("permission_denied", "native authority verifier is unavailable");
+  const result = verifier.verifyAction(input);
+  if (!result.ok || !validProvenance(result.data, input.caller))
+    return failure("permission_denied", "native action observation was not attested");
+  return success(null, null, trustedAuthority("action", result.data, {
+    taskId: input.expected.taskId,
+    workspaceId: input.expected.workspaceId,
+    decisionId: input.expected.decisionId,
+    actionRef: input.expected.actionRef,
+    taskRevision: input.expected.taskRevision,
+    workspaceRevision: input.expected.workspaceRevision,
+    outcome: input.expected.outcome,
+    purpose: input.expected.decision.purpose,
+    response: input.expected.decision.response,
+    binding: input.expected.decision.binding,
+    digest: input.expected.decision.digest,
+    requirementIds: [...input.expected.decision.requirementIds]
+  }, binding, input.caller));
+};
+var verifyNativeReconciliation = (verifier, input, binding) => {
+  if (!verifier?.verifyReconciliation)
+    return failure("permission_denied", "native reconciliation authority is unavailable");
+  const result = verifier.verifyReconciliation(input);
+  if (!result.ok || !validProvenance(result.data, input.caller))
+    return failure("permission_denied", "native reconciliation observation was not attested");
+  return success(null, null, trustedAuthority("reconciliation", result.data, {
+    taskId: input.expected.taskId,
+    workspaceId: input.expected.workspaceId,
+    decisionId: input.expected.decisionId,
+    actionRef: input.expected.actionRef,
+    taskRevision: input.expected.taskRevision,
+    workspaceRevision: input.expected.workspaceRevision,
+    outcome: input.expected.outcome,
+    evidenceDigest: input.expected.evidenceDigest,
+    step: input.expected.step,
+    purpose: input.expected.decision.purpose,
+    response: input.expected.decision.response,
+    binding: input.expected.decision.binding,
+    digest: input.expected.decision.digest,
+    requirementIds: [...input.expected.decision.requirementIds]
+  }, binding, input.caller));
+};
+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 digestBytes3 = (bytes) => createHash7("sha256").update(bytes).digest("hex");
+var verifyDecisionContentAtRoot = (checkoutRoot, binding) => {
+  let root;
+  try {
+    root = fs9.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 = path22.resolve(root, reference.path);
+    if (target !== root && !target.startsWith(`${root}${path22.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 = path22.relative(root, target);
+      let current = root;
+      for (const segment of relative.split(path22.sep)) {
+        if (!segment)
+          continue;
+        current = path22.join(current, segment);
+        const stat = fs9.lstatSync(current);
+        const real = fs9.realpathSync(current);
+        if (real !== root && !real.startsWith(`${root}${path22.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 (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 (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 (digestBytes3(fs9.readFileSync(target)) !== reference.digest)
+        return failure("permission_denied", "approved document bytes have changed");
+    } catch {
+      return failure("invalid_input", "approved document is unavailable");
     }
   }
-  const blocking = evaluations.filter((item) => {
-    if (item.status !== "unsatisfied" && item.status !== "unavailable")
-      return false;
-    const requirement = view.task.policy?.requirements.find((candidate) => candidate.id === item.requirementId);
-    return !requirement || requirement.before === "close";
-  });
-  if (requestedOutcome !== "stopped" && blocking.length)
-    return failure("requirements_unsatisfied", "applicable requirements are unsatisfied", {
-      requirementIds: blocking.map((item) => item.requirementId),
-      requirements: blocking.map((item) => {
-        const requirement = view.task.policy?.requirements.find((candidate) => candidate.id === item.requirementId);
-        return {
-          requirementId: item.requirementId,
-          ruleId: requirement?.ruleId ?? "unknown",
-          reason: item.reason,
-          satisfaction: requirement?.satisfaction ?? "",
-          dependentAction: requirement?.dependentAction ?? null
-        };
-      })
-    });
-  const accepted = evaluations.filter((item) => item.status === "accepted_limitation");
-  if (requestedOutcome === "verified" && accepted.length)
-    return failure("requirements_unsatisfied", "accepted limitations cannot be reported as verified", {
-      requirementIds: accepted.map((item) => item.requirementId)
-    });
-  const evidenceIds = [
-    ...new Set([
-      ...evaluations.flatMap((item) => item.evidenceIds),
-      ...view.task.findings.flatMap((item) => item.data.resolution?.evidenceIds ?? [])
-    ])
-  ];
-  const decisionIds = [
-    ...new Set([
-      ...evaluations.flatMap((item) => item.decisionIds),
-      ...view.task.findings.flatMap((item) => item.data.resolution?.decisionIds ?? [])
-    ])
-  ];
-  return success(null, null, {
-    outcome: requestedOutcome === "stopped" ? "stopped" : accepted.length ? "accepted_limitations" : "verified",
-    evidenceIds,
-    decisionIds,
-    requirementIds: evaluations.map((item) => item.requirementId)
-  });
-}
-
-// packages/workit-core/src/core/methods.ts
-var METHODS = {
-  "workit-challenge": { dimensions: ["challenge", "decisions"] },
-  "workit-behavioral-tdd": { dimensions: ["testing"], ruleIds: ["mechanical-existing-checks"] },
-  "workit-review": { dimensions: ["review"], ruleIds: ["fresh-context-review", "self-review"] },
-  "workit-plan": { dimensions: ["artifacts", "continuity"] },
-  "workit-implement": { dimensions: ["delegation"] },
-  "workit-debug": {},
-  "workit-handoff": {},
-  "workit-deslop": { ruleIds: ["pre-pr-cleanup"] }
+  return success(null, null, null);
 };
-var methodMatches = (definition, requirement) => definition.dimensions?.includes(requirement.dimension) === true || definition.ruleIds?.includes(requirement.ruleId) === true;
-var assuranceFor = (id, definition, capabilities) => {
-  const keys = new Set([
-    id,
-    ...definition.dimensions ?? [],
-    ...definition.ruleIds ?? []
-  ]);
-  const matches = capabilities.filter((capability) => keys.has(capability.name) || keys.has(capability.surface));
-  if (id === "workit-review" && matches.length === 0)
-    return { assurance: "unavailable", reasons: ["independent review capability is unavailable"] };
-  if (matches.some((capability) => capability.assurance === "unavailable"))
-    return {
-      assurance: "unavailable",
-      reasons: matches.filter((capability) => capability.assurance === "unavailable").map((capability) => capability.reason)
-    };
-  if (matches.some((capability) => capability.assurance === "enforced"))
-    return { assurance: "enforced", reasons: matches.map((capability) => capability.reason) };
-  return { assurance: "agent_guided", reasons: matches.map((capability) => capability.reason) };
+var 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 selectMethods(policy, capabilities) {
-  return Object.entries(METHODS).flatMap(([id, definition]) => {
-    const requirements = policy.requirements.filter((requirement) => methodMatches(definition, requirement));
-    if (requirements.length === 0)
-      return [];
-    const capability = assuranceFor(id, definition, capabilities);
-    const reasons = [
-      ...new Set(requirements.map((requirement) => requirement.reason)),
-      ...capability.reasons
-    ];
-    if (capability.assurance === "unavailable")
-      reasons.unshift("required capability is unavailable");
-    return [{ id, reason: reasons.join("; "), assurance: capability.assurance }];
-  });
-}
-
-// 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: []
+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)
     });
-  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 COMPACT_MAX_BYTES = 4096;
-var COMPACT_MAX_ITEMS = 8;
-var COMPACT_TEXT_BYTES = 128;
-var sensitiveUrl = /\bhttps?:\/\/[^/\s:@]+:[^@\s]+@/gi;
-var sensitiveValue = /(?:token|secret|password|passwd|api[-_ ]?key|private[-_ ]?key|authorization)\s*[:=]\s*(?:bearer\s+)?\S+|\bbearer\s+\S+/gi;
-var privateKey = /-----BEGIN [^-]*PRIVATE KEY-----[\s\S]*?-----END [^-]*PRIVATE KEY-----/gi;
-var compactText = (value, limit) => value === null ? null : value.replace(privateKey, "<redacted-private-key>").replace(sensitiveUrl, "<redacted-url>").replace(sensitiveValue, (match) => {
-  const separator = match.search(/[:=]/u);
-  if (separator >= 0)
-    return `${match.slice(0, separator)}=<redacted>`;
-  const space = match.search(/\s/u);
-  return `${match.slice(0, space)} <redacted>`;
-}).slice(0, limit);
-var compactBytes = (value) => new TextEncoder().encode(value).byteLength;
-var compactReference = (ref) => {
-  if (ref.kind === "file")
-    return {
-      kind: "file",
-      path: compactText(ref.path, COMPACT_TEXT_BYTES) ?? ""
+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
     };
-  if (ref.kind === "record")
-    return {
-      kind: "record",
-      collection: ref.collection,
-      id: ref.id
+    const actionProgress = workflow.steps.length ? [
+      ...(current.actionProgress ?? []).filter((progress) => progress.decisionId !== input.decisionId),
+      {
+        decisionId: input.decisionId,
+        steps: [...workflow.steps],
+        completedSteps: [...workflow.completed]
+      }
+    ] : current.actionProgress ?? [];
+    const next = {
+      ...current,
+      actionProgress,
+      decisions: current.decisions.map((candidate) => candidate.id === input.decisionId ? { ...candidate, data: settled } : candidate)
+    };
+    if (!complete) {
+      outcomeResult = success(mutation.revision, input.workspaceRevision, {
+        ...entry,
+        data: settled
+      });
+    }
+    return success(mutation.revision, null, next);
+  }, input.native?.now);
+  if (!changed.ok)
+    return changed;
+  const entry = changed.data.decisions.find((candidate) => candidate.id === input.decisionId);
+  if (!entry)
+    return failure("recovery_required", "settled decision disappeared");
+  if (outcomeResult)
+    return outcomeResult;
+  return success(changed.data.revision, input.workspaceRevision, entry);
+}
+function reconcileAction(input) {
+  if (!input.store || !input.taskRevision || !input.workspaceRevision || !input.evidenceDigest)
+    return failure("invalid_input", "action reconciliation preconditions are required");
+  const authority = takeAuthority(input.authority, { owner: input.authorityOwner, store: input.store, root: input.store.root }, input.authorityCaller);
+  if (!authority || authority.kind !== "reconciliation")
+    return failure("permission_denied", "native reconciliation authority is not verified");
+  if (authority.taskId !== input.taskId || authority.decisionId !== input.decisionId || !sameRef(authority.actionRef, input.actionRef) || authority.taskRevision !== input.taskRevision || authority.workspaceRevision !== input.workspaceRevision || authority.outcome !== input.outcome || authority.evidenceDigest !== input.evidenceDigest || authority.step !== input.step)
+    return failure("permission_denied", "native reconciliation authority is not bound");
+  const changed = input.store.mutateTask(input.taskId, input.taskRevision, (current, mutation) => {
+    const workspace = input.store.readWorkspace();
+    if (!workspace.ok)
+      return workspace;
+    if (!workspace.data)
+      return failure("not_found", "workspace not found");
+    if (authority.workspaceId !== workspace.data.id)
+      return failure("permission_denied", "native reconciliation workspace does not match");
+    if (workspace.data.revision !== input.workspaceRevision)
+      return failure("revision_conflict", "workspace revision does not match");
+    const entry = current.decisions.find((candidate) => candidate.id === input.decisionId);
+    if (!entry || entry.data.purpose !== "action")
+      return failure("not_found", "decision not found");
+    if (!authorityDecisionMatches(authority, entry.data) || !provenanceMatches(entry.provenance, authority.provenance))
+      return failure("permission_denied", "native reconciliation caller does not match approval");
+    if (entry.data.response !== "approved" || entry.data.revoked !== null || entry.data.digest !== decisionDigest(entry.data) || entry.data.binding.taskId !== current.id || entry.data.binding.workspaceId !== current.workspaceId || entry.data.binding.workspaceId !== workspace.data.id)
+      return failure("permission_denied", "reconciliation decision binding is invalid");
+    if (entry.data.consumption?.state !== "uncertain")
+      return failure("external_outcome_unknown", "only an uncertain action can be reconciled");
+    if (!sameRef(entry.data.consumption.actionRef, input.actionRef))
+      return failure("permission_denied", "reconciliation reference does not match reservation");
+    const stored = current.actionProgress?.find((progress) => progress.decisionId === input.decisionId);
+    const workflow = stored ? { steps: [...stored.steps], completed: [...stored.completedSteps] } : { steps: [], completed: [] };
+    const currentStep = input.step ?? workflow.steps[workflow.completed.length];
+    if (workflow.steps.length && (!currentStep || currentStep !== workflow.steps[workflow.completed.length]))
+      return failure("permission_denied", "reconciliation step is outside the approved workflow");
+    if (input.outcome === "not_started") {
+      return success(mutation.revision, null, {
+        ...current,
+        decisions: current.decisions.map((candidate) => candidate.id === input.decisionId ? { ...candidate, data: { ...candidate.data, consumption: null } } : candidate)
+      });
+    }
+    if (currentStep)
+      workflow.completed.push(currentStep);
+    const complete = !workflow.steps.length || workflow.completed.length >= workflow.steps.length;
+    const nextDecision = {
+      ...entry.data,
+      consumption: complete ? { ...entry.data.consumption, state: "consumed", at: mutation.now } : null
     };
-  return { kind: ref.kind };
-};
-function compactTaskContext(view) {
-  const decisions = view.task.decisions.slice().sort((left, right) => left.id < right.id ? -1 : left.id > right.id ? 1 : 0).slice(0, COMPACT_MAX_ITEMS).map((entry) => ({
-    id: entry.id,
-    purpose: entry.data.purpose,
-    status: entry.data.response,
-    digest: entry.data.digest,
-    references: entry.data.binding.contentRefs.slice(0, 1).map(compactReference)
-  }));
-  const methods = view.task.policy ? selectMethods(view.task.policy, view.capabilities).map((method) => ({
-    id: method.id,
-    assurance: method.assurance,
-    reason: compactText(method.reason, COMPACT_TEXT_BYTES) ?? ""
-  })) : [];
-  const gaps = Array.from(new Set([
-    ...view.evidence.filter((entry) => entry.status === "stale").map((entry) => `stale evidence: ${entry.evidenceId}`),
-    ...view.requirements.filter((entry) => entry.status !== "satisfied").map((entry) => entry.reason),
-    ...view.task.progress.blockers.map((entry) => entry.reason)
-  ])).sort().slice(0, COMPACT_MAX_ITEMS).map((gap) => compactText(gap, COMPACT_TEXT_BYTES));
-  const context = {
-    objective: compactText(view.task.intent.data.objective, COMPACT_TEXT_BYTES) ?? "",
-    status: view.task.status,
-    decisions,
-    methods,
-    gaps,
-    nextAction: compactText(view.task.progress.nextAction, COMPACT_TEXT_BYTES)
-  };
-  let encoded = JSON.stringify(context);
-  while (compactBytes(encoded) > COMPACT_MAX_BYTES && (context.decisions.length || context.methods.length || context.gaps.length)) {
-    if (context.gaps.length)
-      context.gaps.pop();
-    else if (context.decisions.length)
-      context.decisions.pop();
-    else
-      context.methods.pop();
-    encoded = JSON.stringify(context);
-  }
-  if (compactBytes(encoded) > COMPACT_MAX_BYTES) {
-    context.objective = compactText(context.objective, 64) ?? "";
-    context.nextAction = compactText(context.nextAction, 64);
-    encoded = JSON.stringify(context);
-  }
-  return encoded;
+    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 exportDigest = (bundle) => sha256({
-  schemaVersion: bundle.schemaVersion,
-  exportedAt: bundle.exportedAt,
-  sourceWorkspaceId: bundle.sourceWorkspaceId,
-  task: bundle.task
-});
-// packages/workit-core/src/core/branch.ts
-import { existsSync as existsSync16, mkdirSync as mkdirSync8, readFileSync as readFileSync16, writeFileSync as writeFileSync10 } from "node:fs";
-import { execFileSync as execFileSync3 } from "node:child_process";
-import path23 from "node:path";
+var bindingCovers = scopeCovers;
+var verifyDecisionContent = verifyContentRefs;
 
-// packages/workit-core/src/core/git.ts
-import { execFileSync as execFileSync2 } from "node:child_process";
-var run = (cwd, args) => {
-  try {
-    const stdout = execFileSync2("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
-    };
-  }
+// packages/workit-core/src/core/task-evaluation.ts
+var digestBytes4 = (value) => createHash8("sha256").update(value).digest("hex");
+var inside = (root, candidate) => candidate === root || candidate.startsWith(`${root}${path23.sep}`);
+var relative = (root, candidate) => path23.relative(root, candidate).split(path23.sep).join("/") || ".";
+var canonicalPath = (value) => {
+  if (typeof value !== "string" || !value)
+    return null;
+  if (value.includes("\\") || value.split("/").includes(".."))
+    return null;
+  const normalized = path23.posix.normalize(value);
+  if (normalized === ".." || normalized.startsWith("../") || normalized.startsWith("/"))
+    return null;
+  return normalized === "." ? "." : normalized.replace(/\/$/, "");
 };
-var gitContext = (workspaceRoot, paths = []) => {
-  const cwd = workspaceRoot;
-  let failure;
-  const runHere = (args) => {
-    const result = run(cwd, args);
-    if (!failure && result.exitCode !== 0) {
-      failure = { stderr: result.stderr, exitCode: result.exitCode };
-    }
-    return result.stdout;
-  };
-  const 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);
-    }
-  }
-  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));
+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 {
-    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 } : {}
+    description: scope.description,
+    paths: [...new Set(normalizedPaths)],
+    exclusions: [...new Set(normalizedExclusions)]
   };
 };
-
-// packages/workit-core/src/core/vcs-config.ts
-import fs10 from "node:fs";
-import path22 from "node:path";
-import { spawnSync as spawnSync4 } from "node:child_process";
-var TOKEN_PLACEHOLDER3 = "YOUR_TOKEN_HERE";
-var vcsConfigPath = () => process.env.WORKFLOW_VCS_CONFIG ?? path22.join(configDir(), "vcs.json");
-var vcsCwd = (cwd) => cwd ?? process.env.WORKFLOW_WORKSPACE_ROOT ?? process.cwd();
-var remoteProvider = (cwd) => {
-  const r = spawnSync4("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 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 readVcsConfig = () => {
-  const file = vcsConfigPath();
-  let raw;
-  try {
-    raw = fs10.readFileSync(file, "utf8");
-  } catch {
-    return { status: "missing", path: file, config: {} };
+var pathRelevant = (value, scope) => scopeMatches(value, scope);
+var compareCodeUnits2 = (left, right) => {
+  const length = Math.min(left.length, right.length);
+  for (let index = 0;index < length; index += 1) {
+    const difference = left.charCodeAt(index) - right.charCodeAt(index);
+    if (difference !== 0)
+      return difference;
+  }
+  return left.length - right.length;
+};
+var gitPaths = (root) => {
+  const result = spawnSync4("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(path23.sep).join("/")) : [];
+  const stagedDeleted = spawnSync4("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(path23.sep).join("/")));
+  }
+  return { paths: [...new Set(paths)], uncertain: false, git: true };
+};
+var walk = (root, directory, output) => {
+  let names;
   try {
-    parsed = JSON.parse(raw);
+    names = fs10.readdirSync(directory);
   } catch {
-    return { status: "malformed", path: file, config: {}, error: `${file} is not valid JSON` };
+    return true;
   }
-  if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
-    return { status: "valid", path: file, config: parsed };
+  let uncertain = false;
+  for (const name of names) {
+    if (name === ".git" || name === ".workit")
+      continue;
+    const target = path23.join(directory, name);
+    let stat;
+    try {
+      stat = fs10.lstatSync(target);
+    } catch {
+      uncertain = true;
+      continue;
+    }
+    const item = relative(root, target);
+    output.add(item);
+    if (stat.isDirectory() && !stat.isSymbolicLink())
+      uncertain = walk(root, target, output) || uncertain;
   }
-  return { status: "malformed", path: file, config: {}, error: `${file} is not a JSON object` };
+  return uncertain;
 };
-function vcsConfig(mode, cwd) {
-  const ws = resolveWorkspace(vcsCwd(cwd));
-  const wsVcs = ws?.vcs ?? {};
-  const wsYt = ws?.youtrack ?? {};
-  const wsIssues = ws?.issues ?? {};
-  const { status: cfgStatus, path: cfgPath, config: cfg, error: cfgError } = readVcsConfig();
-  const root = vcsCwd(cwd);
-  const determinateRoot = cwd !== undefined || process.env.WORKFLOW_WORKSPACE_ROOT !== undefined;
-  const rawProvider = wsVcs.provider ?? (determinateRoot ? remoteProvider(root) : null) ?? cfg.provider ?? null;
-  const provider = rawProvider === null || rawProvider === undefined ? null : String(rawProvider).toLowerCase() || null;
-  const wp = ws?.branchPolicy ?? {};
-  const hasWorkspacePolicy = typeof wp.preset === "string" && Object.hasOwn(PRESETS, wp.preset);
-  const policyDefault = resolveBranchPolicyFor(root).defaultTargetBranch;
-  const defaultTarget = String(wsVcs.defaultTargetBranch ?? (hasWorkspacePolicy ? policyDefault : cfg.defaultTargetBranch ?? policyDefault) ?? "develop");
-  const linkIssues = typeof wsYt.link_issues === "boolean" ? wsYt.link_issues : null;
-  const youtrackBaseUrl = typeof wsYt.baseUrl === "string" ? wsYt.baseUrl : null;
-  let issuesProvider = null;
-  let linkOnPr = null;
-  if (provider === "github" && typeof wsIssues.provider === "string" && wsIssues.provider.toLowerCase() === "github") {
-    issuesProvider = "github";
-    linkOnPr = typeof wsIssues.link_on_pr === "boolean" ? wsIssues.link_on_pr : null;
-  }
-  if (mode === "resolve") {
-    if (cfgStatus === "malformed")
-      return { ok: false, error: cfgError, configPath: cfgPath };
-    return {
-      ok: true,
-      workspace_name: ws?.name ?? null,
-      provider,
-      defaultTargetBranch: defaultTarget,
-      link_issues: linkIssues,
-      youtrack_base_url: youtrackBaseUrl,
-      issues_provider: issuesProvider,
-      link_on_pr: linkOnPr
-    };
-  }
-  if (cfgStatus === "malformed") {
-    return { ok: false, error: cfgError, configPath: cfgPath };
+var scopeRoots = (root, scope) => {
+  const roots = [];
+  for (const item of scope.paths.length ? scope.paths : ["."]) {
+    const target = path23.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 (!fs10.existsSync(ancestor) && ancestor !== root)
+      ancestor = path23.dirname(ancestor);
+    try {
+      if (!inside(root, fs10.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);
   }
-  if (cfgStatus === "missing") {
-    return { ok: false, error: `vcs.json is missing: ${cfgPath}`, configPath: cfgPath };
+  return success(null, null, roots);
+};
+function captureCandidate(root, scope, environment = []) {
+  let checkout;
+  try {
+    checkout = fs10.realpathSync(root);
+  } catch {
+    return failure("invalid_input", "candidate root does not exist");
   }
-  if (provider === null) {
-    return {
-      ok: false,
-      error: `no vcs provider configured (set vcs.provider in ${cfgPath}, match a workspace entry, or run inside a checkout with a recognized origin remote)`,
-      configPath: cfgPath
-    };
+  const 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 (!fs10.existsSync(target))
+      continue;
+    let stat;
+    try {
+      stat = fs10.lstatSync(target);
+    } catch {
+      uncertain = true;
+      continue;
+    }
+    if (!git.git && stat.isDirectory() && !stat.isSymbolicLink())
+      uncertain = walk(checkout, target, names) || uncertain;
   }
-  const prov = cfg[provider] ?? {};
-  const wsTokenFile = typeof wsVcs.tokenFile === "string" && wsVcs.tokenFile.trim() !== "" ? wsVcs.tokenFile : null;
-  const tokenFile = String(wsTokenFile ?? prov.tokenFile ?? path22.join(configDir(), `${provider}.token`));
-  const tokenPath = path22.resolve(tokenFile);
-  let tokenOk = false;
-  if (fs10.existsSync(tokenPath)) {
-    const token = fs10.readFileSync(tokenPath, "utf8").trim();
-    const placeholder = !token || token === TOKEN_PLACEHOLDER3 || token.startsWith(TOKEN_PLACEHOLDER3);
-    tokenOk = !placeholder;
+  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 = path23.join(checkout, item);
+    try {
+      const stat = fs10.lstatSync(target);
+      if (stat.isSymbolicLink()) {
+        const link = fs10.readlinkSync(target);
+        files.push({ path: item, kind: "symlink", digest: digestBytes4(link), executable: null });
+      } else if (stat.isFile()) {
+        files.push({
+          path: item,
+          kind: "file",
+          digest: digestBytes4(fs10.readFileSync(target)),
+          executable: (stat.mode & 73) !== 0
+        });
+      } else if (!stat.isDirectory()) {
+        completeness = "uncertain";
+      } else if (git.git && git.paths.includes(item)) {
+        completeness = "uncertain";
+      }
+    } catch (error) {
+      if (error?.code === "ENOENT") {
+        files.push({ path: item, kind: "absent", digest: null, executable: null });
+      } else
+        completeness = "uncertain";
+    }
   }
-  const out = {
-    ok: true,
-    configPath: path22.resolve(cfgPath),
-    provider,
-    defaultTargetBranch: defaultTarget,
-    pr: cfg.pr ?? {},
-    tokenPath,
-    tokenPresent: fs10.existsSync(tokenPath),
-    tokenReady: tokenOk,
-    workspace_name: ws?.name ?? null,
-    link_issues: linkIssues,
-    youtrack_base_url: youtrackBaseUrl,
-    issues_provider: issuesProvider,
-    link_on_pr: linkOnPr
+  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 = spawnSync4("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
   };
-  if (provider === "gitlab") {
-    out.gitlab = {
-      host: prov.host ?? "gitlab.com",
-      apiUrl: prov.apiUrl ?? "https://gitlab.com/api/v4"
+  const candidate = { ...partial, id: candidateDigest(partial) };
+  const parsed = candidateSchema.safeParse(candidate);
+  return parsed.success ? success(null, null, parsed.data) : failure("invalid_input", "captured candidate is invalid");
+}
+var fileMap = (candidate) => new Map(candidate.files.map((file) => [file.path, file]));
+var changedPaths = (before, after) => {
+  const paths = new Set([...before.files, ...after.files].map((file) => file.path));
+  const left = fileMap(before);
+  const right = fileMap(after);
+  const changed = [...paths].filter((item) => JSON.stringify(left.get(item) ?? null) !== JSON.stringify(right.get(item) ?? null));
+  if (before.head !== after.head)
+    changed.push(".");
+  if (JSON.stringify(before.environment) !== JSON.stringify(after.environment))
+    changed.push(".");
+  return changed;
+};
+var sessionFromRef = (value) => {
+  if (typeof value !== "object" || value === null || value.kind !== "host")
+    return null;
+  return typeof value.host === "string" && typeof value.handle === "string" ? { host: value.host, handle: value.handle } : null;
+};
+var sameSession = (left, right) => {
+  const other = sessionFromRef(right);
+  return left !== null && other !== null && left.host === other.host && left.handle === other.handle;
+};
+var evidenceScopes = (task, ids) => (task.policy?.requirements ?? []).filter((requirement) => ids.includes(requirement.id)).map((requirement) => requirement.scope);
+function evaluateEvidence(task, candidate) {
+  const current = candidate ?? task.candidates.at(-1) ?? null;
+  return task.evidence.map((entry) => {
+    const evidence = entry.data;
+    if (evidence.result === "failed")
+      return {
+        evidenceId: entry.id,
+        status: "failed",
+        reason: "failed evidence remains historical"
+      };
+    if (evidence.kind === "check" || evidence.kind === "review") {
+      if (!evidence.beforeCandidateId || !evidence.candidateId)
+        return {
+          evidenceId: entry.id,
+          status: "stale",
+          reason: "check or review evidence lacks start and end candidates"
+        };
+      if (evidence.beforeCandidateId !== evidence.candidateId)
+        return {
+          evidenceId: entry.id,
+          status: "stale",
+          reason: "candidate changed during the check or review"
+        };
+    }
+    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"
     };
-  } 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 = fs10.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 = spawnSync4("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) => spawnSync4("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 = spawnSync4("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) });
-    }
-  }
+}
+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 {
-    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
+    beforeCandidateId: evidence.beforeCandidateId ?? fallback,
+    candidateId: evidence.candidateId ?? fallback
   };
-}
-
-// packages/workit-core/src/core/branch.ts
-var resolveBranchPolicyFor = (workspaceRoot) => resolveBranchPolicy(readConfig(), resolveWorkspace(workspaceRoot));
-var resolveCommitPolicyFor = (workspaceRoot) => resolveCommitPolicy(readConfig(), resolveWorkspace(workspaceRoot));
-var policy = (root) => resolveBranchPolicyFor(root);
-var allowedBranch = (root, name) => policy(root).allowed.some((r) => r.test(name));
-var isProtected = (root, name) => policy(root).protected.has(name.toLowerCase());
-var baseBranch = (cwd) => {
-  const resolved = vcsConfig("resolve", cwd);
-  if (resolved.ok === false)
-    return { error: String(resolved.error) };
-  return { base: String(resolved.defaultTargetBranch ?? "develop") };
 };
-var originBaseReady = (cwd, base) => {
-  const run = (args) => execFileSync3("git", args, { cwd, encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] });
-  try {
-    try {
-      run(["fetch", "origin", base, "--prune"]);
-    } catch {
-      run(["fetch", "origin", "--prune"]);
+var findingVerificationPasses = (findingCandidateId, evidence) => evidence.status === "passed" && (evidence.kind === "check" || evidence.kind === "review") && ((findingCandidateId ?? null) === null || evidence.candidateId === findingCandidateId);
+var applicableDecision2 = (task, workspace, requirement, checkoutRoot) => task.decisions.filter((entry) => entry.provenance.kind !== "imported").map((entry) => entry.data).filter((decision) => decision.purpose === "limitation" && decision.response === "approved" && decision.revoked === null && decision.binding.taskId === task.id && decision.binding.workspaceId === workspace.id && decision.requirementIds.includes(requirement.id) && decision.binding.scope && scopeCovers2(decision.binding.scope, requirement.scope) && decision.digest === decisionDigest(decision) && (checkoutRoot ? verifyDecisionContentAtRoot(checkoutRoot, decision.binding).ok : decision.binding.contentRefs.every((reference) => reference.kind !== "file")));
+var applicableRequirementDecision = (task, workspace, requirement, checkoutRoot) => task.decisions.filter(({ data, provenance }) => provenance.kind !== "imported" && data.purpose !== "limitation" && (data.response === "approved" || data.response === "stated") && data.revoked === null && data.binding.taskId === task.id && data.binding.workspaceId === workspace.id && data.requirementIds.includes(requirement.id) && scopeCovers2(data.binding.scope, requirement.scope) && data.digest === decisionDigest(data) && (checkoutRoot ? verifyDecisionContentAtRoot(checkoutRoot, data.binding).ok : data.binding.contentRefs.every((reference) => reference.kind !== "file"))).map(({ id }) => ({ id }));
+var evidenceMatchesRequirement = (kind, evidenceKind, dimension, ruleId) => {
+  if (kind !== "passed")
+    return false;
+  if (dimension === "testing" || dimension === "verification")
+    return evidenceKind === "check" || ruleId === "pre-pr-cleanup" && evidenceKind === "artifact";
+  if (dimension === "review")
+    return evidenceKind === "review";
+  if (dimension === "investigation" || dimension === "challenge")
+    return evidenceKind === "investigation";
+  if (dimension === "artifacts" || dimension === "continuity")
+    return evidenceKind === "artifact";
+  return false;
+};
+var expectedKinds = (dimension, ruleId) => {
+  if (dimension === "testing")
+    return "check";
+  if (dimension === "verification")
+    return ruleId === "pre-pr-cleanup" ? "check or artifact" : "check";
+  if (dimension === "review")
+    return "review";
+  if (dimension === "investigation" || dimension === "challenge")
+    return "investigation";
+  if (dimension === "artifacts" || dimension === "continuity")
+    return "artifact";
+  if (dimension === "decisions")
+    return "decision";
+  return "worker report";
+};
+function evaluateRequirements(task, workspace, capabilities, candidate, checkoutRoot, _caller) {
+  const evidence = evaluateEvidence(task, candidate);
+  if (task.policy && task.policy.policyVersion !== POLICY_VERSION)
+    return task.policy.requirements.map((requirement) => ({
+      requirementId: requirement.id,
+      status: "unsatisfied",
+      evidenceIds: [],
+      decisionIds: [],
+      reason: "stored policy version is unsupported; reassessment is required"
+    }));
+  return (task.policy?.requirements ?? []).map((requirement) => {
+    const related = task.evidence.map((entry, index) => ({ entry, evaluation: evidence[index] })).filter(({ entry }) => entry.data.requirementIds.includes(requirement.id));
+    const passed = related.filter(({ entry, evaluation }) => {
+      if (!evidenceMatchesRequirement(evaluation.status, entry.data.kind, requirement.dimension, requirement.ruleId))
+        return false;
+      if ((entry.data.kind === "check" || entry.data.kind === "review") && (!entry.data.beforeCandidateId || !entry.data.candidateId || entry.data.beforeCandidateId !== entry.data.candidateId))
+        return false;
+      if (requirement.dimension !== "review")
+        return true;
+      const reviewSession = sessionFromRef(entry.data.reviewContext);
+      const sameImplementation = sameSession(reviewSession, task.intent.provenance.session);
+      const sameEvidenceSession = related.some(({ entry: other }) => other.id !== entry.id && other.data.kind === "review" && other.data.candidateId !== null && other.data.candidateId === entry.data.candidateId && sameSession(reviewSession, other.provenance.session));
+      return entry.data.kind === "review" && reviewSession !== null && sameSession(reviewSession, entry.provenance.session) && (requirement.ruleId === "self-review" || !sameImplementation && !sameEvidenceSession);
+    });
+    if (passed.length) {
+      const currentId = candidate?.id ?? null;
+      const withRed = requirement.dimension === "testing" ? passed.filter(({ entry }) => related.some((other) => other.entry.data.kind === "check" && other.evaluation.status === "failed" && other.entry.data.requirementIds.includes(requirement.id) && other.entry.recordedAt <= entry.recordedAt) || related.some((baseline) => baseline.entry.id !== entry.id && baseline.entry.data.kind === "check" && baseline.entry.data.result === "passed" && baseline.entry.data.candidateId !== null && currentId !== null && baseline.entry.data.candidateId !== currentId)) : passed;
+      if (withRed.length)
+        return {
+          requirementId: requirement.id,
+          status: "satisfied",
+          evidenceIds: withRed.map(({ entry }) => entry.id),
+          decisionIds: [],
+          reason: "fresh applicable evidence passed"
+        };
+      if (requirement.dimension === "testing")
+        return {
+          requirementId: requirement.id,
+          status: "unsatisfied",
+          evidenceIds: [],
+          decisionIds: [],
+          reason: "testing requirement has GREEN evidence but no preceding RED"
+        };
     }
-    try {
-      execFileSync3("git", ["show-ref", "--verify", "--quiet", `refs/remotes/origin/${base}`], {
-        cwd,
-        stdio: "pipe"
-      });
-    } catch {
+    if (requirement.dimension === "delegation") {
+      const dot = (scope) => scope.paths.length > 0 ? scope : { ...scope, paths: ["."] };
+      const reconciled = task.workers.some((worker) => worker.data.report?.outcome === "completed" && (worker.data.assignment.requirementIds.includes(requirement.id) || scopeCovers2(dot(requirement.scope), dot(worker.data.assignment.scope))));
+      if (reconciled)
+        return {
+          requirementId: requirement.id,
+          status: "satisfied",
+          evidenceIds: [],
+          decisionIds: [],
+          reason: "bounded helper completed and its result is recorded"
+        };
+    }
+    const decisions = requirement.dimension === "decisions" ? applicableRequirementDecision(task, workspace, requirement, checkoutRoot) : [];
+    if (decisions.length)
       return {
-        ok: false,
-        error: `origin/${base} missing — push ${base} before creating feature/* or bugfix/* branches`
+        requirementId: requirement.id,
+        status: "satisfied",
+        evidenceIds: [],
+        decisionIds: decisions.map((decision) => decision.id),
+        reason: "an applicable approved or stated decision satisfies the requirement"
+      };
+    const limitations = requirement.acceptanceAllowed ? applicableDecision2(task, workspace, requirement, checkoutRoot) : [];
+    if (limitations.length)
+      return {
+        requirementId: requirement.id,
+        status: "accepted_limitation",
+        evidenceIds: [],
+        decisionIds: limitations.map((decision) => task.decisions.find((entry) => entry.data === decision).id),
+        reason: "an applicable approved limitation permits the missing evidence"
+      };
+    const unavailable = capabilities.some((capability) => capability.assurance === "unavailable" && (capability.name === requirement.dimension || capability.surface === requirement.dimension));
+    if (!unavailable && related.length > 0 && !passed.length)
+      return {
+        requirementId: requirement.id,
+        status: "unsatisfied",
+        evidenceIds: related.map(({ entry }) => entry.id),
+        decisionIds: [],
+        reason: `no passing evidence (needs kind:${expectedKinds(requirement.dimension, requirement.ruleId)})`
       };
+    return {
+      requirementId: requirement.id,
+      status: unavailable ? "unavailable" : "unsatisfied",
+      evidenceIds: related.map(({ entry }) => entry.id),
+      decisionIds: [],
+      reason: unavailable ? "required capability is unavailable" : "no fresh passing evidence"
+    };
+  });
+}
+function evaluateClosure(requestedOutcome, view) {
+  if (requestedOutcome !== "stopped" && !view.task.policy)
+    return failure("requirements_unsatisfied", "task has not been assessed");
+  if (view.task.policy && view.task.policy.policyVersion !== POLICY_VERSION)
+    return failure("requirements_unsatisfied", "stored policy version is unsupported; reassessment is required");
+  const evaluations = view.requirements;
+  const openFindings = view.task.findings.filter((entry) => entry.data.disposition === "open");
+  if (requestedOutcome !== "stopped" && openFindings.length)
+    return failure("requirements_unsatisfied", "open findings must be resolved before closure");
+  if (requestedOutcome !== "stopped") {
+    const evidenceById = new Map(view.evidence.map((entry) => [entry.evidenceId, entry.status]));
+    for (const entry of view.task.findings) {
+      if (entry.data.disposition === "fixed") {
+        const verified = entry.data.resolution?.evidenceIds.some((id) => {
+          const evidence = view.task.evidence.find((item) => item.id === id);
+          if (!evidence)
+            return false;
+          return findingVerificationPasses(entry.data.candidateId, {
+            kind: evidence.data.kind,
+            candidateId: evidence.data.candidateId,
+            status: evidenceById.get(id) ?? "missing"
+          });
+        });
+        if (!verified)
+          return failure("requirements_unsatisfied", "fixed findings require current verification");
+      }
+      if (entry.data.disposition === "deferred") {
+        const valid = entry.data.resolution?.decisionIds.some((id) => {
+          const decisionEntry = view.task.decisions.find((item) => item.id === id);
+          const decision = decisionEntry?.data;
+          return Boolean(decision && decisionEntry?.provenance.kind !== "imported" && decision.purpose === "limitation" && decision.response === "approved" && decision.revoked === null && decision.digest === decisionDigest(decision) && verifyDecisionContentAtRoot(view.workspace.root, decision.binding).ok && decision.binding.taskId === view.task.id && decision.binding.workspaceId === view.workspace.id && scopeCovers2(decision.binding.scope, entry.data.scope) && decision.requirementIds.some((requirementId) => view.task.policy?.requirements.some((requirement) => requirement.id === requirementId && requirement.acceptanceAllowed)));
+        });
+        if (!valid)
+          return failure("requirements_unsatisfied", "deferred findings require an approved limitation decision that references an acceptanceAllowed requirement and covers the finding scope");
+      }
     }
-    return { ok: true };
-  } catch (error) {
-    return {
-      ok: false,
-      error: error instanceof Error ? error.message : "ensure-base-branch failed"
-    };
   }
+  const blocking = evaluations.filter((item) => {
+    if (item.status !== "unsatisfied" && item.status !== "unavailable")
+      return false;
+    const requirement = view.task.policy?.requirements.find((candidate) => candidate.id === item.requirementId);
+    return !requirement || requirement.before === "close";
+  });
+  if (requestedOutcome !== "stopped" && blocking.length)
+    return failure("requirements_unsatisfied", "applicable requirements are unsatisfied", {
+      requirementIds: blocking.map((item) => item.requirementId),
+      requirements: blocking.map((item) => {
+        const requirement = view.task.policy?.requirements.find((candidate) => candidate.id === item.requirementId);
+        return {
+          requirementId: item.requirementId,
+          ruleId: requirement?.ruleId ?? "unknown",
+          reason: item.reason,
+          satisfaction: requirement?.satisfaction ?? "",
+          dependentAction: requirement?.dependentAction ?? null
+        };
+      })
+    });
+  const accepted = evaluations.filter((item) => item.status === "accepted_limitation");
+  if (requestedOutcome === "verified" && accepted.length)
+    return failure("requirements_unsatisfied", "accepted limitations cannot be reported as verified", {
+      requirementIds: accepted.map((item) => item.requirementId)
+    });
+  const evidenceIds = [
+    ...new Set([
+      ...evaluations.flatMap((item) => item.evidenceIds),
+      ...view.task.findings.flatMap((item) => item.data.resolution?.evidenceIds ?? [])
+    ])
+  ];
+  const decisionIds = [
+    ...new Set([
+      ...evaluations.flatMap((item) => item.decisionIds),
+      ...view.task.findings.flatMap((item) => item.data.resolution?.decisionIds ?? [])
+    ])
+  ];
+  return success(null, null, {
+    outcome: requestedOutcome === "stopped" ? "stopped" : accepted.length ? "accepted_limitations" : "verified",
+    evidenceIds,
+    decisionIds,
+    requirementIds: evaluations.map((item) => item.requirementId)
+  });
+}
+
+// packages/workit-core/src/core/methods.ts
+var METHODS = {
+  "workit-challenge": { dimensions: ["challenge", "decisions"] },
+  "workit-behavioral-tdd": { dimensions: ["testing"], ruleIds: ["mechanical-existing-checks"] },
+  "workit-review": { dimensions: ["review"], ruleIds: ["fresh-context-review", "self-review"] },
+  "workit-plan": { dimensions: ["artifacts", "continuity"] },
+  "workit-implement": { dimensions: ["delegation"] },
+  "workit-debug": {},
+  "workit-handoff": {},
+  "workit-deslop": { ruleIds: ["pre-pr-cleanup"] }
 };
-var fastForwardBase = (cwd, base) => {
-  const run = (args) => execFileSync3("git", args, { cwd, encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] });
-  try {
-    let hasLocalBase = true;
-    try {
-      execFileSync3("git", ["show-ref", "--verify", "--quiet", `refs/heads/${base}`], {
-        cwd,
-        stdio: "pipe"
-      });
-    } catch {
-      hasLocalBase = false;
-    }
-    if (hasLocalBase) {
-      run(["checkout", base]);
-      try {
-        run(["merge", "--ff-only", `origin/${base}`]);
-      } catch {}
-    } else {
-      run(["checkout", "-b", base, "--track", `origin/${base}`]);
-    }
-    return { ok: true };
-  } catch (error) {
+var methodMatches = (definition, requirement) => definition.dimensions?.includes(requirement.dimension) === true || definition.ruleIds?.includes(requirement.ruleId) === true;
+var assuranceFor = (id, definition, capabilities) => {
+  const keys = new Set([
+    id,
+    ...definition.dimensions ?? [],
+    ...definition.ruleIds ?? []
+  ]);
+  const matches = capabilities.filter((capability) => keys.has(capability.name) || keys.has(capability.surface));
+  if (id === "workit-review" && matches.length === 0)
+    return { assurance: "unavailable", reasons: ["independent review capability is unavailable"] };
+  if (matches.some((capability) => capability.assurance === "unavailable"))
     return {
-      ok: false,
-      error: error instanceof Error ? error.message : "ensure-base-branch failed"
+      assurance: "unavailable",
+      reasons: matches.filter((capability) => capability.assurance === "unavailable").map((capability) => capability.reason)
     };
-  }
-};
-var ensureBaseBranch = (cwd, base) => {
-  const git = gitContext(cwd);
-  if (!git.branch || git.branch === "unknown")
-    return { ok: false, error: "not in a git repository" };
-  const ready = originBaseReady(cwd, base);
-  if (!ready.ok)
-    return ready;
-  return fastForwardBase(cwd, base);
+  if (matches.some((capability) => capability.assurance === "enforced"))
+    return { assurance: "enforced", reasons: matches.map((capability) => capability.reason) };
+  return { assurance: "agent_guided", reasons: matches.map((capability) => capability.reason) };
 };
-var classifyBranchDirt = (workspaceRoot) => {
-  let raw;
-  try {
-    raw = execFileSync3("git", ["status", "--porcelain=v1"], {
-      cwd: path23.resolve(workspaceRoot),
-      encoding: "utf8",
-      stdio: ["pipe", "pipe", "pipe"]
+function selectMethods(policy, capabilities) {
+  return Object.entries(METHODS).flatMap(([id, definition]) => {
+    const requirements = policy.requirements.filter((requirement) => methodMatches(definition, requirement));
+    if (requirements.length === 0)
+      return [];
+    const capability = assuranceFor(id, definition, capabilities);
+    const reasons = [
+      ...new Set(requirements.map((requirement) => requirement.reason)),
+      ...capability.reasons
+    ];
+    if (capability.assurance === "unavailable")
+      reasons.unshift("required capability is unavailable");
+    return [{ id, reason: reasons.join("; "), assurance: capability.assurance }];
+  });
+}
+
+// packages/workit-core/src/core/task-context.ts
+function reconcileResume(view, observations = []) {
+  if (observations.length > 0)
+    return failure("permission_denied", "worker observations require native host verification");
+  const candidate = captureCandidate(view.workspace.root, view.task.intent.data.scope, []);
+  if (!candidate.ok)
+    return candidate;
+  const staleEvidenceIds = evaluateEvidence(view.task, candidate.data).filter((entry) => entry.status === "stale").map((entry) => entry.evidenceId);
+  const blockers = [...view.task.progress.blockers];
+  if (view.task.workers.some((entry) => isUncertainWorker(entry.data.state)))
+    blockers.push({
+      reason: "worker state requires reconciliation",
+      dependentAction: "resume",
+      refs: []
     });
-  } catch {
-    return "clean";
-  }
-  let dirty = false;
-  for (const line of raw.split(`
-`)) {
-    if (!line.trim())
-      continue;
-    dirty = true;
-    const code = line.slice(0, 2);
-    if (code === "??")
-      continue;
-    let entry = line.slice(3);
-    const arrow = entry.indexOf(" -> ");
-    if (arrow >= 0)
-      entry = entry.slice(arrow + 4);
-    const unquoted = entry.startsWith('"') && entry.endsWith('"') ? entry.slice(1, -1) : entry;
-    if (unquoted !== "docs" && !unquoted.startsWith("docs/"))
-      return "stash-required";
-  }
-  return dirty ? "carry" : "clean";
-};
-var branchSetup = ({
-  action,
-  sdd_dir,
-  target_branch,
-  stash,
-  workspace_root,
-  log
-}) => {
-  const cwd = path23.resolve(workspace_root);
-  const exec = (args) => execFileSync3("git", args, { cwd, encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] });
-  const current = gitContext(cwd).branch;
-  if (!current || current === "unknown")
-    return { error: "not in a git repository", phase: "preflight" };
-  const sdd = sdd_dir ?? "docs";
-  const manifestPath = path23.isAbsolute(sdd) ? path23.join(sdd, "manifest.json") : path23.join(cwd, sdd, "manifest.json");
-  const ensureManifestDir = () => {
-    const dir = path23.dirname(manifestPath);
-    if (!existsSync16(dir))
-      mkdirSync8(dir, { recursive: true, mode: 493 });
-  };
-  const readManifest = () => {
-    try {
-      return JSON.parse(readFileSync16(manifestPath, "utf8"));
-    } catch {
-      return {};
-    }
-  };
-  const writeManifest = (data) => {
-    ensureManifestDir();
-    writeFileSync10(manifestPath, JSON.stringify(data, null, 2) + `
-`, "utf8");
-  };
-  const journal = (message) => log?.(`branch-setup: ${message}`);
-  if (action === "reapply_stash") {
-    const manifest = readManifest();
-    const ref = manifest.stash_ref;
-    if (!ref)
-      return { error: "no stash_ref in manifest", phase: "preflight" };
-    journal(`pre-pop: ${String(ref)}`);
-    try {
-      exec(["stash", "pop", String(ref)]);
-    } catch (error) {
-      journal("pop: failed");
-      return {
-        error: error instanceof Error ? error.message : "stash pop failed",
-        phase: "post_mutation"
-      };
-    }
-    journal("pop: ok");
-    delete manifest.stash_ref;
-    delete manifest.stash_created_at;
-    writeManifest(manifest);
-    return { action: "reapply_stash", ok: true };
-  }
-  const target = target_branch ?? "";
-  if (!target)
+  return success(null, null, {
+    candidate: candidate.data,
+    staleEvidenceIds,
+    workerUpdates: [],
+    blockers,
+    reassessmentRequired: view.task.policy?.policyVersion !== POLICY_VERSION
+  });
+}
+var COMPACT_MAX_BYTES = 4096;
+var COMPACT_MAX_ITEMS = 8;
+var COMPACT_TEXT_BYTES = 128;
+var sensitiveUrl = /\bhttps?:\/\/[^/\s:@]+:[^@\s]+@/gi;
+var sensitiveValue = /(?:token|secret|password|passwd|api[-_ ]?key|private[-_ ]?key|authorization)\s*[:=]\s*(?:bearer\s+)?\S+|\bbearer\s+\S+/gi;
+var privateKey = /-----BEGIN [^-]*PRIVATE KEY-----[\s\S]*?-----END [^-]*PRIVATE KEY-----/gi;
+var compactText = (value, limit) => value === null ? null : value.replace(privateKey, "<redacted-private-key>").replace(sensitiveUrl, "<redacted-url>").replace(sensitiveValue, (match) => {
+  const separator = match.search(/[:=]/u);
+  if (separator >= 0)
+    return `${match.slice(0, separator)}=<redacted>`;
+  const space = match.search(/\s/u);
+  return `${match.slice(0, space)} <redacted>`;
+}).slice(0, limit);
+var compactBytes = (value) => new TextEncoder().encode(value).byteLength;
+var compactReference = (ref) => {
+  if (ref.kind === "file")
     return {
-      error: "target_branch (the working branch to create or switch to) is required for setup",
-      phase: "preflight"
+      kind: "file",
+      path: compactText(ref.path, COMPACT_TEXT_BYTES) ?? ""
     };
-  if (isProtected(cwd, target))
-    return { error: `protected branch ${target}`, phase: "preflight" };
-  if (!allowedBranch(cwd, target))
+  if (ref.kind === "record")
     return {
-      error: `target branch ${target} is not allowed by the branch policy`,
-      phase: "preflight"
+      kind: "record",
+      collection: ref.collection,
+      id: ref.id
     };
-  let base;
-  let targetExists = true;
-  try {
-    exec(["rev-parse", "--verify", "--quiet", `refs/heads/${target}`]);
-  } catch {
-    targetExists = false;
-  }
-  if (!targetExists) {
-    const baseResolved = baseBranch(cwd);
-    if ("error" in baseResolved)
-      return { error: baseResolved.error, phase: "preflight" };
-    base = baseResolved.base;
-  }
-  journal(`entry: current=${current} target=${target} base=${base ?? "-"}`);
-  let stash_ref;
-  const failAfterStash = (message, phase = "post_mutation") => {
-    let suffix = "";
-    if (stash_ref) {
-      journal(`pre-pop: ${stash_ref}`);
-      try {
-        exec(["stash", "pop", stash_ref]);
-        stash_ref = undefined;
-        journal("pop: ok");
-      } catch {
-        journal("pop: failed");
-        suffix = " (changes preserved in stash)";
-      }
-    }
-    return { error: `${message}${suffix}`, phase: stash_ref ? "post_mutation" : phase };
+  return { kind: ref.kind };
+};
+function compactTaskContext(view) {
+  const decisions = view.task.decisions.slice().sort((left, right) => left.id < right.id ? -1 : left.id > right.id ? 1 : 0).slice(0, COMPACT_MAX_ITEMS).map((entry) => ({
+    id: entry.id,
+    purpose: entry.data.purpose,
+    status: entry.data.response,
+    digest: entry.data.digest,
+    references: entry.data.binding.contentRefs.slice(0, 1).map(compactReference)
+  }));
+  const methods = view.task.policy ? selectMethods(view.task.policy, view.capabilities).map((method) => ({
+    id: method.id,
+    assurance: method.assurance,
+    reason: compactText(method.reason, COMPACT_TEXT_BYTES) ?? ""
+  })) : [];
+  const gaps = Array.from(new Set([
+    ...view.evidence.filter((entry) => entry.status === "stale").map((entry) => `stale evidence: ${entry.evidenceId}`),
+    ...view.requirements.filter((entry) => entry.status !== "satisfied").map((entry) => entry.reason),
+    ...view.task.progress.blockers.map((entry) => entry.reason)
+  ])).sort().slice(0, COMPACT_MAX_ITEMS).map((gap) => compactText(gap, COMPACT_TEXT_BYTES));
+  const context = {
+    objective: compactText(view.task.intent.data.objective, COMPACT_TEXT_BYTES) ?? "",
+    status: view.task.status,
+    decisions,
+    methods,
+    gaps,
+    nextAction: compactText(view.task.progress.nextAction, COMPACT_TEXT_BYTES)
   };
-  if (current !== target) {
-    const dirty = Boolean(gitContext(cwd).status_short.trim());
-    if (classifyBranchDirt(cwd) === "stash-required" && stash !== "yes") {
-      return {
-        error: "dirty working tree — ask with native question, then call workit_branch_setup with stash=yes",
-        phase: "preflight"
-      };
-    }
-    let validatedBase;
-    if (!targetExists && base !== undefined) {
-      const ready = originBaseReady(cwd, base);
-      if (!ready.ok)
-        return { error: ready.error ?? "ensure-base-branch failed", phase: "preflight" };
-      validatedBase = base;
-    }
-    if (dirty && stash === "yes") {
-      try {
-        exec(["stash", "push", "-u", "-m", `workit: pre-checkout ${target}`]);
-      } catch (error) {
-        return {
-          error: error instanceof Error ? error.message : "stash push failed",
-          phase: "post_mutation"
-        };
-      }
-      stash_ref = "stash@{0}";
-      journal(`stash push: ${stash_ref}`);
-    }
-    try {
-      exec(["checkout", target]);
-      journal("post-checkout");
-    } catch (error) {
-      const message = error instanceof Error ? error.message : "checkout failed";
-      if (/worktree/i.test(message)) {
-        return failAfterStash(`branch ${target} is locked by an existing git worktree — remove it first (we do not use worktrees)`, "preflight");
-      }
-      try {
-        let effectiveBase = base;
-        if (effectiveBase === undefined) {
-          const lateResolved = baseBranch(cwd);
-          if ("error" in lateResolved)
-            return failAfterStash(lateResolved.error, "preflight");
-          effectiveBase = lateResolved.base;
-        }
-        const baseResult = validatedBase !== undefined ? fastForwardBase(cwd, effectiveBase) : ensureBaseBranch(cwd, effectiveBase);
-        if (!baseResult.ok)
-          return failAfterStash(baseResult.error ?? "ensure-base-branch failed");
-        exec(["checkout", "-b", target]);
-        journal("post-create");
-      } catch (createError) {
-        return failAfterStash(createError instanceof Error ? createError.message : "branch create failed");
-      }
-    }
+  let encoded = JSON.stringify(context);
+  while (compactBytes(encoded) > COMPACT_MAX_BYTES && (context.decisions.length || context.methods.length || context.gaps.length)) {
+    if (context.gaps.length)
+      context.gaps.pop();
+    else if (context.decisions.length)
+      context.decisions.pop();
+    else
+      context.methods.pop();
+    encoded = JSON.stringify(context);
   }
-  try {
-    const manifest = readManifest();
-    manifest.branch = target;
-    manifest.previous_branch = current;
-    if (stash_ref) {
-      manifest.stash_ref = stash_ref;
-      manifest.stash_created_at = new Date().toISOString();
-    }
-    writeManifest(manifest);
-  } catch (error) {
-    const result = failAfterStash(error instanceof Error ? `manifest update failed: ${error.message}` : "manifest update failed");
-    if (stash_ref === undefined && gitContext(cwd).branch !== current) {
-      try {
-        exec(["checkout", current]);
-      } catch {
-        try {
-          exec(["checkout", "-m", current]);
-        } catch {}
-      }
-    }
-    return result;
+  if (compactBytes(encoded) > COMPACT_MAX_BYTES) {
+    context.objective = compactText(context.objective, 64) ?? "";
+    context.nextAction = compactText(context.nextAction, 64);
+    encoded = JSON.stringify(context);
   }
-  return {
-    action: "setup",
-    ok: true,
-    branch: target,
-    previous_branch: current,
-    stash_ref: stash_ref ?? null,
-    manifest: manifestPath
-  };
-};
+  return encoded;
+}
+var exportDigest = (bundle) => sha256({
+  schemaVersion: bundle.schemaVersion,
+  exportedAt: bundle.exportedAt,
+  sourceWorkspaceId: bundle.sourceWorkspaceId,
+  task: bundle.task
+});
 // packages/workit-core/src/core/external-action.ts
 import { execFileSync as execFileSync4 } from "node:child_process";
 var externalActionSchema = discriminatedUnion("operation", [
@@ -60040,6 +60287,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({
@@ -60113,7 +60367,7 @@ var externalActionDescriptor = (operation, payload) => canonicalJson({
   payload,
   ...payload && typeof payload === "object" && !Array.isArray(payload) && "resolved" in payload && payload.resolved && typeof payload.resolved === "object" && Array.isArray(payload.resolved.steps) ? { steps: payload.resolved.steps } : {}
 });
-var externalActionHelp = "Fixed actions: git.branch_setup {action?,sdd_dir?,target_branch(required unless reapply_stash; the working branch to create or switch to),stash?}; git.commit {message}; git.push {branch?}; hosting.pull_request {title,body?,draft?,target_branch?,babysit?}; youtrack.update {issueId,markdown,minutes?}; youtrack.time {issueId,minutes,text?,dateMs?}; youtrack.meeting {issueId,minutes,text}; changelog.apply {entries?,path?,normalize_only?}; context.read {kind,range?,issueId?,issueUrl?,issueRef?,mode?,specPath?,planPath?}. context.read is read-only and needs no approval; all other operations require native approval (CLI uses a TTY; caller-unattested MCP cannot mutate).";
+var externalActionHelp = "Fixed actions: git.branch_setup {action?,sdd_dir?,target_branch(required unless reapply_stash; the working branch to create or switch to),stash?}; git.commit {message}; git.push {branch?}; hosting.pull_request {title,body?,draft?,target_branch?,babysit?}; hosting.merge {target_branch?,source_branch?}; youtrack.update {issueId,markdown,minutes?}; youtrack.time {issueId,minutes,text?,dateMs?}; youtrack.meeting {issueId,minutes,text}; changelog.apply {entries?,path?,normalize_only?}; context.read {kind,range?,issueId?,issueUrl?,issueRef?,mode?,specPath?,planPath?}. context.read is read-only and needs no approval; all other operations require native approval (CLI uses a TTY; caller-unattested MCP cannot mutate).";
 var externalActionRef = (host, actor, descriptor) => ({
   kind: "host",
   host,
@@ -61620,7 +61874,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;
@@ -61635,8 +61892,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;
@@ -61668,7 +61927,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,
@@ -61699,7 +61961,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, {
@@ -63120,10 +63382,58 @@ function prCreate(env, cwd) {
     output: (result.stdout ?? "").trim()
   };
 }
+function mergePr(cwd, opts) {
+  const root = repoRoot2(cwd);
+  const cfg = vcsConfig("load", root);
+  if (!cfg.ok)
+    return { error: cfg.error ?? "vcs config missing" };
+  if (!cfg.tokenReady)
+    return { error: "VCS token not ready — run /wk-init and edit token file locally" };
+  const provider = cfg.provider;
+  if (provider !== "gitlab" && provider !== "github")
+    return { error: `unsupported provider: ${provider}` };
+  if (!hostingCliAvailable(provider))
+    return { error: `workflow CLI missing (required for ${provider})` };
+  const pr = cfg.pr ?? {};
+  const token = fs11.readFileSync(cfg.tokenPath, "utf8").trim();
+  const squash = pr.squashOnMerge !== false;
+  const removeBranch = pr.removeSourceBranch !== false;
+  let cmd;
+  let cmdEnv;
+  if (provider === "gitlab") {
+    cmd = ["glab", "mr", "merge", opts.source];
+    cmd.push(squash ? "--squash" : "--squash=false");
+    if (removeBranch)
+      cmd.push("--remove-source-branch");
+    cmd.push("--yes");
+    cmdEnv = { ...process.env, PATH: process.env.PATH ?? "", GITLAB_TOKEN: token };
+  } else {
+    cmd = ["gh", "pr", "merge", opts.source];
+    cmd.push(squash ? "--squash" : "--merge");
+    if (removeBranch)
+      cmd.push("--delete-branch");
+    cmd.push("--yes");
+    cmdEnv = { ...process.env, PATH: process.env.PATH ?? "", GH_TOKEN: token };
+  }
+  const result = spawnSync6(cmd[0], cmd.slice(1), { cwd: root, encoding: "utf8", env: cmdEnv });
+  if (result.status !== 0)
+    return {
+      error: "merge failed",
+      provider,
+      stderr: (result.stderr ?? result.stdout ?? "").trim().slice(0, 800)
+    };
+  return {
+    ok: true,
+    provider,
+    targetBranch: opts.target,
+    sourceBranch: opts.source,
+    output: (result.stdout ?? "").trim()
+  };
+}
 
 // packages/workit-core/src/core/repo-context.ts
 import { spawnSync as spawnSync7 } from "node:child_process";
-import { existsSync as existsSync18, readFileSync as readFileSync17, readdirSync as readdirSync9 } from "node:fs";
+import { existsSync as existsSync18, readFileSync as readFileSync18, readdirSync as readdirSync9 } from "node:fs";
 import path26 from "node:path";
 var isSafeContextRange = (value) => value.length <= 4096 && (() => {
   try {
@@ -63293,7 +63603,7 @@ var packageScripts = (cwd, keys) => {
   if (!existsSync18(pkgPath))
     return [];
   try {
-    const pkg = JSON.parse(readFileSync17(pkgPath, "utf8"));
+    const pkg = JSON.parse(readFileSync18(pkgPath, "utf8"));
     return keys.filter((k) => pkg.scripts && typeof pkg.scripts[k] === "string").map((k) => `${k}: ${pkg.scripts?.[k]}`);
   } catch {
     return [];
@@ -63327,7 +63637,7 @@ var documentationFiles = (cwd) => {
 var readTrimmed = (file, maxLines) => {
   if (!existsSync18(file))
     return "";
-  const lines = readFileSync17(file, "utf8").split(`
+  const lines = readFileSync18(file, "utf8").split(`
 `);
   return lines.slice(0, maxLines).join(`
 `);
@@ -63515,7 +63825,7 @@ function docsRefreshContext(root, range) {
   const pkgPath = path26.join(cwd, "package.json");
   if (existsSync18(pkgPath)) {
     try {
-      const pkg = JSON.parse(readFileSync17(pkgPath, "utf8"));
+      const pkg = JSON.parse(readFileSync18(pkgPath, "utf8"));
       stdout += JSON.stringify({ name: pkg.name, version: pkg.version, scripts: pkg.scripts }, null, 2) + `
 `;
     } catch {}
@@ -64711,6 +65021,11 @@ var actionProposalQuestion = (request, descriptorPayload) => {
         presented: `Workit decision: action — Open a PR from \`${String(resolved.source_branch ?? "")}\` to \`${payloadTarget}\` titled "${String(request.payload.title)}"?`,
         approvedText: `Open the PR: ${String(resolved.source_branch ?? "")} → ${payloadTarget}, "${String(request.payload.title)}".`
       };
+    case "hosting.merge":
+      return {
+        presented: `Workit decision: action — Merge \`${String(resolved.source_branch ?? "")}\` into \`${payloadTarget}\` (squash, delete branch)?`,
+        approvedText: `Merge ${String(resolved.source_branch ?? "")} → ${payloadTarget}.`
+      };
     case "changelog.apply":
       return {
         presented: `Workit decision: action — Apply changelog changes at \`${String(payload.path ?? "CHANGELOG.md")}\`?`,
@@ -64741,7 +65056,7 @@ var actionProposalQuestion = (request, descriptorPayload) => {
 var approvedResolvedExternalAction = (content) => {
   try {
     const value = JSON.parse(content);
-    if (value.operation !== "hosting.pull_request" && value.operation !== "changelog.apply" && value.operation !== "youtrack.update" && value.operation !== "youtrack.time" && value.operation !== "youtrack.meeting")
+    if (value.operation !== "hosting.pull_request" && value.operation !== "hosting.merge" && value.operation !== "changelog.apply" && value.operation !== "youtrack.update" && value.operation !== "youtrack.time" && value.operation !== "youtrack.meeting")
       return failure("invalid_input", "approved action is not a reconciliable external action");
     if (!value.payload || typeof value.payload !== "object")
       return failure("invalid_input", "approved action payload is incomplete");
@@ -64754,6 +65069,8 @@ var approvedResolvedExternalAction = (content) => {
     const target = resolved;
     if (value.operation === "hosting.pull_request" && (typeof target.marker !== "string" || typeof target.source_branch !== "string" || typeof target.source_commit !== "string" || typeof target.remote !== "string" || typeof payload.target_branch !== "string"))
       return failure("invalid_input", "approved hosting target is incomplete");
+    if (value.operation === "hosting.merge" && (typeof target.marker !== "string" || typeof target.source_branch !== "string" || typeof target.source_commit !== "string" || typeof target.remote !== "string" || typeof payload.target_branch !== "string"))
+      return failure("invalid_input", "approved hosting target is incomplete");
     if (value.operation === "changelog.apply" && (typeof target.target !== "string" || typeof target.beforeDigest !== "string" || typeof target.beforeExists !== "boolean" || typeof target.afterDigest !== "string"))
       return failure("invalid_input", "approved changelog target is incomplete");
     if (value.operation !== "hosting.pull_request" && value.operation !== "changelog.apply" && (typeof target.marker !== "string" || typeof target.baseUrl !== "string" || typeof target.issueId !== "string" || !Array.isArray(target.steps)))
@@ -65045,6 +65362,11 @@ var resolveExternalActionRequest = (root, request, preservedDateMs) => {
       }
       case "git.push": {
         const branch = request.payload.branch ?? gitValue(root, ["branch", "--show-current"]);
+        if (branch && isProtectedBranch2(root, branch))
+          return failure("invalid_input", `cannot push protected branch ${branch}`, {
+            outcome: "not_started",
+            fields: [{ path: "branch", reason: "protected branch" }]
+          });
         const commit = branch ? gitValue(root, ["rev-parse", branch]) : null;
         const remote = pushRemote(root);
         const identity = remote ? credentialFreeRemote(remote) : null;
@@ -65142,6 +65464,11 @@ var resolveExternalActionRequest = (root, request, preservedDateMs) => {
       case "hosting.pull_request": {
         const target_branch = request.payload.target_branch ?? resolveBranchPolicyFor(root).defaultTargetBranch;
         const source_branch = gitValue(root, ["branch", "--show-current"]);
+        if (source_branch && isProtectedBranch2(root, source_branch))
+          return failure("invalid_input", `cannot open a PR from protected branch ${source_branch}`, {
+            outcome: "not_started",
+            fields: [{ path: "source_branch", reason: "protected branch" }]
+          });
         const source_commit = gitValue(root, ["rev-parse", "HEAD"]);
         const remote = pushRemote(root);
         const identity = remote ? credentialFreeRemote(remote) : null;
@@ -65173,6 +65500,44 @@ var resolveExternalActionRequest = (root, request, preservedDateMs) => {
           }
         });
       }
+      case "hosting.merge": {
+        const target_branch = request.payload.target_branch ?? resolveBranchPolicyFor(root).defaultTargetBranch;
+        const source_branch = request.payload.source_branch ?? gitValue(root, ["branch", "--show-current"]);
+        if (source_branch && isProtectedBranch2(root, source_branch))
+          return failure("invalid_input", `cannot merge protected branch ${source_branch}`, {
+            outcome: "not_started",
+            fields: [{ path: "source_branch", reason: "protected branch" }]
+          });
+        const source_commit = gitValue(root, ["rev-parse", "HEAD"]);
+        const remote = pushRemote(root);
+        const identity = remote ? credentialFreeRemote(remote) : null;
+        if (!source_branch || !source_commit || !identity || remoteProvider2(identity) !== null && remoteProvider2(identity) !== String(vcsConfig("load", root).provider).toLowerCase())
+          return failure("capability_unavailable", "hosting target is not bound to the configured remote provider", { capability: "hosting.merge" });
+        const vcs = vcsConfig("load", root);
+        if (!vcs.ok || !vcs.tokenReady)
+          return failure("capability_unavailable", "hosting credentials are unavailable", {
+            capability: "hosting.merge",
+            outcome: "not_started"
+          });
+        if (!hostingCliAvailable(String(vcs.provider)))
+          return failure("capability_unavailable", "hosting CLI is unavailable", {
+            capability: "hosting.merge",
+            outcome: "not_started"
+          });
+        const normalized = {
+          operation: request.operation,
+          payload: { ...request.payload, target_branch, source_branch }
+        };
+        const marker = `<!-- workit-action:${sha256({ operation: request.operation, payload: normalized.payload, source_commit, remote: identity })} -->`;
+        return success(null, null, {
+          request: normalized,
+          marker,
+          descriptorPayload: {
+            ...normalized.payload,
+            resolved: { source_branch, source_commit, remote: identity, target_branch, marker }
+          }
+        });
+      }
       case "changelog.apply": {
         const preview = changelogApplyPreview({ ...request.payload, workspace_root: root });
         if (preview.error)
@@ -65348,6 +65713,17 @@ var executeConcreteExternalAction = async (request, root, marker, dateMs, step,
         ...request.payload.babysit ?? true ? { next: prBabysitNext(String(result.output ?? "")) } : {}
       });
     }
+    case "hosting.merge": {
+      const target = String(request.payload.target_branch ?? "");
+      const source = String(request.payload.source_branch ?? "");
+      if (!target || !source)
+        return failure("invalid_input", "hosting.merge requires target and source branches", {
+          outcome: "not_started",
+          fields: [{ path: "target_branch", reason: "required" }]
+        });
+      const result = mergePr(root, { target, source });
+      return result.error || result.ok === false ? unknown2(request.operation) : success(null, null, result);
+    }
     case "changelog.apply": {
       const preview = changelogApplyPreview({ ...request.payload, workspace_root: root });
       if (preview.error || approvedBeforeDigest !== undefined && preview.beforeDigest !== approvedBeforeDigest || approvedBeforeExists !== undefined && preview.beforeExists !== approvedBeforeExists)
@@ -65472,7 +65848,7 @@ async function payloadValue(raw, deps) {
     return { ok: true, value: {} };
   let source;
   try {
-    source = raw === "-" ? await readInput(deps.stdin ?? process.stdin) : raw.startsWith("@") ? decodeUtf8(readFileSync18(raw.slice(1))) : raw;
+    source = raw === "-" ? await readInput(deps.stdin ?? process.stdin) : raw.startsWith("@") ? decodeUtf8(readFileSync19(raw.slice(1))) : raw;
   } catch (error) {
     return {
       ok: false,
@@ -65815,7 +66191,7 @@ var nativeExternalActionRunner = (root, actor, core, step) => createAuthorizedEx
   const store = new TaskStore(root);
   const approved = approvedExternalAction(store, "workit_cli", actor, operationValue);
   if (!approved.ok) {
-    const plan = planCommitBinding(store, "workit_cli", actor, operationValue) ?? chainStepBinding(store, "workit_cli", actor, operationValue);
+    const plan = planCommitBinding(store, "workit_cli", actor, operationValue) ?? chainStepBinding(store, "workit_cli", actor, operationValue) ?? standingAutoBinding(core, store, "workit_cli", actor, operationValue);
     if (plan) {
       const actionRef = externalActionRef("workit_cli", actor, operationValue);
       return {
@@ -65944,7 +66320,10 @@ async function runActionCommand(argv, deps = {}) {
     return result.ok ? 0 : 1;
   }
   const tty = deps.stdinIsTTY ? deps.stdinIsTTY() : process.stdin.isTTY === true;
-  if (!tty || !argv.includes("--confirm")) {
+  const actor = deps.actor ?? "cli";
+  const store = new TaskStore(root);
+  const autoApplies = standingAutoApplies(store, "workit_cli", actor, descriptor);
+  if ((!tty || !argv.includes("--confirm")) && !autoApplies) {
     const result = failure("needs_input", "TTY confirmation is required for external actions", {
       operation: normalized.operation
     });
@@ -65954,8 +66333,6 @@ async function runActionCommand(argv, deps = {}) {
       printHuman(result, deps);
     return 1;
   }
-  const actor = deps.actor ?? "cli";
-  const store = new TaskStore(root);
   const taskId = taskIndex >= 0 ? argv[taskIndex + 1] : undefined;
   const listed = store.listTasks();
   const workspace = store.readWorkspace();
@@ -66059,6 +66436,7 @@ async function runActionCommand(argv, deps = {}) {
     "git.commit",
     "git.push",
     "hosting.pull_request",
+    "hosting.merge",
     "changelog.apply"
   ].includes(normalized.operation);
   if (localOperation) {
@@ -66094,6 +66472,20 @@ async function runActionCommand(argv, deps = {}) {
       printHuman(result, deps);
     return result.ok ? 0 : 1;
   }
+  if (standingAutoApplies(store, "workit_cli", actor, descriptor)) {
+    const core = new WorkitCore(store, {
+      ...contextFor(root, { ...deps, actor }, "host_observed"),
+      nativeAuthority: cliActionAuthority(actor),
+      workerId: null
+    });
+    const runner = nativeExternalActionRunner(root, actor, core);
+    const result = await runner(descriptor, (step) => executeResolvedExternalAction(resolved.data, root, step, { host: "workit_cli", actor }));
+    if (json)
+      jsonResult(outOf(deps), result);
+    else
+      printHuman(result, deps);
+    return result.ok ? 0 : 1;
+  }
   if (!json)
     write2(outOf(deps), question.presented);
   const accepted = await observeConsent(deps);