@brainervirus/workit-codex 1.0.11 → 1.0.12

package/dist/launch-mcp.js

@@ -6625,9 +6625,9 @@ import { existsSync as existsSync8, realpathSync as realpathSync8, statSync as s
 import path15 from "node:path";
 
 // packages/workit-core/src/core.ts
-import { spawnSync as spawnSync2 } from "node:child_process";
-import { existsSync as existsSync4, realpathSync as realpathSync5 } from "node:fs";
-import path7 from "node:path";
+import { spawnSync as spawnSync3 } from "node:child_process";
+import { existsSync as existsSync5, realpathSync as realpathSync6 } from "node:fs";
+import path10 from "node:path";
 
 // packages/workit-core/src/core/task-contract.ts
 import { createHash, randomUUID } from "node:crypto";
@@ -14201,6 +14201,89 @@ var refSchema = discriminatedUnion("kind", [
   object({ kind: literal("host"), host: hostSchema, handle: nonEmpty }).strict(),
   object({ kind: literal("external"), url: text.url() }).strict()
 ]);
+var rewriteUnknown = (value, map) => {
+  if (Array.isArray(value)) {
+    const out = [];
+    for (const item of value) {
+      const rewritten = rewriteUnknown(item, map);
+      if (!rewritten.drop)
+        out.push(rewritten.value);
+    }
+    return { drop: false, value: out };
+  }
+  if (typeof value === "object" && value !== null) {
+    if (refSchema.safeParse(value).success) {
+      const mapped = map(value);
+      return mapped === null ? { drop: true } : { drop: false, value: mapped };
+    }
+    const out = {};
+    for (const [key, item] of Object.entries(value)) {
+      const rewritten = rewriteUnknown(item, map);
+      out[key] = rewritten.drop ? null : rewritten.value;
+    }
+    return { drop: false, value: out };
+  }
+  return { drop: false, value };
+};
+var rewriteNode = (value, schema, map) => {
+  if (typeof value === "object" && value !== null && !Array.isArray(value) && refSchema.safeParse(value).success) {
+    const mapped = map(value);
+    return mapped === null ? { drop: true } : { drop: false, value: mapped };
+  }
+  let node = schema;
+  while (node instanceof ZodNullable || node instanceof ZodOptional || node instanceof ZodDefault) {
+    node = node.unwrap();
+  }
+  if (node === refSchema) {
+    if (!refSchema.safeParse(value).success)
+      return { drop: false, value };
+    const mapped = map(value);
+    return mapped === null ? { drop: true } : { drop: false, value: mapped };
+  }
+  if (node instanceof ZodArray) {
+    if (!Array.isArray(value))
+      return { drop: false, value };
+    const out = [];
+    for (const item of value) {
+      const rewritten = rewriteNode(item, node.element, map);
+      if (!rewritten.drop)
+        out.push(rewritten.value);
+    }
+    return { drop: false, value: out };
+  }
+  if (node instanceof ZodObject) {
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+      return { drop: false, value };
+    const shape = node.shape;
+    const record = value;
+    const out = {};
+    for (const [key, item] of Object.entries(record)) {
+      if (!(key in shape)) {
+        const scrubbed = rewriteUnknown(item, map);
+        out[key] = scrubbed.drop ? null : scrubbed.value;
+        continue;
+      }
+      const child = shape[key];
+      const rewritten = rewriteNode(item, child, map);
+      if (rewritten.drop) {
+        if (child instanceof ZodOptional || child instanceof ZodDefault)
+          continue;
+        if (child instanceof ZodNullable) {
+          out[key] = null;
+          continue;
+        }
+        return { drop: true };
+      }
+      out[key] = rewritten.value;
+    }
+    return { drop: false, value: out };
+  }
+  return { drop: false, value };
+};
+var rewriteRecordRefs = (value, schema, map) => {
+  const rewritten = rewriteNode(value, schema, map);
+  return rewritten.drop ? null : rewritten.value;
+};
 var provenanceSchema = object({
   kind: _enum(["host_observed", "agent_reported", "imported"]),
   host: hostSchema,
@@ -15912,11 +15995,11 @@ class TaskStore {
         return workspace;
       if (!workspace.data)
         return failure("not_found", "workspace not found");
-      const expectedTaskRevision = input.expectedTaskRevision ?? input.expectedRevision;
-      if (!expectedTaskRevision)
+      const expected = input.expectedRevision;
+      if (!expected)
         return failure("invalid_input", "task revision is required");
-      if (task.data.revision !== expectedTaskRevision)
-        return this.conflict(expectedTaskRevision, task.data.revision);
+      if (task.data.revision !== expected)
+        return this.conflict(expected, task.data.revision);
       if (workspace.data.revision !== input.expectedWorkspaceRevision)
         return this.conflict(input.expectedWorkspaceRevision, workspace.data.revision);
       const previousWorkspaceBytes = this.snapshotBytes(this.workspacePath);
@@ -16450,6 +16533,7 @@ var same = (left, right) => {
 };
 var UNCERTAIN_WORKER_STATES = ["dispatching", "running", "cancelling", "unknown"];
 var isUncertainWorker = (state) => UNCERTAIN_WORKER_STATES.includes(state);
+var workerBlocksTransition = (transition, state) => transition === "pause" ? false : isUncertainWorker(state);
 var callerSession = (caller) => caller.session ?? { kind: "host", host: caller.host, handle: caller.actor };
 var validPath = (value) => typeof value === "string" && value.length > 0 && ![...value].some((char) => {
   const code = char.charCodeAt(0);
@@ -16511,6 +16595,36 @@ var trustedAuthority = (kind, provenance, expected, binding, caller) => {
   verifiedAuthorities.set(token, { kind, provenance, ...expected, ...binding, caller });
   return token;
 };
+var chainStepKey = (step) => step.kind === "commit" ? step.message : step.kind === "branch" ? `branch:${step.target}` : "pr";
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var normalizeChainSteps = (steps) => {
+  if (!Array.isArray(steps) || steps.length === 0 || steps.length > 32)
+    return null;
+  const normalized = [];
+  for (const step of steps) {
+    if (typeof step === "string") {
+      if (!step.trim())
+        return null;
+      normalized.push({ kind: "commit", message: step });
+      continue;
+    }
+    if (!isRecord(step))
+      return null;
+    if (typeof step.branch === "string" && step.branch.trim() && Object.keys(step).length === 1) {
+      normalized.push({ kind: "branch", target: step.branch });
+      continue;
+    }
+    if (step.pr === true && Object.keys(step).length === 1) {
+      normalized.push({ kind: "pr" });
+      continue;
+    }
+    return null;
+  }
+  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;
@@ -16522,7 +16636,10 @@ var parseSteps = (content) => {
   if (typeof value !== "object" || value === null || !("steps" in value))
     return [];
   const steps = value.steps;
-  return Array.isArray(steps) && steps.every((step) => typeof step === "string") ? steps : null;
+  if (!Array.isArray(steps))
+    return null;
+  const normalized = normalizeChainSteps(steps);
+  return normalized;
 };
 var decisionMatches = (entry, purpose, binding) => {
   const decision = entry.data;
@@ -16713,14 +16830,12 @@ var validateAction = (store, task, workspaceId, input, authority) => {
     return content;
   const requestedSteps = parseSteps(decision.binding.approvedContent);
   if (requestedSteps === null)
-    return failure("invalid_input", "bounded action steps must be a string array");
-  if (input.steps && canonicalJson(input.steps) !== canonicalJson(requestedSteps))
+    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");
-  if (requestedSteps.some((step) => !step || typeof step !== "string") || new Set(requestedSteps).size !== requestedSteps.length)
-    return failure("invalid_input", "bounded action steps must be unique and non-empty");
   const stored = task.actionProgress?.find((item) => item.decisionId === input.decisionId);
-  const workflow = stored ? { steps: stored.steps, completed: stored.completedSteps } : { steps: requestedSteps, completed: [] };
-  if (workflow.steps.length && requestedSteps.length && canonicalJson(workflow.steps) !== canonicalJson(requestedSteps))
+  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 });
 };
@@ -17275,13 +17390,28 @@ function evaluateEvidence(task, candidate) {
   });
 }
 var scopeCovers2 = scopeCovers;
+var checkPin = (assignment, beforeCandidateId, candidateId) => {
+  const pin = assignment.candidateId ?? null;
+  if (pin === null)
+    return true;
+  return (beforeCandidateId ?? null) === pin || (candidateId ?? null) === pin;
+};
+var resolveBinding = (evidence, pin, currentCandidateId) => {
+  const bound = evidence.kind === "check" || evidence.kind === "review";
+  const fallback = bound ? pin ?? currentCandidateId : null;
+  return {
+    beforeCandidateId: evidence.beforeCandidateId ?? fallback,
+    candidateId: evidence.candidateId ?? fallback
+  };
+};
+var findingVerificationPasses = (findingCandidateId, evidence) => evidence.status === "passed" && (evidence.kind === "check" || evidence.kind === "review") && ((findingCandidateId ?? null) === null || evidence.candidateId === findingCandidateId);
 var applicableDecision2 = (task, workspace, requirement, checkoutRoot) => task.decisions.filter((entry) => entry.provenance.kind !== "imported").map((entry) => entry.data).filter((decision) => decision.purpose === "limitation" && decision.response === "approved" && decision.revoked === null && decision.binding.taskId === task.id && decision.binding.workspaceId === workspace.id && decision.requirementIds.includes(requirement.id) && decision.binding.scope && scopeCovers2(decision.binding.scope, requirement.scope) && decision.digest === decisionDigest(decision) && (checkoutRoot ? verifyDecisionContentAtRoot(checkoutRoot, decision.binding).ok : decision.binding.contentRefs.every((reference) => reference.kind !== "file")));
 var applicableRequirementDecision = (task, workspace, requirement, checkoutRoot) => task.decisions.filter(({ data, provenance }) => provenance.kind !== "imported" && data.purpose !== "limitation" && (data.response === "approved" || data.response === "stated") && data.revoked === null && data.binding.taskId === task.id && data.binding.workspaceId === workspace.id && data.requirementIds.includes(requirement.id) && scopeCovers2(data.binding.scope, requirement.scope) && data.digest === decisionDigest(data) && (checkoutRoot ? verifyDecisionContentAtRoot(checkoutRoot, data.binding).ok : data.binding.contentRefs.every((reference) => reference.kind !== "file"))).map(({ id }) => ({ id }));
-var evidenceMatchesRequirement = (kind, evidenceKind, dimension) => {
+var evidenceMatchesRequirement = (kind, evidenceKind, dimension, ruleId) => {
   if (kind !== "passed")
     return false;
   if (dimension === "testing" || dimension === "verification")
-    return evidenceKind === "check";
+    return evidenceKind === "check" || ruleId === "pre-pr-cleanup" && evidenceKind === "artifact";
   if (dimension === "review")
     return evidenceKind === "review";
   if (dimension === "investigation" || dimension === "challenge")
@@ -17290,6 +17420,21 @@ var evidenceMatchesRequirement = (kind, evidenceKind, dimension) => {
     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)
@@ -17303,7 +17448,7 @@ function evaluateRequirements(task, workspace, capabilities, candidate, checkout
   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))
+      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;
@@ -17311,11 +17456,12 @@ function evaluateRequirements(task, workspace, capabilities, candidate, checkout
         return true;
       const reviewSession = sessionFromRef(entry.data.reviewContext);
       const sameImplementation = sameSession(reviewSession, task.intent.provenance.session);
-      const sameEvidenceSession = task.evidence.some((other) => other.id !== entry.id && other.data.kind === "review" && sameSession(reviewSession, other.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 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)) : passed;
+      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,
@@ -17364,6 +17510,14 @@ function evaluateRequirements(task, workspace, capabilities, candidate, checkout
         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",
@@ -17388,7 +17542,13 @@ function evaluateClosure(requestedOutcome, view) {
       if (entry.data.disposition === "fixed") {
         const verified = entry.data.resolution?.evidenceIds.some((id) => {
           const evidence = view.task.evidence.find((item) => item.id === id);
-          return evidenceById.get(id) === "passed" && (evidence?.data.kind === "check" || evidence?.data.kind === "review");
+          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");
@@ -17404,7 +17564,12 @@ function evaluateClosure(requestedOutcome, view) {
       }
     }
   }
-  const blocking = evaluations.filter((item) => item.status === "unsatisfied" || item.status === "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),
@@ -17473,197 +17638,755 @@ var exportDigest = (bundle) => sha256({
   sourceWorkspaceId: bundle.sourceWorkspaceId,
   task: bundle.task
 });
-// packages/workit-core/src/core/external-action.ts
-var externalActionSchema = discriminatedUnion("operation", [
-  object({
-    operation: literal("git.branch_setup"),
-    payload: object({
-      action: _enum(["setup", "reapply_stash"]).optional(),
-      sdd_dir: string2().optional(),
-      target_branch: string2().optional(),
-      stash: _enum(["yes", "no"]).optional()
-    }).strict()
-  }).strict(),
-  object({
-    operation: literal("git.commit"),
-    payload: object({
-      message: string2().min(1).optional(),
-      plan_steps: array(string2().min(1)).optional(),
-      plan_branch: string2().min(1).optional()
-    }).strict()
-  }).strict(),
-  object({
-    operation: literal("git.push"),
-    payload: object({ branch: string2().min(1).optional() }).strict()
-  }).strict(),
-  object({
-    operation: literal("hosting.pull_request"),
-    payload: object({
-      title: string2().min(1),
-      body: string2().optional(),
-      draft: boolean2().optional(),
-      target_branch: string2().optional(),
-      babysit: boolean2().optional()
-    }).strict()
-  }).strict(),
-  object({
-    operation: literal("youtrack.update"),
-    payload: object({
-      issueId: string2().min(1),
-      markdown: string2().min(1),
-      minutes: number2().positive().optional()
-    }).strict()
-  }).strict(),
-  object({
-    operation: literal("youtrack.time"),
-    payload: object({
-      issueId: string2().min(1),
-      minutes: number2().positive(),
-      text: string2().optional(),
-      dateMs: number2().finite().optional()
-    }).strict()
-  }).strict(),
-  object({
-    operation: literal("youtrack.meeting"),
-    payload: object({
-      issueId: string2().min(1),
-      minutes: number2().positive(),
-      text: string2().min(1)
-    }).strict()
-  }).strict(),
-  object({
-    operation: literal("changelog.apply"),
-    payload: object({
-      entries: union([
-        record(string2(), array(string2())),
-        array(object({ category: string2().min(1), text: string2().min(1) }).strict())
-      ]).optional(),
-      path: string2().optional(),
-      normalize_only: boolean2().optional()
-    }).strict()
-  }).strict(),
-  object({
-    operation: literal("context.read"),
-    payload: object({
-      kind: _enum([
-        "git",
-        "pr",
-        "youtrack",
-        "github_issue",
-        "gitlab_issue",
-        "changelog",
-        "release",
-        "affected"
-      ]),
-      range: string2().optional(),
-      issueId: string2().optional(),
-      issueUrl: string2().optional(),
-      issueRef: string2().optional(),
-      mode: string2().optional(),
-      specPath: string2().optional(),
-      planPath: string2().optional()
-    }).strict()
-  }).strict()
-]);
-// packages/workit-core/src/core/task-engine.ts
-import { realpathSync as realpathSync4 } from "node:fs";
-
-// packages/workit-core/src/core/policy-resolver.ts
-var resolverInputSchema = object({
-  intent: intentSchema,
-  assessment: assessmentSchema,
-  constraints: array(constraintSchema),
-  prior: object({
-    decisions: array(decisionSchema),
-    findings: array(findingSchema),
-    requirements: array(requirementSchema)
-  }).strict(),
-  preferences: object({ fast: boolean2().optional(), thorough: boolean2().optional() }).strict().optional()
-}).strict();
-var compareCodeUnits3 = (left, right) => {
-  const length = Math.min(left.length, right.length);
-  for (let index = 0;index < length; index += 1) {
-    const difference = left.charCodeAt(index) - right.charCodeAt(index);
-    if (difference !== 0)
-      return difference;
+// packages/workit-core/src/core/git.ts
+import { execFileSync } from "node:child_process";
+var run = (cwd, args) => {
+  try {
+    const stdout = execFileSync("git", args, {
+      cwd,
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return { stdout: stdout.trimEnd(), stderr: "", exitCode: 0 };
+  } catch (error) {
+    const e = error;
+    return {
+      stdout: (e.stdout ?? "").trimEnd(),
+      stderr: (e.stderr ?? "").trimEnd(),
+      exitCode: e.status ?? 1
+    };
   }
-  return left.length - right.length;
 };
-var stableUnique = (values) => [...new Set(values)].sort(compareCodeUnits3);
-var stableList = (values) => [...values].sort((left, right) => compareCodeUnits3(canonicalJson(left), canonicalJson(right)));
-var normalizedScope = (scope) => ({
-  description: scope.description,
-  paths: stableUnique(scope.paths),
-  exclusions: stableUnique(scope.exclusions)
-});
-var normalizedRefList = (values) => stableList(values);
-var normalizeAssessment = (assessment) => ({
-  facts: stableList(assessment.facts.map((fact) => ({ ...fact, refs: normalizedRefList(fact.refs) }))),
-  signals: Object.fromEntries(Object.entries(assessment.signals).map(([name, signal]) => [
-    name,
-    { ...signal, refs: normalizedRefList(signal.refs) }
-  ])),
-  consequences: stableList(assessment.consequences.map((consequence) => ({
-    ...consequence,
-    fact: { ...consequence.fact, refs: normalizedRefList(consequence.fact.refs) }
-  }))),
-  verification: stableList(assessment.verification.map((verification) => ({
-    ...verification,
-    scope: normalizedScope(verification.scope),
-    availableChecks: normalizedRefList(verification.availableChecks),
-    gaps: stableUnique(verification.gaps)
-  })))
-});
-var normalizeConstraint = (constraint) => ({
-  ...constraint,
-  source: constraint.source,
-  requires: stableList(constraint.requires.map((requirement) => ({
-    ...requirement,
-    scope: normalizedScope(requirement.scope),
-    refs: normalizedRefList(requirement.refs)
-  })))
-});
-var normalizeDecision = (decision) => ({
-  ...decision,
-  binding: {
-    ...decision.binding,
-    scope: normalizedScope(decision.binding.scope),
-    contentRefs: normalizedRefList(decision.binding.contentRefs)
-  },
-  requirementIds: stableUnique(decision.requirementIds)
-});
-var normalizeIntent = (intent) => ({
-  ...intent,
-  scope: normalizedScope(intent.scope),
-  authorityRefs: normalizedRefList(intent.authorityRefs)
-});
-var normalizePrior = (prior) => ({
-  decisions: stableList(prior.decisions.map(normalizeDecision)),
-  findings: stableList(prior.findings.map((finding) => ({
-    ...finding,
-    scope: normalizedScope(finding.scope),
-    refs: normalizedRefList(finding.refs),
-    resolution: finding.resolution ? {
-      ...finding.resolution,
-      evidenceIds: stableUnique(finding.resolution.evidenceIds),
-      decisionIds: stableUnique(finding.resolution.decisionIds)
-    } : null
-  }))),
-  requirements: stableList(prior.requirements.map((requirement) => ({
-    ...requirement,
-    scope: normalizedScope(requirement.scope)
-  })))
-});
-var invalidFields = (error) => ({
-  fields: error.issues.map((issue) => ({
-    path: issue.code === "unrecognized_keys" ? issue.keys.join(".") : issue.path.join("."),
-    reason: issue.message
-  }))
-});
-function normalizeResolverInput(input) {
-  const parsed = resolverInputSchema.safeParse(input);
-  if (!parsed.success)
-    return failure("invalid_input", "resolver input is invalid", invalidFields(parsed.error));
+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));
+  return {
+    workspace_root: cwd,
+    branch,
+    status_short,
+    staged,
+    unstaged,
+    untracked,
+    diff_stat: [diff_stat, cached_stat].filter(Boolean).join(`
+`),
+    partial_staged: partial_staged.length > 0,
+    partial_staged_files: partial_staged,
+    ...failure ? { stderr: failure.stderr, exitCode: failure.exitCode } : {}
+  };
+};
+
+// packages/workit-core/src/core/config.ts
+import {
+  copyFileSync,
+  cpSync,
+  existsSync as existsSync4,
+  mkdirSync as mkdirSync2,
+  readFileSync as readFileSync4,
+  readdirSync as readdirSync3,
+  writeFileSync as writeFileSync2
+} from "node:fs";
+import os from "node:os";
+import path7 from "node:path";
+
+// packages/workit-core/src/core/boundary.ts
+import { statSync } from "node:fs";
+var EVENT = {
+  initialization: "initialization",
+  provenance: "provenance",
+  assets: "assets",
+  configurationSource: "configuration_source",
+  hooks: "hooks",
+  mcpConnection: "mcp_connection",
+  migration: "migration",
+  installSteps: "install_steps",
+  uncaughtFailure: "uncaught_failure",
+  toolsFailed: "tools_failed",
+  doctor: "doctor"
+};
+var errorDetail = (err) => {
+  if (err instanceof Error) {
+    return { error_name: err.name, error: err.message };
+  }
+  return { error_name: "unknown", error: String(err) };
+};
+var markSourcesLoaded = (files, loadedAt = Date.now()) => ({
+  loadedAt,
+  files: [...files]
+});
+var changedSourcesSinceLoad = (marker) => {
+  const changed = [];
+  for (const file of marker.files) {
+    try {
+      if (statSync(file).mtimeMs > marker.loadedAt)
+        changed.push(file);
+    } catch {}
+  }
+  return changed;
+};
+
+// packages/workit-core/src/core/config.ts
+var diagnosticLogger;
+var PRESETS = {
+  gitflow: {
+    allowed: ["feature/*", "bugfix/*", "hotfix/*", "release/*"],
+    protected: ["main", "develop", "master", "prod", "production"]
+  },
+  "github-flow": { allowed: ["*"], protected: ["main"] },
+  "trunk-based": { allowed: ["*"], protected: ["main"] },
+  custom: { allowed: [], protected: [] }
+};
+var mergePreset = (preset, input = {}, current = {
+  branchPolicy: { preset, allowed: [], protected: [] }
+}) => {
+  const defs = PRESETS[preset];
+  return {
+    preset,
+    allowed: preset === "custom" ? input.allowed ?? current.branchPolicy.allowed : [...defs.allowed],
+    protected: preset === "custom" ? input.protectedNames ?? current.branchPolicy.protected : [...defs.protected]
+  };
+};
+var resolveConfigDir = () => process.env.WORKFLOW_TOOLKIT_CONFIG ?? process.env.WORKFLOW_TOOLKIT_CONFIG_DIR ?? path7.join(process.env.XDG_CONFIG_HOME || path7.join(os.homedir(), ".config"), "workit");
+var migratedDir = null;
+var migrationFailed = false;
+var ensureConfigDir = (dir = resolveConfigDir()) => {
+  if (migratedDir === dir)
+    return dir;
+  if (process.env.WORKFLOW_TOOLKIT_CONFIG || process.env.WORKFLOW_TOOLKIT_CONFIG_DIR) {
+    migratedDir = dir;
+    return dir;
+  }
+  const legacy = path7.join(process.env.XDG_CONFIG_HOME || path7.join(os.homedir(), ".config"), "workflow-toolkit");
+  if (!existsSync4(legacy)) {
+    migratedDir = dir;
+    return dir;
+  }
+  if (!migrationFailed && existsSync4(dir)) {
+    migratedDir = dir;
+    return dir;
+  }
+  migrationFailed = false;
+  mkdirSync2(dir, { recursive: true });
+  diagnosticLogger?.info(EVENT.migration, { from: legacy, to: dir });
+  for (const entry of readdirSync3(legacy, { withFileTypes: true })) {
+    const src = path7.join(legacy, entry.name);
+    const dest = path7.join(dir, entry.name);
+    if (existsSync4(dest))
+      continue;
+    try {
+      if (entry.isDirectory())
+        cpSync(src, dest, { recursive: true });
+      else if (entry.isFile())
+        copyFileSync(src, dest);
+    } catch (err) {
+      migrationFailed = true;
+      diagnosticLogger?.warn(EVENT.migration, { from: src, ok: false, ...errorDetail(err) });
+      console.warn(`[workit] config migration: a file could not be copied to ${dir}; it will be retried on the next run`);
+    }
+  }
+  if (!migrationFailed)
+    migratedDir = dir;
+  return dir;
+};
+var configDir = () => ensureConfigDir();
+var LOCALE_RE = /^[a-z]{2,3}(-(?:[A-Z]{2}|[0-9]{3}))?$/;
+var DEFAULTS = {
+  locale: "en",
+  localeOptions: ["en", "es-CL", "es-MX", "es-AR", "pt-BR"],
+  timezone: "America/Santiago",
+  branchPolicy: {
+    preset: "gitflow",
+    allowed: [...PRESETS.gitflow.allowed],
+    protected: [...PRESETS.gitflow.protected]
+  },
+  commitPolicy: { preset: "conventional" }
+};
+var readSafe = (p) => {
+  try {
+    return readFileSync4(p, "utf8");
+  } catch {
+    return null;
+  }
+};
+var isConfigObject = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+var parseConfigResult = (raw, file) => {
+  if (raw === null)
+    return { status: "missing", path: file };
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return { status: "malformed", path: file, error: `${file} is not valid JSON` };
+  }
+  if (!isConfigObject(parsed)) {
+    return { status: "malformed", path: file, error: `${file} is not a JSON object` };
+  }
+  const input = parsed;
+  const locale = LOCALE_RE.test(String(input.locale ?? "")) ? input.locale : DEFAULTS.locale;
+  const preset = Object.hasOwn(PRESETS, input.branchPolicy?.preset) ? input.branchPolicy?.preset : "gitflow";
+  const commitPreset = COMMIT_PRESETS.includes(String(input.commitPolicy?.preset ?? "")) ? input.commitPolicy?.preset : "conventional";
+  return {
+    status: "valid",
+    path: file,
+    config: {
+      locale,
+      localeOptions: Array.isArray(input.localeOptions) ? input.localeOptions : DEFAULTS.localeOptions,
+      timezone: input.timezone ?? DEFAULTS.timezone,
+      branchPolicy: mergePreset(preset, {
+        allowed: Array.isArray(input.branchPolicy?.allowed) ? input.branchPolicy.allowed : undefined,
+        protectedNames: Array.isArray(input.branchPolicy?.protected) ? input.branchPolicy.protected : undefined
+      }, DEFAULTS),
+      commitPolicy: {
+        preset: commitPreset,
+        ...typeof input.commitPolicy?.pattern === "string" ? { pattern: input.commitPolicy.pattern } : {}
+      }
+    }
+  };
+};
+var readConfigTyped = (dir) => {
+  const file = path7.join(dir ?? configDir(), "config.json");
+  return parseConfigResult(readSafe(file), file);
+};
+var readConfig = () => {
+  const result = readConfigTyped();
+  if (result.status === "malformed")
+    throw new Error(result.error);
+  return result.config ?? DEFAULTS;
+};
+var resolveBranchPolicy = (config, workspace) => {
+  const wp = workspace?.branchPolicy ?? {};
+  const preset = Object.hasOwn(PRESETS, wp.preset) ? wp.preset : config.branchPolicy?.preset ?? "gitflow";
+  const merged = mergePreset(preset, {
+    allowed: wp.allowed,
+    protectedNames: wp.protected
+  }, config);
+  const allowed = merged.allowed.map((p) => new RegExp(`^${p.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*")}$`, "i"));
+  return {
+    preset,
+    allowed,
+    protected: new Set(merged.protected.map((p) => p.toLowerCase())),
+    integration: wp.integration === "merge" ? "merge" : "pr",
+    defaultTargetBranch: preset === "github-flow" ? "main" : preset === "trunk-based" ? "master" : "develop"
+  };
+};
+var COMMIT_PRESETS = [
+  "conventional",
+  "gitmoji",
+  "ticket-prefix",
+  "freeform",
+  "custom",
+  "auto"
+];
+
+// packages/workit-core/src/core/workspaces.ts
+import { readFileSync as readFileSync5, realpathSync as realpathSync4 } from "node:fs";
+import path8 from "node:path";
+var readWorkspacesResult = (dir = configDir()) => {
+  const file = path8.join(dir, "workspaces.json");
+  let raw;
+  try {
+    raw = readFileSync5(file, "utf8");
+  } catch {
+    return { status: "missing", path: file, entries: [] };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return { status: "malformed", path: file, entries: [], error: `${file} is not valid JSON` };
+  }
+  if (!isConfigObject(parsed)) {
+    return { status: "malformed", path: file, entries: [], error: `${file} is not a JSON object` };
+  }
+  const list = parsed.workspaces;
+  return {
+    status: "valid",
+    path: file,
+    entries: Array.isArray(list) ? list : []
+  };
+};
+var loadWorkspacesFrom = (dir) => readWorkspacesResult(dir).entries;
+var globToRegExp = (glob) => {
+  let out = "";
+  for (let i = 0;i < glob.length; i++) {
+    const c = glob[i];
+    if (c === "*") {
+      if (glob[i + 1] === "*") {
+        if (glob[i + 2] === "/") {
+          if (out === "")
+            out += "/?";
+          out += "(?:[^/]+/)*";
+          i += 2;
+        } else {
+          if (i + 2 >= glob.length) {
+            if (out.endsWith("/")) {
+              out = out.slice(0, -1);
+              out += "(?:/.*)?";
+            } else {
+              out += ".*";
+            }
+          } else {
+            out += ".*";
+          }
+          i++;
+        }
+      } else {
+        out += "[^/]*";
+      }
+    } else {
+      out += c.replace(/[.+?^${}()|[\]\\]/g, "\\$&");
+    }
+  }
+  return new RegExp(`^${out}$`);
+};
+var matchWorkspace = (glob, target) => globToRegExp(glob.replaceAll("\\", "/")).test(target.replaceAll("\\", "/"));
+var realpathOf = (p) => {
+  const real = realpathSync4.native ?? realpathSync4;
+  try {
+    return real(p);
+  } catch {
+    return p;
+  }
+};
+var canonicalGlob = (glob) => {
+  const m = /[*?[\]{]/.exec(glob);
+  const prefix = m ? glob.slice(0, m.index) : glob;
+  const rest = m ? glob.slice(m.index) : "";
+  if (!prefix)
+    return glob;
+  const real = realpathOf(prefix.replace(/\/+$/, "") || "/");
+  return real + (prefix.endsWith("/") ? "/" : "") + rest;
+};
+var resolveWorkspaceFrom = (cwd, dir) => {
+  const targets = [cwd, realpathOf(cwd)].map((p) => p.replaceAll("\\", "/"));
+  for (const entry of loadWorkspacesFrom(dir)) {
+    if (!entry || typeof entry !== "object")
+      continue;
+    const ws = entry;
+    if (typeof ws.glob !== "string" || !ws.glob)
+      continue;
+    const glob = ws.glob.replaceAll("\\", "/");
+    const canonical = canonicalGlob(glob);
+    for (const target of targets) {
+      if (matchWorkspace(glob, target))
+        return ws;
+      if (canonical !== glob && matchWorkspace(canonical, target))
+        return ws;
+    }
+  }
+  return null;
+};
+var resolveWorkspace = (cwd) => resolveWorkspaceFrom(cwd, configDir());
+
+// packages/workit-core/src/core/vcs-config.ts
+import fs7 from "node:fs";
+import path9 from "node:path";
+import { spawnSync as spawnSync2 } from "node:child_process";
+var TOKEN_PLACEHOLDER = "YOUR_TOKEN_HERE";
+var vcsConfigPath = () => process.env.WORKFLOW_VCS_CONFIG ?? path9.join(configDir(), "vcs.json");
+var vcsCwd = (cwd) => cwd ?? process.env.WORKFLOW_WORKSPACE_ROOT ?? process.cwd();
+var remoteProvider = (cwd) => {
+  const r = spawnSync2("git", ["remote", "get-url", "origin"], { cwd, encoding: "utf8" });
+  if (r.status !== 0)
+    return null;
+  const url = (r.stdout ?? "").trim();
+  if (/github\.com[:/]/.test(url))
+    return "github";
+  if (/gitlab\.com[:/]/.test(url))
+    return "gitlab";
+  return null;
+};
+var readVcsConfig = () => {
+  const file = vcsConfigPath();
+  let raw;
+  try {
+    raw = fs7.readFileSync(file, "utf8");
+  } catch {
+    return { status: "missing", path: file, config: {} };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return { status: "malformed", path: file, config: {}, error: `${file} is not valid JSON` };
+  }
+  if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+    return { status: "valid", path: file, config: parsed };
+  }
+  return { status: "malformed", path: file, config: {}, error: `${file} is not a JSON object` };
+};
+function vcsConfig(mode, cwd) {
+  const ws = resolveWorkspace(vcsCwd(cwd));
+  const wsVcs = ws?.vcs ?? {};
+  const wsYt = ws?.youtrack ?? {};
+  const wsIssues = ws?.issues ?? {};
+  const { status: cfgStatus, path: cfgPath, config: cfg, error: cfgError } = readVcsConfig();
+  const root = vcsCwd(cwd);
+  const determinateRoot = cwd !== undefined || process.env.WORKFLOW_WORKSPACE_ROOT !== undefined;
+  const rawProvider = wsVcs.provider ?? (determinateRoot ? remoteProvider(root) : null) ?? cfg.provider ?? null;
+  const provider = rawProvider === null || rawProvider === undefined ? null : String(rawProvider).toLowerCase() || null;
+  const wp = ws?.branchPolicy ?? {};
+  const hasWorkspacePolicy = typeof wp.preset === "string" && Object.hasOwn(PRESETS, wp.preset);
+  const policyDefault = resolveBranchPolicyFor(root).defaultTargetBranch;
+  const defaultTarget = String(wsVcs.defaultTargetBranch ?? (hasWorkspacePolicy ? policyDefault : cfg.defaultTargetBranch ?? policyDefault) ?? "develop");
+  const linkIssues = typeof wsYt.link_issues === "boolean" ? wsYt.link_issues : null;
+  const youtrackBaseUrl = typeof wsYt.baseUrl === "string" ? wsYt.baseUrl : null;
+  let issuesProvider = null;
+  let linkOnPr = null;
+  if (provider === "github" && typeof wsIssues.provider === "string" && wsIssues.provider.toLowerCase() === "github") {
+    issuesProvider = "github";
+    linkOnPr = typeof wsIssues.link_on_pr === "boolean" ? wsIssues.link_on_pr : null;
+  }
+  if (mode === "resolve") {
+    if (cfgStatus === "malformed")
+      return { ok: false, error: cfgError, configPath: cfgPath };
+    return {
+      ok: true,
+      workspace_name: ws?.name ?? null,
+      provider,
+      defaultTargetBranch: defaultTarget,
+      link_issues: linkIssues,
+      youtrack_base_url: youtrackBaseUrl,
+      issues_provider: issuesProvider,
+      link_on_pr: linkOnPr
+    };
+  }
+  if (cfgStatus === "malformed") {
+    return { ok: false, error: cfgError, configPath: cfgPath };
+  }
+  if (cfgStatus === "missing") {
+    return { ok: false, error: `vcs.json is missing: ${cfgPath}`, configPath: cfgPath };
+  }
+  if (provider === null) {
+    return {
+      ok: false,
+      error: `no vcs provider configured (set vcs.provider in ${cfgPath}, match a workspace entry, or run inside a checkout with a recognized origin remote)`,
+      configPath: cfgPath
+    };
+  }
+  const prov = cfg[provider] ?? {};
+  const wsTokenFile = typeof wsVcs.tokenFile === "string" && wsVcs.tokenFile.trim() !== "" ? wsVcs.tokenFile : null;
+  const tokenFile = String(wsTokenFile ?? prov.tokenFile ?? path9.join(configDir(), `${provider}.token`));
+  const tokenPath = path9.resolve(tokenFile);
+  let tokenOk = false;
+  if (fs7.existsSync(tokenPath)) {
+    const token = fs7.readFileSync(tokenPath, "utf8").trim();
+    const placeholder = !token || token === TOKEN_PLACEHOLDER || token.startsWith(TOKEN_PLACEHOLDER);
+    tokenOk = !placeholder;
+  }
+  const out = {
+    ok: true,
+    configPath: path9.resolve(cfgPath),
+    provider,
+    defaultTargetBranch: defaultTarget,
+    pr: cfg.pr ?? {},
+    tokenPath,
+    tokenPresent: fs7.existsSync(tokenPath),
+    tokenReady: tokenOk,
+    workspace_name: ws?.name ?? null,
+    link_issues: linkIssues,
+    youtrack_base_url: youtrackBaseUrl,
+    issues_provider: issuesProvider,
+    link_on_pr: linkOnPr
+  };
+  if (provider === "gitlab") {
+    out.gitlab = {
+      host: prov.host ?? "gitlab.com",
+      apiUrl: prov.apiUrl ?? "https://gitlab.com/api/v4"
+    };
+  } else if (provider === "github") {
+    out.github = { host: prov.host ?? "github.com" };
+  }
+  if (mode === "summary")
+    delete out.tokenPath;
+  return out;
+}
+function mergedPrStyle(limit = 6, cwd) {
+  const cfg = vcsConfig("load", cwd);
+  if (!cfg.ok || !cfg.tokenReady)
+    return { ok: false, error: "vcs not configured" };
+  const provider = cfg.provider;
+  const token = fs7.readFileSync(cfg.tokenPath, "utf8").trim();
+  const examples = [];
+  const descInfo = (desc, caseInsensitiveNotes = false) => ({
+    hasNotesSection: caseInsensitiveNotes ? /##\s*notes/i.test(desc) : /##\s*Notes/.test(desc),
+    sections: desc.split(`
+`).filter((l) => l.startsWith("## ")).map((l) => l.trim()),
+    descriptionPreview: desc.slice(0, 600)
+  });
+  if (provider === "gitlab") {
+    const remote = spawnSync2("git", ["remote", "get-url", "origin"], { cwd, encoding: "utf8" });
+    if (remote.status !== 0)
+      return { ok: false, error: "no origin remote" };
+    const url = (remote.stdout ?? "").trim();
+    const m = /gitlab\.com[:/](.+?)(?:\.git)?$/.exec(url);
+    if (!m)
+      return { ok: false, error: "not a gitlab.com origin" };
+    const project = m[1];
+    const env = { ...process.env, GITLAB_TOKEN: token };
+    const run = (args) => spawnSync2("glab", ["api", ...args], { cwd, encoding: "utf8", env });
+    let r = run([
+      `projects/${project.replaceAll("/", "%2F")}/merge_requests?state=merged&per_page=${limit}&order_by=updated_at&sort=desc`
+    ]);
+    if (r.status !== 0) {
+      r = run([`merge_requests?state=merged&per_page=${limit}&order_by=updated_at&sort=desc`]);
+    }
+    if (r.status !== 0)
+      return { ok: false, error: "could not list merge requests" };
+    for (const mr of JSON.parse(r.stdout ?? "[]")) {
+      const desc = String(mr.description ?? "").trim();
+      examples.push({
+        title: mr.title,
+        url: mr.web_url,
+        squash: mr.squash,
+        ...descInfo(desc, true)
+      });
+    }
+  } else if (provider === "github") {
+    const r = spawnSync2("gh", ["pr", "list", "--state", "merged", "--limit", String(limit), "--json", "title,url,body"], { cwd, encoding: "utf8", env: { ...process.env, GH_TOKEN: token } });
+    if (r.status !== 0)
+      return { ok: false, error: "could not list pull requests" };
+    for (const pr of JSON.parse(r.stdout ?? "[]")) {
+      const desc = String(pr.body ?? "").trim();
+      examples.push({ title: pr.title, url: pr.url, ...descInfo(desc) });
+    }
+  }
+  return {
+    ok: true,
+    provider,
+    count: examples.length,
+    styleHints: [
+      "Prefer ## Summary bullets + ## Validation or ## Test plan only",
+      "Do not add ## Notes with branch names, commit counts, or diff stats",
+      "Do not paste commit log or diff stat into the body"
+    ],
+    examples
+  };
+}
+
+// packages/workit-core/src/core/branch.ts
+var resolveBranchPolicyFor = (workspaceRoot) => resolveBranchPolicy(readConfig(), resolveWorkspace(workspaceRoot));
+// packages/workit-core/src/core/external-action.ts
+var externalActionSchema = discriminatedUnion("operation", [
+  object({
+    operation: literal("git.branch_setup"),
+    payload: object({
+      action: _enum(["setup", "reapply_stash"]).optional(),
+      sdd_dir: string2().optional(),
+      target_branch: string2().optional(),
+      stash: _enum(["yes", "no"]).optional()
+    }).strict()
+  }).strict(),
+  object({
+    operation: literal("git.commit"),
+    payload: object({
+      message: string2().min(1).optional(),
+      plan_steps: array(string2().min(1)).optional(),
+      plan_branch: string2().min(1).optional()
+    }).strict()
+  }).strict(),
+  object({
+    operation: literal("git.push"),
+    payload: object({ branch: string2().min(1).optional() }).strict()
+  }).strict(),
+  object({
+    operation: literal("hosting.pull_request"),
+    payload: object({
+      title: string2().min(1),
+      body: string2().optional(),
+      draft: boolean2().optional(),
+      target_branch: string2().optional(),
+      babysit: boolean2().optional()
+    }).strict()
+  }).strict(),
+  object({
+    operation: literal("youtrack.update"),
+    payload: object({
+      issueId: string2().min(1),
+      markdown: string2().min(1),
+      minutes: number2().positive().optional()
+    }).strict()
+  }).strict(),
+  object({
+    operation: literal("youtrack.time"),
+    payload: object({
+      issueId: string2().min(1),
+      minutes: number2().positive(),
+      text: string2().optional(),
+      dateMs: number2().finite().optional()
+    }).strict()
+  }).strict(),
+  object({
+    operation: literal("youtrack.meeting"),
+    payload: object({
+      issueId: string2().min(1),
+      minutes: number2().positive(),
+      text: string2().min(1)
+    }).strict()
+  }).strict(),
+  object({
+    operation: literal("changelog.apply"),
+    payload: object({
+      entries: union([
+        record(string2(), array(string2())),
+        array(object({ category: string2().min(1), text: string2().min(1) }).strict())
+      ]).optional(),
+      path: string2().optional(),
+      normalize_only: boolean2().optional()
+    }).strict()
+  }).strict(),
+  object({
+    operation: literal("context.read"),
+    payload: object({
+      kind: _enum([
+        "git",
+        "pr",
+        "youtrack",
+        "github_issue",
+        "gitlab_issue",
+        "changelog",
+        "release",
+        "affected"
+      ]),
+      range: string2().optional(),
+      issueId: string2().optional(),
+      issueUrl: string2().optional(),
+      issueRef: string2().optional(),
+      mode: string2().optional(),
+      specPath: string2().optional(),
+      planPath: string2().optional()
+    }).strict()
+  }).strict()
+]);
+// packages/workit-core/src/core/task-engine.ts
+import { realpathSync as realpathSync5 } from "node:fs";
+
+// packages/workit-core/src/core/policy-resolver.ts
+var resolverInputSchema = object({
+  intent: intentSchema,
+  assessment: assessmentSchema,
+  constraints: array(constraintSchema),
+  prior: object({
+    decisions: array(decisionSchema),
+    findings: array(findingSchema),
+    requirements: array(requirementSchema)
+  }).strict(),
+  preferences: object({ fast: boolean2().optional(), thorough: boolean2().optional() }).strict().optional()
+}).strict();
+var compareCodeUnits3 = (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 stableUnique = (values) => [...new Set(values)].sort(compareCodeUnits3);
+var stableList = (values) => [...values].sort((left, right) => compareCodeUnits3(canonicalJson(left), canonicalJson(right)));
+var normalizedScope = (scope) => ({
+  description: scope.description,
+  paths: stableUnique(scope.paths),
+  exclusions: stableUnique(scope.exclusions)
+});
+var normalizedRefList = (values) => stableList(values);
+var normalizeAssessment = (assessment) => ({
+  facts: stableList(assessment.facts.map((fact) => ({ ...fact, refs: normalizedRefList(fact.refs) }))),
+  signals: Object.fromEntries(Object.entries(assessment.signals).map(([name, signal]) => [
+    name,
+    { ...signal, refs: normalizedRefList(signal.refs) }
+  ])),
+  consequences: stableList(assessment.consequences.map((consequence) => ({
+    ...consequence,
+    fact: { ...consequence.fact, refs: normalizedRefList(consequence.fact.refs) }
+  }))),
+  verification: stableList(assessment.verification.map((verification) => ({
+    ...verification,
+    scope: normalizedScope(verification.scope),
+    availableChecks: normalizedRefList(verification.availableChecks),
+    gaps: stableUnique(verification.gaps)
+  })))
+});
+var normalizeConstraint = (constraint) => ({
+  ...constraint,
+  source: constraint.source,
+  requires: stableList(constraint.requires.map((requirement) => ({
+    ...requirement,
+    scope: normalizedScope(requirement.scope),
+    refs: normalizedRefList(requirement.refs)
+  })))
+});
+var normalizeDecision = (decision) => ({
+  ...decision,
+  binding: {
+    ...decision.binding,
+    scope: normalizedScope(decision.binding.scope),
+    contentRefs: normalizedRefList(decision.binding.contentRefs)
+  },
+  requirementIds: stableUnique(decision.requirementIds)
+});
+var normalizeIntent = (intent) => ({
+  ...intent,
+  scope: normalizedScope(intent.scope),
+  authorityRefs: normalizedRefList(intent.authorityRefs)
+});
+var normalizePrior = (prior) => ({
+  decisions: stableList(prior.decisions.map(normalizeDecision)),
+  findings: stableList(prior.findings.map((finding) => ({
+    ...finding,
+    scope: normalizedScope(finding.scope),
+    refs: normalizedRefList(finding.refs),
+    resolution: finding.resolution ? {
+      ...finding.resolution,
+      evidenceIds: stableUnique(finding.resolution.evidenceIds),
+      decisionIds: stableUnique(finding.resolution.decisionIds)
+    } : null
+  }))),
+  requirements: stableList(prior.requirements.map((requirement) => ({
+    ...requirement,
+    scope: normalizedScope(requirement.scope)
+  })))
+});
+var invalidFields = (error) => ({
+  fields: error.issues.map((issue) => ({
+    path: issue.code === "unrecognized_keys" ? issue.keys.join(".") : issue.path.join("."),
+    reason: issue.message
+  }))
+});
+function normalizeResolverInput(input) {
+  const parsed = resolverInputSchema.safeParse(input);
+  if (!parsed.success)
+    return failure("invalid_input", "resolver input is invalid", invalidFields(parsed.error));
   const value = parsed.data;
   const signals = value.assessment.signals;
   if (signals.behaviorChange.value === true && signals.mechanicalLowRisk.value === true)
@@ -18010,6 +18733,8 @@ var applyWorkerLifecycle = (input) => {
   if (task.data.status === "paused" && (input.state === "running" || input.state === "cancelling"))
     return failure("invalid_transition", "paused task cannot run a worker");
   const notStarted = input.dispatch === true;
+  if (notStarted && entry.data.state === "stopped" && input.session === null)
+    return success(task.data.revision, workspace.data.revision, entry);
   if (notStarted && (input.state !== "stopped" || input.session !== null))
     return failure("invalid_input", "a never-dispatched worker stops with no session");
   if (notStarted && entry.data.session !== null)
@@ -18041,7 +18766,7 @@ var applyWorkerLifecycle = (input) => {
     return success(task.data.revision, workspace.data.revision, entry);
   const changed = input.store.mutateTaskAndWorkspace({
     taskId: task.data.id,
-    expectedTaskRevision: input.expectedRevision,
+    expectedRevision: input.expectedRevision,
     expectedWorkspaceRevision: input.expectedWorkspaceRevision,
     now: input.now,
     workspace: (current, mutation) => success(mutation.revision, mutation.revision, {
@@ -18089,90 +18814,22 @@ var importedProvenance = (context) => ({
   receipts: []
 });
 var portableTask = (task) => {
-  const clone = structuredClone(task);
-  const portableProvenance = (value) => ({
-    ...value,
-    session: null,
-    receipts: []
-  });
-  const entries = [
-    clone.intent,
-    ...clone.assessments,
-    ...clone.evidence,
-    ...clone.decisions,
-    ...clone.findings,
-    ...clone.workers
-  ];
-  for (const entry of entries)
-    entry.provenance = portableProvenance(entry.provenance);
-  for (const worker of clone.workers)
-    worker.data.session = null;
-  clone.intent = {
-    ...clone.intent,
-    data: { ...clone.intent.data, authorityRefs: portableRefs(clone.intent.data.authorityRefs) }
-  };
-  clone.constraints = clone.constraints.flatMap((constraint) => {
-    const source = portableRef(constraint.source);
-    return source ? [
-      {
-        ...constraint,
-        source,
-        requires: constraint.requires.map((requirement) => ({
-          ...requirement,
-          refs: portableRefs(requirement.refs)
-        }))
-      }
-    ] : [];
-  });
-  clone.assessments = clone.assessments.map((entry) => ({
-    ...entry,
-    data: {
-      ...entry.data,
-      facts: entry.data.facts.map(portableFact),
-      signals: Object.fromEntries(Object.entries(entry.data.signals).map(([name, signal]) => [name, portableSignal(signal)])),
-      consequences: entry.data.consequences.map((consequence) => ({
-        ...consequence,
-        fact: portableFact(consequence.fact)
-      })),
-      verification: entry.data.verification.map((verification) => ({
-        ...verification,
-        availableChecks: portableRefs(verification.availableChecks)
-      }))
-    }
-  }));
-  clone.progress = {
-    ...clone.progress,
-    blockers: clone.progress.blockers.map((blocker) => ({
-      ...blocker,
-      refs: portableRefs(blocker.refs)
-    }))
-  };
-  clone.evidence = clone.evidence.map((entry) => ({
-    ...entry,
-    data: {
-      ...entry.data,
-      refs: portableRefs(entry.data.refs),
-      reviewContext: portableRef(entry.data.reviewContext)
-    }
-  }));
-  clone.decisions = clone.decisions.map((entry) => ({
-    ...entry,
-    data: {
-      ...entry.data,
-      consumption: entry.data.consumption ? portableRef(entry.data.consumption.actionRef) ? {
-        ...entry.data.consumption,
-        actionRef: portableRef(entry.data.consumption.actionRef)
-      } : null : null,
-      binding: {
-        ...entry.data.binding,
-        contentRefs: portableRefs(entry.data.binding.contentRefs)
-      }
-    }
-  }));
-  clone.findings = clone.findings.map((entry) => ({
-    ...entry,
-    data: { ...entry.data, refs: portableRefs(entry.data.refs) }
-  }));
+  const stripped = rewriteRecordRefs(task, taskRecordSchema, portableRef);
+  if (typeof stripped !== "object" || stripped === null || Array.isArray(stripped))
+    throw new TypeError("portable task rewrite produced a non-record");
+  const clone = structuredClone(stripped);
+  const demote = (facts, signals, consequences) => {
+    for (const fact of facts)
+      Object.assign(fact, portableFact(fact));
+    for (const name of Object.keys(signals)) {
+      const signal = signals[name];
+      Object.assign(signal, portableSignal(signal));
+    }
+    for (const consequence of consequences)
+      Object.assign(consequence.fact, portableFact(consequence.fact));
+  };
+  for (const entry of clone.assessments)
+    demote(entry.data.facts, entry.data.signals, entry.data.consequences);
   clone.candidates = [];
   return clone;
 };
@@ -18197,15 +18854,13 @@ var importedTask = (source, bundle, destinationWorkspaceId, context, timestamp)
     allocate(entry.id);
   const fresh = (id) => allocate(id);
   const provenance = importedProvenance(context);
+  const remap = (ref) => mapRef(ref, ids);
   const intent = {
     ...source.intent,
     id: fresh(source.intent.id),
     recordedAt: timestamp,
     provenance,
-    data: {
-      ...source.intent.data,
-      authorityRefs: source.intent.data.authorityRefs.map((ref) => mapRef(ref, ids))
-    }
+    data: rewriteRecordRefs(source.intent.data, intentSchema, remap)
   };
   const assessments = source.assessments.map((entry) => {
     const data = entry.data;
@@ -18214,62 +18869,39 @@ var importedTask = (source, bundle, destinationWorkspaceId, context, timestamp)
       id: fresh(entry.id),
       recordedAt: timestamp,
       provenance,
-      data: {
-        ...data,
-        facts: data.facts.map((fact) => ({
-          ...fact,
-          refs: fact.refs.map((ref) => mapRef(ref, ids))
-        })),
-        signals: Object.fromEntries(Object.entries(data.signals).map(([name, signal]) => [
-          name,
-          { ...signal, refs: signal.refs.map((ref) => mapRef(ref, ids)) }
-        ])),
-        consequences: data.consequences.map((consequence) => ({
-          ...consequence,
-          fact: {
-            ...consequence.fact,
-            refs: consequence.fact.refs.map((ref) => mapRef(ref, ids))
-          }
-        })),
-        verification: data.verification.map((verification) => ({
-          ...verification,
-          availableChecks: verification.availableChecks.map((ref) => mapRef(ref, ids))
-        }))
-      }
+      data: rewriteRecordRefs(data, assessmentSchema, remap)
     };
   });
   const evidence = source.evidence.map((entry) => ({
     ...entry,
     id: fresh(entry.id),
     recordedAt: timestamp,
-    provenance,
-    data: {
-      ...entry.data,
-      refs: entry.data.refs.map((ref) => mapRef(ref, ids)),
-      reviewContext: entry.data.reviewContext ? mapRef(entry.data.reviewContext, ids) : null
-    }
-  }));
-  const decisions = source.decisions.map((entry) => ({
-    ...entry,
-    id: fresh(entry.id),
-    recordedAt: timestamp,
-    provenance
+    provenance,
+    data: rewriteRecordRefs(entry.data, evidenceSchema, remap)
   }));
-  const findings = source.findings.map((entry) => ({
+  const decisions = source.decisions.map((entry) => ({
     ...entry,
     id: fresh(entry.id),
     recordedAt: timestamp,
-    provenance,
-    data: {
-      ...entry.data,
-      refs: entry.data.refs.map((ref) => mapRef(ref, ids)),
-      resolution: entry.data.resolution ? {
-        ...entry.data.resolution,
-        evidenceIds: entry.data.resolution.evidenceIds.map((id) => ids.get(id) ?? id),
-        decisionIds: entry.data.resolution.decisionIds.map((id) => ids.get(id) ?? id)
-      } : null
-    }
+    provenance
   }));
+  const findings = source.findings.map((entry) => {
+    const data = rewriteRecordRefs(entry.data, findingSchema, remap);
+    return {
+      ...entry,
+      id: fresh(entry.id),
+      recordedAt: timestamp,
+      provenance,
+      data: {
+        ...data,
+        resolution: data.resolution ? {
+          ...data.resolution,
+          evidenceIds: data.resolution.evidenceIds.map((id) => ids.get(id) ?? id),
+          decisionIds: data.resolution.decisionIds.map((id) => ids.get(id) ?? id)
+        } : null
+      }
+    };
+  });
   const workers = source.workers.map((entry) => ({
     ...entry,
     id: fresh(entry.id),
@@ -18312,19 +18944,21 @@ var importedTask = (source, bundle, destinationWorkspaceId, context, timestamp)
     closure: null,
     assessments,
     evidence,
-    decisions: decisions.map((entry) => ({
-      ...entry,
-      data: {
-        ...entry.data,
-        binding: {
-          ...entry.data.binding,
-          taskId: "",
-          workspaceId: destinationWorkspaceId,
-          contentRefs: entry.data.binding.contentRefs.map((ref) => mapRef(ref, ids))
-        },
-        consumption: null
-      }
-    })),
+    decisions: decisions.map((entry) => {
+      const data = rewriteRecordRefs(entry.data, decisionSchema, remap);
+      return {
+        ...entry,
+        data: {
+          ...data,
+          binding: {
+            ...data.binding,
+            taskId: "",
+            workspaceId: destinationWorkspaceId
+          },
+          consumption: null
+        }
+      };
+    }),
     ...actionProgress ? { actionProgress } : {},
     findings,
     workers,
@@ -18362,7 +18996,7 @@ class WorkitCore {
   }
   contextRootError() {
     try {
-      if (realpathSync4(this.context.root) !== this.store.root)
+      if (realpathSync5(this.context.root) !== this.store.root)
         return failure("invalid_input", "operation context root does not match the task store root");
     } catch {
       return failure("invalid_input", "operation context root cannot be resolved");
@@ -18407,7 +19041,7 @@ class WorkitCore {
   activeWorkerBlocker(task, workspace) {
     if (workspace.writer)
       return failure("recovery_required", "writer ownership must be released first");
-    if (task.workers.some((entry) => isUncertainWorker(entry.data.state)))
+    if (task.workers.some((entry) => workerBlocksTransition("close", entry.data.state)))
       return failure("recovery_required", "worker state requires reconciliation");
     return null;
   }
@@ -18653,37 +19287,33 @@ class WorkitCore {
     const currentCandidate = captureCandidate(this.store.root, task.data.intent.data.scope, environment());
     if (!currentCandidate.ok)
       return currentCandidate;
-    if (evidence.kind === "check" || evidence.kind === "review") {
-      evidence.beforeCandidateId ??= currentCandidate.data.id;
-      evidence.candidateId ??= currentCandidate.data.id;
-    } else {
-      evidence.beforeCandidateId ??= null;
-      evidence.candidateId ??= null;
-    }
+    const pin = helper && helper.ok ? helper.data.data.assignment.candidateId : null;
+    const bound = resolveBinding(evidence, pin, currentCandidate.data.id);
     if (helper?.ok) {
       const assignment = helper.data.data.assignment;
-      if (evidence.requirementIds.some((id) => !assignment.requirementIds.includes(id)) || assignment.candidateId !== null && evidence.candidateId !== assignment.candidateId && evidence.beforeCandidateId !== assignment.candidateId || !refsWithinScope(evidence.refs, assignment.scope) || !refsWithinScope(evidence.refs, task.data.intent.data.scope))
+      if (evidence.requirementIds.some((id) => !assignment.requirementIds.includes(id)) || !checkPin(assignment, bound.beforeCandidateId, bound.candidateId) || !refsWithinScope(evidence.refs, assignment.scope) || !refsWithinScope(evidence.refs, task.data.intent.data.scope))
         return failure("permission_denied", "evidence is outside the worker assignment");
     }
     const knownCandidates = new Set(task.data.candidates.map((candidate) => candidate.id));
-    for (const candidateId of [evidence.beforeCandidateId, evidence.candidateId]) {
+    for (const candidateId of [bound.beforeCandidateId, bound.candidateId]) {
       if (candidateId && candidateId !== currentCandidate.data.id && !knownCandidates.has(candidateId))
         return failure("invalid_input", "evidence candidate is not a captured candidate");
     }
+    const boundEvidence = { ...evidence, ...bound };
     const changed = this.store.mutateTask(task.data.id, input.expectedRevision, (current, mutation) => {
       const candidates = current.candidates.some((item) => item.id === currentCandidate.data.id) ? current.candidates : [...current.candidates, currentCandidate.data];
       const entry = {
         id: newId(),
         recordedAt: mutation.now,
         provenance: provenance(this.context, "agent_reported"),
-        data: evidence
+        data: boundEvidence
       };
       return success(mutation.revision, null, {
         ...current,
         candidates,
         evidence: [...current.evidence, entry],
         findings: current.findings.map((finding) => {
-          if (finding.data.disposition === "open" || evidence.result === "skipped")
+          if (finding.data.disposition === "open" || boundEvidence.result === "skipped")
             return finding;
           if (finding.data.disposition !== "fixed")
             return finding;
@@ -18692,8 +19322,12 @@ class WorkitCore {
             item.evidenceId,
             item.status
           ]));
-          const verified = withEntry.evidence.some((item) => statuses.get(item.id) === "passed" && (item.data.kind === "check" || item.data.kind === "review") && (finding.data.candidateId === null || item.data.candidateId === finding.data.candidateId));
-          const contradicted = evidence.result === "failed" && finding.data.refs.some((left) => evidence.refs.some((right) => JSON.stringify(left) === JSON.stringify(right)));
+          const verified = withEntry.evidence.some((item) => findingVerificationPasses(finding.data.candidateId, {
+            kind: item.data.kind,
+            candidateId: item.data.candidateId,
+            status: statuses.get(item.id) ?? "missing"
+          }));
+          const contradicted = boundEvidence.result === "failed" && finding.data.refs.some((left) => boundEvidence.refs.some((right) => sameValue(left, right)));
           return verified && !contradicted ? finding : { ...finding, data: { ...finding.data, disposition: "open", resolution: null } };
         })
       });
@@ -18851,7 +19485,7 @@ class WorkitCore {
     if (input.action === "record") {
       if (helper?.ok) {
         const assignment = helper.data.data.assignment;
-        if (!bindingCovers(assignment.scope, input.scope) || !bindingCovers(task.data.intent.data.scope, input.scope) || assignment.candidateId !== null && input.candidateId !== assignment.candidateId || !refsWithinScope(input.refs, assignment.scope) || !refsWithinScope(input.refs, task.data.intent.data.scope))
+        if (!bindingCovers(assignment.scope, input.scope) || !bindingCovers(task.data.intent.data.scope, input.scope) || !checkPin(assignment, null, input.candidateId ?? null) || !refsWithinScope(input.refs, assignment.scope) || !refsWithinScope(input.refs, task.data.intent.data.scope))
           return failure("permission_denied", "finding is outside the worker assignment");
       }
       if (input.candidateId && !task.data.candidates.some((candidate) => candidate.id === input.candidateId))
@@ -18898,7 +19532,11 @@ class WorkitCore {
       const evaluations = evaluateEvidence(task.data, current.data);
       const verified = evidence.some((entry) => {
         const evaluation = evaluations.find((item) => item.evidenceId === entry.id);
-        return evaluation?.status === "passed" && (entry.data.kind === "check" || entry.data.kind === "review") && (finding.data.candidateId === null || entry.data.candidateId === finding.data.candidateId);
+        return findingVerificationPasses(finding.data.candidateId, {
+          kind: entry.data.kind,
+          candidateId: entry.data.candidateId,
+          status: evaluation?.status ?? "missing"
+        });
       });
       if (!verified)
         return failure("permission_denied", "fixed findings require passing verification evidence");
@@ -18910,7 +19548,7 @@ class WorkitCore {
         if (entry.data.result === "missing" || entry.data.result === "skipped")
           return false;
         const candidateMatches = finding.data.candidateId === null ? entry.data.candidateId === null : entry.data.candidateId === finding.data.candidateId || entry.data.beforeCandidateId === finding.data.candidateId;
-        const referenceMatches = finding.data.refs.some((left) => entry.data.refs.some((right) => JSON.stringify(left) === JSON.stringify(right)));
+        const referenceMatches = finding.data.refs.some((left) => entry.data.refs.some((right) => sameValue(left, right)));
         return candidateMatches && (referenceMatches || entry.data.claim === finding.data.claim);
       });
       if (!relevant)
@@ -18988,7 +19626,7 @@ class WorkitCore {
       const workerId = newId();
       const changed = this.store.mutateTaskAndWorkspace({
         taskId: task.data.id,
-        expectedTaskRevision: input.expectedRevision,
+        expectedRevision: input.expectedRevision,
         expectedWorkspaceRevision: input.expectedWorkspaceRevision,
         now: trustedNow(this.context),
         workspace: (current, mutation) => success(mutation.revision, mutation.revision, current),
@@ -19026,7 +19664,7 @@ class WorkitCore {
         return failure("permission_denied", "worker report is outside the worker assignment");
       const changed = this.store.mutateTaskAndWorkspace({
         taskId: task.data.id,
-        expectedTaskRevision: input.expectedRevision,
+        expectedRevision: input.expectedRevision,
         expectedWorkspaceRevision: input.expectedWorkspaceRevision,
         now: trustedNow(this.context),
         workspace: (current, mutation) => success(mutation.revision, mutation.revision, current),
@@ -19050,24 +19688,25 @@ class WorkitCore {
       return failure("invalid_transition", "closed task cannot cancel workers");
     if (entry.data.state === "unknown")
       return failure("recovery_required", "worker state requires recovery");
-    if (entry.data.state === "stopped")
-      return failure("invalid_transition", "stopped worker cannot be cancelled");
-    const settles = entry.data.report !== null || entry.data.state === "cancelling";
+    if (entry.data.state === "stopped") {
+      const stopped = task.data.workers.find((candidate) => candidate.id === input.workerId);
+      return success(task.data.revision, workspace.data.revision, stopped);
+    }
     const changed = this.store.mutateTaskAndWorkspace({
       taskId: task.data.id,
-      expectedTaskRevision: input.expectedRevision,
+      expectedRevision: input.expectedRevision,
       expectedWorkspaceRevision: input.expectedWorkspaceRevision,
       now: trustedNow(this.context),
-      workspace: (current, mutation) => success(mutation.revision, mutation.revision, current),
+      workspace: (current, mutation) => success(mutation.revision, mutation.revision, {
+        ...current,
+        writer: current.writer?.owner.workerId === input.workerId ? null : current.writer
+      }),
       task: (current, mutation) => success(mutation.revision, null, {
         ...current,
         workers: current.workers.map((candidate) => candidate.id === input.workerId ? {
           ...candidate,
           recordedAt: mutation.now,
-          data: {
-            ...candidate.data,
-            state: settles ? "stopped" : "cancelling"
-          }
+          data: { ...candidate.data, state: "stopped" }
         } : candidate)
       })
     });
@@ -19164,7 +19803,7 @@ class WorkitCore {
       return attested;
     const changed = this.store.mutateTaskAndWorkspace({
       taskId: task.data.id,
-      expectedTaskRevision: input.expectedRevision,
+      expectedRevision: input.expectedRevision,
       expectedWorkspaceRevision: input.expectedWorkspaceRevision,
       now: trustedNow(this.context),
       workspace: (current, mutation) => success(mutation.revision, mutation.revision, current),
@@ -19330,6 +19969,12 @@ class WorkitCore {
         if (!sameSession2(helper.data.data.session, this.context))
           return failure("permission_denied", "worker session does not match the caller");
       }
+      const gate = this.view(task.data);
+      if (gate.ok) {
+        const writeGates = (task.data.policy?.requirements ?? []).filter((requirement) => requirement.before === "write" && gate.data.requirements.some((evaluation) => evaluation.requirementId === requirement.id && (evaluation.status === "unsatisfied" || evaluation.status === "unavailable")));
+        if (writeGates.length)
+          return failure("requirements_unsatisfied", "writer ownership is gated by unsatisfied requirements; record their evidence or an approved limitation waiver first", { requirementIds: writeGates.map((requirement) => requirement.id) });
+      }
       const owner = {
         taskId: task.data.id,
         workerId: helperId,
@@ -19341,7 +19986,7 @@ class WorkitCore {
       };
       const changed = this.store.mutateTaskAndWorkspace({
         taskId: task.data.id,
-        expectedTaskRevision: input.expectedRevision,
+        expectedRevision: input.expectedRevision,
         expectedWorkspaceRevision: input.expectedWorkspaceRevision,
         now: trustedNow(this.context),
         workspace: (current, mutation) => success(mutation.revision, mutation.revision, {
@@ -19372,7 +20017,7 @@ class WorkitCore {
     }
     const changed = this.store.mutateTaskAndWorkspace({
       taskId: task.data.id,
-      expectedTaskRevision: input.expectedRevision,
+      expectedRevision: input.expectedRevision,
       expectedWorkspaceRevision: input.expectedWorkspaceRevision,
       now: trustedNow(this.context),
       workspace: (currentWorkspace, mutation) => success(mutation.revision, mutation.revision, { ...currentWorkspace, writer: null }),
@@ -19604,7 +20249,7 @@ class WorkitCore {
     if (view.task.workspaceId !== view.workspace.id)
       return failure("invalid_input", "task and workspace bindings are invalid");
     try {
-      if (realpathSync4(view.workspace.root) !== this.store.root)
+      if (realpathSync5(view.workspace.root) !== this.store.root)
         return failure("invalid_input", "task view root does not match the task store");
     } catch {
       return failure("invalid_input", "task view root cannot be resolved");
@@ -19621,7 +20266,15 @@ class WorkitCore {
       if (seen.has(observation.workerId))
         return failure("invalid_input", "worker observations must be unique");
       seen.add(observation.workerId);
-      if (observation.taskId !== view.task.id || observation.expectedRevision !== view.task.revision || observation.expectedWorkspaceRevision !== view.workspace.revision)
+      const freshTask = this.store.readTask(view.task.id);
+      const freshWorkspace = this.store.readWorkspace();
+      if (!freshTask.ok)
+        return freshTask;
+      if (!freshWorkspace.ok)
+        return freshWorkspace;
+      if (!freshWorkspace.data)
+        return failure("not_found", "workspace not found");
+      if (observation.taskId !== view.task.id || observation.expectedRevision !== freshTask.data.revision || observation.expectedWorkspaceRevision !== freshWorkspace.data.revision)
         return failure("revision_conflict", "worker observation is stale");
       if (!view.task.workers.some((entry) => entry.id === observation.workerId))
         return failure("permission_denied", "worker observation is not assigned");
@@ -19707,19 +20360,26 @@ class WorkitCore {
         return failure("permission_denied", "imported resume requires native destination approval");
       resumeCandidate = current.data.candidate;
     }
-    const blocker = this.activeWorkerBlocker(task.data, workspace.data);
+    const blocker = status === "paused" ? workspace.data.writer ? failure("recovery_required", "writer ownership must be released first") : null : this.activeWorkerBlocker(task.data, workspace.data);
     if (blocker)
       return blocker;
+    let pauseCandidate = null;
+    if (status === "paused") {
+      const captured = captureCandidate(this.store.root, task.data.intent.data.scope, environment());
+      if (!captured.ok)
+        return captured;
+      pauseCandidate = captured.data;
+    }
     const changed = this.store.mutateTaskAndWorkspace({
       taskId: task.data.id,
-      expectedTaskRevision: input.expectedRevision,
+      expectedRevision: input.expectedRevision,
       expectedWorkspaceRevision: input.expectedWorkspaceRevision,
       now: trustedNow(this.context),
       workspace: (workspace, context) => success(context.revision, context.revision, workspace),
       task: (current, context) => success(context.revision, null, {
         ...current,
         status,
-        candidates: resumeCandidate && !current.candidates.some((candidate) => candidate.id === resumeCandidate.id) ? [...current.candidates, resumeCandidate] : current.candidates,
+        candidates: (resumeCandidate ?? pauseCandidate) && !current.candidates.some((candidate) => candidate.id === (resumeCandidate ?? pauseCandidate).id) ? [...current.candidates, resumeCandidate ?? pauseCandidate] : current.candidates,
         progress: current.progress,
         pauseReason: status === "paused" ? input.reason ?? null : null
       })
@@ -19757,12 +20417,13 @@ class WorkitCore {
       return workspace;
     if (!workspace.data)
       return failure("not_found", "workspace not found");
-    if (workspace.data.writer || task.data.workers.some((entry) => isUncertainWorker(entry.data.state)))
-      return failure("recovery_required", "scope revision requires worker ownership reconciliation");
+    const revisionBlocker = this.activeWorkerBlocker(task.data, workspace.data);
+    if (revisionBlocker)
+      return revisionBlocker;
     this.fillRevisions(input, task.data, workspace.data);
     const changed = this.store.mutateTaskAndWorkspace({
       taskId: task.data.id,
-      expectedTaskRevision: input.expectedRevision,
+      expectedRevision: input.expectedRevision,
       expectedWorkspaceRevision: input.expectedWorkspaceRevision,
       now: trustedNow(this.context),
       workspace: (workspace, context) => success(context.revision, context.revision, workspace),
@@ -19818,7 +20479,7 @@ class WorkitCore {
       return closure;
     const changed = this.store.mutateTaskAndWorkspace({
       taskId: task.data.id,
-      expectedTaskRevision: input.expectedRevision,
+      expectedRevision: input.expectedRevision,
       expectedWorkspaceRevision: input.expectedWorkspaceRevision,
       now: trustedNow(this.context),
       workspace: (value, context) => success(context.revision, context.revision, value),
@@ -19855,7 +20516,7 @@ function gitRevisionParts(value) {
 }
 function resolveGitRevision(root, value) {
   for (const part of gitRevisionParts(value)) {
-    const result = run(root, "git", [
+    const result = run2(root, "git", [
       "rev-parse",
       "--verify",
       "--quiet",
@@ -19867,23 +20528,23 @@ function resolveGitRevision(root, value) {
   }
 }
 function resolveInside(root, candidate) {
-  const base = realpathSync5(root);
-  const target = path7.resolve(base, candidate);
-  if (target !== base && !target.startsWith(base + path7.sep)) {
+  const base = realpathSync6(root);
+  const target = path10.resolve(base, candidate);
+  if (target !== base && !target.startsWith(base + path10.sep)) {
     throw new Error("path must stay inside repository root");
   }
   let ancestor = target;
-  while (!existsSync4(ancestor))
-    ancestor = path7.dirname(ancestor);
-  const canonicalAncestor = realpathSync5(ancestor);
-  if (canonicalAncestor !== base && !canonicalAncestor.startsWith(base + path7.sep)) {
+  while (!existsSync5(ancestor))
+    ancestor = path10.dirname(ancestor);
+  const canonicalAncestor = realpathSync6(ancestor);
+  if (canonicalAncestor !== base && !canonicalAncestor.startsWith(base + path10.sep)) {
     throw new Error("path must stay inside repository root");
   }
   return target;
 }
-function run(root, executable, args, env = {}) {
-  const cwd = realpathSync5(root);
-  const result = spawnSync2(executable, args, {
+function run2(root, executable, args, env = {}) {
+  const cwd = realpathSync6(root);
+  const result = spawnSync3(executable, args, {
     cwd,
     encoding: "utf8",
     env: { ...process.env, ...env }
@@ -24523,1029 +25184,707 @@ class Protocol {
         this._onrequest(message, extra);
       } else if (isJSONRPCNotification(message)) {
         this._onnotification(message);
-      } else {
-        this._onerror(new Error(`Unknown message type: ${JSON.stringify(message)}`));
-      }
-    };
-    await this._transport.start();
-  }
-  _onclose() {
-    const responseHandlers = this._responseHandlers;
-    this._responseHandlers = new Map;
-    this._progressHandlers.clear();
-    this._taskProgressTokens.clear();
-    this._pendingDebouncedNotifications.clear();
-    for (const info of this._timeoutInfo.values()) {
-      clearTimeout(info.timeoutId);
-    }
-    this._timeoutInfo.clear();
-    for (const controller of this._requestHandlerAbortControllers.values()) {
-      controller.abort();
-    }
-    this._requestHandlerAbortControllers.clear();
-    const error = McpError.fromError(ErrorCode.ConnectionClosed, "Connection closed");
-    this._transport = undefined;
-    this.onclose?.();
-    for (const handler of responseHandlers.values()) {
-      handler(error);
-    }
-  }
-  _onerror(error) {
-    this.onerror?.(error);
-  }
-  _onnotification(notification) {
-    const handler = this._notificationHandlers.get(notification.method) ?? this.fallbackNotificationHandler;
-    if (handler === undefined) {
-      return;
-    }
-    Promise.resolve().then(() => handler(notification)).catch((error) => this._onerror(new Error(`Uncaught error in notification handler: ${error}`)));
-  }
-  _onrequest(request, extra) {
-    const handler = this._requestHandlers.get(request.method) ?? this.fallbackRequestHandler;
-    const capturedTransport = this._transport;
-    const relatedTaskId = request.params?._meta?.[RELATED_TASK_META_KEY]?.taskId;
-    if (handler === undefined) {
-      const errorResponse = {
-        jsonrpc: "2.0",
-        id: request.id,
-        error: {
-          code: ErrorCode.MethodNotFound,
-          message: "Method not found"
-        }
-      };
-      if (relatedTaskId && this._taskMessageQueue) {
-        this._enqueueTaskMessage(relatedTaskId, {
-          type: "error",
-          message: errorResponse,
-          timestamp: Date.now()
-        }, capturedTransport?.sessionId).catch((error) => this._onerror(new Error(`Failed to enqueue error response: ${error}`)));
-      } else {
-        capturedTransport?.send(errorResponse).catch((error) => this._onerror(new Error(`Failed to send an error response: ${error}`)));
-      }
-      return;
-    }
-    const abortController = new AbortController;
-    this._requestHandlerAbortControllers.set(request.id, abortController);
-    const taskCreationParams = isTaskAugmentedRequestParams(request.params) ? request.params.task : undefined;
-    const taskStore = this._taskStore ? this.requestTaskStore(request, capturedTransport?.sessionId) : undefined;
-    const fullExtra = {
-      signal: abortController.signal,
-      sessionId: capturedTransport?.sessionId,
-      _meta: request.params?._meta,
-      sendNotification: async (notification) => {
-        if (abortController.signal.aborted)
-          return;
-        const notificationOptions = { relatedRequestId: request.id };
-        if (relatedTaskId) {
-          notificationOptions.relatedTask = { taskId: relatedTaskId };
-        }
-        await this.notification(notification, notificationOptions);
-      },
-      sendRequest: async (r, resultSchema, options) => {
-        if (abortController.signal.aborted) {
-          throw new McpError(ErrorCode.ConnectionClosed, "Request was cancelled");
-        }
-        const requestOptions = { ...options, relatedRequestId: request.id };
-        if (relatedTaskId && !requestOptions.relatedTask) {
-          requestOptions.relatedTask = { taskId: relatedTaskId };
-        }
-        const effectiveTaskId = requestOptions.relatedTask?.taskId ?? relatedTaskId;
-        if (effectiveTaskId && taskStore) {
-          await taskStore.updateTaskStatus(effectiveTaskId, "input_required");
-        }
-        return await this.request(r, resultSchema, requestOptions);
-      },
-      authInfo: extra?.authInfo,
-      requestId: request.id,
-      requestInfo: extra?.requestInfo,
-      taskId: relatedTaskId,
-      taskStore,
-      taskRequestedTtl: taskCreationParams?.ttl,
-      closeSSEStream: extra?.closeSSEStream,
-      closeStandaloneSSEStream: extra?.closeStandaloneSSEStream
-    };
-    Promise.resolve().then(() => {
-      if (taskCreationParams) {
-        this.assertTaskHandlerCapability(request.method);
-      }
-    }).then(() => handler(request, fullExtra)).then(async (result) => {
-      if (abortController.signal.aborted) {
-        return;
-      }
-      const response = {
-        result,
-        jsonrpc: "2.0",
-        id: request.id
-      };
-      if (relatedTaskId && this._taskMessageQueue) {
-        await this._enqueueTaskMessage(relatedTaskId, {
-          type: "response",
-          message: response,
-          timestamp: Date.now()
-        }, capturedTransport?.sessionId);
-      } else {
-        await capturedTransport?.send(response);
-      }
-    }, async (error) => {
-      if (abortController.signal.aborted) {
-        return;
-      }
-      const errorResponse = {
-        jsonrpc: "2.0",
-        id: request.id,
-        error: {
-          code: Number.isSafeInteger(error["code"]) ? error["code"] : ErrorCode.InternalError,
-          message: error.message ?? "Internal error",
-          ...error["data"] !== undefined && { data: error["data"] }
-        }
-      };
-      if (relatedTaskId && this._taskMessageQueue) {
-        await this._enqueueTaskMessage(relatedTaskId, {
-          type: "error",
-          message: errorResponse,
-          timestamp: Date.now()
-        }, capturedTransport?.sessionId);
-      } else {
-        await capturedTransport?.send(errorResponse);
-      }
-    }).catch((error) => this._onerror(new Error(`Failed to send response: ${error}`))).finally(() => {
-      if (this._requestHandlerAbortControllers.get(request.id) === abortController) {
-        this._requestHandlerAbortControllers.delete(request.id);
-      }
-    });
-  }
-  _onprogress(notification) {
-    const { progressToken, ...params } = notification.params;
-    const messageId = Number(progressToken);
-    const handler = this._progressHandlers.get(messageId);
-    if (!handler) {
-      this._onerror(new Error(`Received a progress notification for an unknown token: ${JSON.stringify(notification)}`));
-      return;
-    }
-    const responseHandler = this._responseHandlers.get(messageId);
-    const timeoutInfo = this._timeoutInfo.get(messageId);
-    if (timeoutInfo && responseHandler && timeoutInfo.resetTimeoutOnProgress) {
-      try {
-        this._resetTimeout(messageId);
-      } catch (error) {
-        this._responseHandlers.delete(messageId);
-        this._progressHandlers.delete(messageId);
-        this._cleanupTimeout(messageId);
-        responseHandler(error);
-        return;
-      }
-    }
-    handler(params);
-  }
-  _onresponse(response) {
-    const messageId = Number(response.id);
-    const resolver = this._requestResolvers.get(messageId);
-    if (resolver) {
-      this._requestResolvers.delete(messageId);
-      if (isJSONRPCResultResponse(response)) {
-        resolver(response);
-      } else {
-        const error = new McpError(response.error.code, response.error.message, response.error.data);
-        resolver(error);
-      }
-      return;
-    }
-    const handler = this._responseHandlers.get(messageId);
-    if (handler === undefined) {
-      this._onerror(new Error(`Received a response for an unknown message ID: ${JSON.stringify(response)}`));
-      return;
-    }
-    this._responseHandlers.delete(messageId);
-    this._cleanupTimeout(messageId);
-    let isTaskResponse = false;
-    if (isJSONRPCResultResponse(response) && response.result && typeof response.result === "object") {
-      const result = response.result;
-      if (result.task && typeof result.task === "object") {
-        const task = result.task;
-        if (typeof task.taskId === "string") {
-          isTaskResponse = true;
-          this._taskProgressTokens.set(task.taskId, messageId);
-        }
+      } else {
+        this._onerror(new Error(`Unknown message type: ${JSON.stringify(message)}`));
       }
+    };
+    await this._transport.start();
+  }
+  _onclose() {
+    const responseHandlers = this._responseHandlers;
+    this._responseHandlers = new Map;
+    this._progressHandlers.clear();
+    this._taskProgressTokens.clear();
+    this._pendingDebouncedNotifications.clear();
+    for (const info of this._timeoutInfo.values()) {
+      clearTimeout(info.timeoutId);
     }
-    if (!isTaskResponse) {
-      this._progressHandlers.delete(messageId);
+    this._timeoutInfo.clear();
+    for (const controller of this._requestHandlerAbortControllers.values()) {
+      controller.abort();
     }
-    if (isJSONRPCResultResponse(response)) {
-      handler(response);
-    } else {
-      const error = McpError.fromError(response.error.code, response.error.message, response.error.data);
+    this._requestHandlerAbortControllers.clear();
+    const error = McpError.fromError(ErrorCode.ConnectionClosed, "Connection closed");
+    this._transport = undefined;
+    this.onclose?.();
+    for (const handler of responseHandlers.values()) {
       handler(error);
     }
   }
-  get transport() {
-    return this._transport;
-  }
-  async close() {
-    await this._transport?.close();
+  _onerror(error) {
+    this.onerror?.(error);
   }
-  async* requestStream(request, resultSchema, options) {
-    const { task } = options ?? {};
-    if (!task) {
-      try {
-        const result = await this.request(request, resultSchema, options);
-        yield { type: "result", result };
-      } catch (error) {
-        yield {
-          type: "error",
-          error: error instanceof McpError ? error : new McpError(ErrorCode.InternalError, String(error))
-        };
-      }
+  _onnotification(notification) {
+    const handler = this._notificationHandlers.get(notification.method) ?? this.fallbackNotificationHandler;
+    if (handler === undefined) {
       return;
     }
-    let taskId;
-    try {
-      const createResult = await this.request(request, CreateTaskResultSchema, options);
-      if (createResult.task) {
-        taskId = createResult.task.taskId;
-        yield { type: "taskCreated", task: createResult.task };
-      } else {
-        throw new McpError(ErrorCode.InternalError, "Task creation did not return a task");
-      }
-      while (true) {
-        const task = await this.getTask({ taskId }, options);
-        yield { type: "taskStatus", task };
-        if (isTerminal(task.status)) {
-          if (task.status === "completed") {
-            const result = await this.getTaskResult({ taskId }, resultSchema, options);
-            yield { type: "result", result };
-          } else if (task.status === "failed") {
-            yield {
-              type: "error",
-              error: new McpError(ErrorCode.InternalError, `Task ${taskId} failed`)
-            };
-          } else if (task.status === "cancelled") {
-            yield {
-              type: "error",
-              error: new McpError(ErrorCode.InternalError, `Task ${taskId} was cancelled`)
-            };
-          }
-          return;
-        }
-        if (task.status === "input_required") {
-          const result = await this.getTaskResult({ taskId }, resultSchema, options);
-          yield { type: "result", result };
-          return;
-        }
-        const pollInterval = task.pollInterval ?? this._options?.defaultTaskPollInterval ?? 1000;
-        await new Promise((resolve) => setTimeout(resolve, pollInterval));
-        options?.signal?.throwIfAborted();
-      }
-    } catch (error) {
-      yield {
-        type: "error",
-        error: error instanceof McpError ? error : new McpError(ErrorCode.InternalError, String(error))
-      };
-    }
+    Promise.resolve().then(() => handler(notification)).catch((error) => this._onerror(new Error(`Uncaught error in notification handler: ${error}`)));
   }
-  request(request, resultSchema, options) {
-    const { relatedRequestId, resumptionToken, onresumptiontoken, task, relatedTask } = options ?? {};
-    return new Promise((resolve, reject) => {
-      const earlyReject = (error) => {
-        reject(error);
-      };
-      if (!this._transport) {
-        earlyReject(new Error("Not connected"));
-        return;
-      }
-      if (this._options?.enforceStrictCapabilities === true) {
-        try {
-          this.assertCapabilityForMethod(request.method);
-          if (task) {
-            this.assertTaskCapability(request.method);
-          }
-        } catch (e) {
-          earlyReject(e);
-          return;
-        }
-      }
-      options?.signal?.throwIfAborted();
-      const messageId = this._requestMessageId++;
-      const jsonrpcRequest = {
-        ...request,
+  _onrequest(request, extra) {
+    const handler = this._requestHandlers.get(request.method) ?? this.fallbackRequestHandler;
+    const capturedTransport = this._transport;
+    const relatedTaskId = request.params?._meta?.[RELATED_TASK_META_KEY]?.taskId;
+    if (handler === undefined) {
+      const errorResponse = {
         jsonrpc: "2.0",
-        id: messageId
+        id: request.id,
+        error: {
+          code: ErrorCode.MethodNotFound,
+          message: "Method not found"
+        }
       };
-      if (options?.onprogress) {
-        this._progressHandlers.set(messageId, options.onprogress);
-        jsonrpcRequest.params = {
-          ...request.params,
-          _meta: {
-            ...request.params?._meta || {},
-            progressToken: messageId
-          }
-        };
-      }
-      if (task) {
-        jsonrpcRequest.params = {
-          ...jsonrpcRequest.params,
-          task
-        };
-      }
-      if (relatedTask) {
-        jsonrpcRequest.params = {
-          ...jsonrpcRequest.params,
-          _meta: {
-            ...jsonrpcRequest.params?._meta || {},
-            [RELATED_TASK_META_KEY]: relatedTask
-          }
-        };
+      if (relatedTaskId && this._taskMessageQueue) {
+        this._enqueueTaskMessage(relatedTaskId, {
+          type: "error",
+          message: errorResponse,
+          timestamp: Date.now()
+        }, capturedTransport?.sessionId).catch((error) => this._onerror(new Error(`Failed to enqueue error response: ${error}`)));
+      } else {
+        capturedTransport?.send(errorResponse).catch((error) => this._onerror(new Error(`Failed to send an error response: ${error}`)));
       }
-      const cancel = (reason) => {
-        this._responseHandlers.delete(messageId);
-        this._progressHandlers.delete(messageId);
-        this._cleanupTimeout(messageId);
-        this._transport?.send({
-          jsonrpc: "2.0",
-          method: "notifications/cancelled",
-          params: {
-            requestId: messageId,
-            reason: String(reason)
-          }
-        }, { relatedRequestId, resumptionToken, onresumptiontoken }).catch((error) => this._onerror(new Error(`Failed to send cancellation: ${error}`)));
-        const error = reason instanceof McpError ? reason : new McpError(ErrorCode.RequestTimeout, String(reason));
-        reject(error);
-      };
-      this._responseHandlers.set(messageId, (response) => {
-        if (options?.signal?.aborted) {
+      return;
+    }
+    const abortController = new AbortController;
+    this._requestHandlerAbortControllers.set(request.id, abortController);
+    const taskCreationParams = isTaskAugmentedRequestParams(request.params) ? request.params.task : undefined;
+    const taskStore = this._taskStore ? this.requestTaskStore(request, capturedTransport?.sessionId) : undefined;
+    const fullExtra = {
+      signal: abortController.signal,
+      sessionId: capturedTransport?.sessionId,
+      _meta: request.params?._meta,
+      sendNotification: async (notification) => {
+        if (abortController.signal.aborted)
           return;
+        const notificationOptions = { relatedRequestId: request.id };
+        if (relatedTaskId) {
+          notificationOptions.relatedTask = { taskId: relatedTaskId };
         }
-        if (response instanceof Error) {
-          return reject(response);
+        await this.notification(notification, notificationOptions);
+      },
+      sendRequest: async (r, resultSchema, options) => {
+        if (abortController.signal.aborted) {
+          throw new McpError(ErrorCode.ConnectionClosed, "Request was cancelled");
         }
-        try {
-          const parseResult = safeParse4(resultSchema, response.result);
-          if (!parseResult.success) {
-            reject(parseResult.error);
-          } else {
-            resolve(parseResult.data);
-          }
-        } catch (error) {
-          reject(error);
+        const requestOptions = { ...options, relatedRequestId: request.id };
+        if (relatedTaskId && !requestOptions.relatedTask) {
+          requestOptions.relatedTask = { taskId: relatedTaskId };
         }
-      });
-      options?.signal?.addEventListener("abort", () => {
-        cancel(options?.signal?.reason);
-      });
-      const timeout = options?.timeout ?? DEFAULT_REQUEST_TIMEOUT_MSEC;
-      const timeoutHandler = () => cancel(McpError.fromError(ErrorCode.RequestTimeout, "Request timed out", { timeout }));
-      this._setupTimeout(messageId, timeout, options?.maxTotalTimeout, timeoutHandler, options?.resetTimeoutOnProgress ?? false);
-      const relatedTaskId = relatedTask?.taskId;
-      if (relatedTaskId) {
-        const responseResolver = (response) => {
-          const handler = this._responseHandlers.get(messageId);
-          if (handler) {
-            handler(response);
-          } else {
-            this._onerror(new Error(`Response handler missing for side-channeled request ${messageId}`));
-          }
-        };
-        this._requestResolvers.set(messageId, responseResolver);
-        this._enqueueTaskMessage(relatedTaskId, {
-          type: "request",
-          message: jsonrpcRequest,
+        const effectiveTaskId = requestOptions.relatedTask?.taskId ?? relatedTaskId;
+        if (effectiveTaskId && taskStore) {
+          await taskStore.updateTaskStatus(effectiveTaskId, "input_required");
+        }
+        return await this.request(r, resultSchema, requestOptions);
+      },
+      authInfo: extra?.authInfo,
+      requestId: request.id,
+      requestInfo: extra?.requestInfo,
+      taskId: relatedTaskId,
+      taskStore,
+      taskRequestedTtl: taskCreationParams?.ttl,
+      closeSSEStream: extra?.closeSSEStream,
+      closeStandaloneSSEStream: extra?.closeStandaloneSSEStream
+    };
+    Promise.resolve().then(() => {
+      if (taskCreationParams) {
+        this.assertTaskHandlerCapability(request.method);
+      }
+    }).then(() => handler(request, fullExtra)).then(async (result) => {
+      if (abortController.signal.aborted) {
+        return;
+      }
+      const response = {
+        result,
+        jsonrpc: "2.0",
+        id: request.id
+      };
+      if (relatedTaskId && this._taskMessageQueue) {
+        await this._enqueueTaskMessage(relatedTaskId, {
+          type: "response",
+          message: response,
           timestamp: Date.now()
-        }).catch((error) => {
-          this._cleanupTimeout(messageId);
-          reject(error);
-        });
+        }, capturedTransport?.sessionId);
       } else {
-        this._transport.send(jsonrpcRequest, { relatedRequestId, resumptionToken, onresumptiontoken }).catch((error) => {
-          this._cleanupTimeout(messageId);
-          reject(error);
-        });
+        await capturedTransport?.send(response);
       }
-    });
-  }
-  async getTask(params, options) {
-    return this.request({ method: "tasks/get", params }, GetTaskResultSchema, options);
-  }
-  async getTaskResult(params, resultSchema, options) {
-    return this.request({ method: "tasks/result", params }, resultSchema, options);
-  }
-  async listTasks(params, options) {
-    return this.request({ method: "tasks/list", params }, ListTasksResultSchema, options);
-  }
-  async cancelTask(params, options) {
-    return this.request({ method: "tasks/cancel", params }, CancelTaskResultSchema, options);
-  }
-  async notification(notification, options) {
-    if (!this._transport) {
-      throw new Error("Not connected");
-    }
-    this.assertNotificationCapability(notification.method);
-    const relatedTaskId = options?.relatedTask?.taskId;
-    if (relatedTaskId) {
-      const jsonrpcNotification = {
-        ...notification,
+    }, async (error) => {
+      if (abortController.signal.aborted) {
+        return;
+      }
+      const errorResponse = {
         jsonrpc: "2.0",
-        params: {
-          ...notification.params,
-          _meta: {
-            ...notification.params?._meta || {},
-            [RELATED_TASK_META_KEY]: options.relatedTask
-          }
+        id: request.id,
+        error: {
+          code: Number.isSafeInteger(error["code"]) ? error["code"] : ErrorCode.InternalError,
+          message: error.message ?? "Internal error",
+          ...error["data"] !== undefined && { data: error["data"] }
         }
       };
-      await this._enqueueTaskMessage(relatedTaskId, {
-        type: "notification",
-        message: jsonrpcNotification,
-        timestamp: Date.now()
-      });
+      if (relatedTaskId && this._taskMessageQueue) {
+        await this._enqueueTaskMessage(relatedTaskId, {
+          type: "error",
+          message: errorResponse,
+          timestamp: Date.now()
+        }, capturedTransport?.sessionId);
+      } else {
+        await capturedTransport?.send(errorResponse);
+      }
+    }).catch((error) => this._onerror(new Error(`Failed to send response: ${error}`))).finally(() => {
+      if (this._requestHandlerAbortControllers.get(request.id) === abortController) {
+        this._requestHandlerAbortControllers.delete(request.id);
+      }
+    });
+  }
+  _onprogress(notification) {
+    const { progressToken, ...params } = notification.params;
+    const messageId = Number(progressToken);
+    const handler = this._progressHandlers.get(messageId);
+    if (!handler) {
+      this._onerror(new Error(`Received a progress notification for an unknown token: ${JSON.stringify(notification)}`));
       return;
     }
-    const debouncedMethods = this._options?.debouncedNotificationMethods ?? [];
-    const canDebounce = debouncedMethods.includes(notification.method) && !notification.params && !options?.relatedRequestId && !options?.relatedTask;
-    if (canDebounce) {
-      if (this._pendingDebouncedNotifications.has(notification.method)) {
+    const responseHandler = this._responseHandlers.get(messageId);
+    const timeoutInfo = this._timeoutInfo.get(messageId);
+    if (timeoutInfo && responseHandler && timeoutInfo.resetTimeoutOnProgress) {
+      try {
+        this._resetTimeout(messageId);
+      } catch (error) {
+        this._responseHandlers.delete(messageId);
+        this._progressHandlers.delete(messageId);
+        this._cleanupTimeout(messageId);
+        responseHandler(error);
         return;
       }
-      this._pendingDebouncedNotifications.add(notification.method);
-      Promise.resolve().then(() => {
-        this._pendingDebouncedNotifications.delete(notification.method);
-        if (!this._transport) {
-          return;
-        }
-        let jsonrpcNotification = {
-          ...notification,
-          jsonrpc: "2.0"
-        };
-        if (options?.relatedTask) {
-          jsonrpcNotification = {
-            ...jsonrpcNotification,
-            params: {
-              ...jsonrpcNotification.params,
-              _meta: {
-                ...jsonrpcNotification.params?._meta || {},
-                [RELATED_TASK_META_KEY]: options.relatedTask
-              }
-            }
-          };
-        }
-        this._transport?.send(jsonrpcNotification, options).catch((error) => this._onerror(error));
-      });
+    }
+    handler(params);
+  }
+  _onresponse(response) {
+    const messageId = Number(response.id);
+    const resolver = this._requestResolvers.get(messageId);
+    if (resolver) {
+      this._requestResolvers.delete(messageId);
+      if (isJSONRPCResultResponse(response)) {
+        resolver(response);
+      } else {
+        const error = new McpError(response.error.code, response.error.message, response.error.data);
+        resolver(error);
+      }
       return;
     }
-    let jsonrpcNotification = {
-      ...notification,
-      jsonrpc: "2.0"
-    };
-    if (options?.relatedTask) {
-      jsonrpcNotification = {
-        ...jsonrpcNotification,
-        params: {
-          ...jsonrpcNotification.params,
-          _meta: {
-            ...jsonrpcNotification.params?._meta || {},
-            [RELATED_TASK_META_KEY]: options.relatedTask
-          }
+    const handler = this._responseHandlers.get(messageId);
+    if (handler === undefined) {
+      this._onerror(new Error(`Received a response for an unknown message ID: ${JSON.stringify(response)}`));
+      return;
+    }
+    this._responseHandlers.delete(messageId);
+    this._cleanupTimeout(messageId);
+    let isTaskResponse = false;
+    if (isJSONRPCResultResponse(response) && response.result && typeof response.result === "object") {
+      const result = response.result;
+      if (result.task && typeof result.task === "object") {
+        const task = result.task;
+        if (typeof task.taskId === "string") {
+          isTaskResponse = true;
+          this._taskProgressTokens.set(task.taskId, messageId);
         }
-      };
+      }
     }
-    await this._transport.send(jsonrpcNotification, options);
-  }
-  setRequestHandler(requestSchema, handler) {
-    const method = getMethodLiteral(requestSchema);
-    this.assertRequestHandlerCapability(method);
-    this._requestHandlers.set(method, (request, extra) => {
-      const parsed = parseWithCompat(requestSchema, request);
-      return Promise.resolve(handler(parsed, extra));
-    });
-  }
-  removeRequestHandler(method) {
-    this._requestHandlers.delete(method);
-  }
-  assertCanSetRequestHandler(method) {
-    if (this._requestHandlers.has(method)) {
-      throw new Error(`A request handler for ${method} already exists, which would be overridden`);
+    if (!isTaskResponse) {
+      this._progressHandlers.delete(messageId);
+    }
+    if (isJSONRPCResultResponse(response)) {
+      handler(response);
+    } else {
+      const error = McpError.fromError(response.error.code, response.error.message, response.error.data);
+      handler(error);
     }
   }
-  setNotificationHandler(notificationSchema, handler) {
-    const method = getMethodLiteral(notificationSchema);
-    this._notificationHandlers.set(method, (notification) => {
-      const parsed = parseWithCompat(notificationSchema, notification);
-      return Promise.resolve(handler(parsed));
-    });
-  }
-  removeNotificationHandler(method) {
-    this._notificationHandlers.delete(method);
+  get transport() {
+    return this._transport;
   }
-  _cleanupTaskProgressHandler(taskId) {
-    const progressToken = this._taskProgressTokens.get(taskId);
-    if (progressToken !== undefined) {
-      this._progressHandlers.delete(progressToken);
-      this._taskProgressTokens.delete(taskId);
-    }
+  async close() {
+    await this._transport?.close();
   }
-  async _enqueueTaskMessage(taskId, message, sessionId) {
-    if (!this._taskStore || !this._taskMessageQueue) {
-      throw new Error("Cannot enqueue task message: taskStore and taskMessageQueue are not configured");
+  async* requestStream(request, resultSchema, options) {
+    const { task } = options ?? {};
+    if (!task) {
+      try {
+        const result = await this.request(request, resultSchema, options);
+        yield { type: "result", result };
+      } catch (error) {
+        yield {
+          type: "error",
+          error: error instanceof McpError ? error : new McpError(ErrorCode.InternalError, String(error))
+        };
+      }
+      return;
     }
-    const maxQueueSize = this._options?.maxTaskQueueSize;
-    await this._taskMessageQueue.enqueue(taskId, message, sessionId, maxQueueSize);
-  }
-  async _clearTaskQueue(taskId, sessionId) {
-    if (this._taskMessageQueue) {
-      const messages = await this._taskMessageQueue.dequeueAll(taskId, sessionId);
-      for (const message of messages) {
-        if (message.type === "request" && isJSONRPCRequest(message.message)) {
-          const requestId = message.message.id;
-          const resolver = this._requestResolvers.get(requestId);
-          if (resolver) {
-            resolver(new McpError(ErrorCode.InternalError, "Task cancelled or completed"));
-            this._requestResolvers.delete(requestId);
-          } else {
-            this._onerror(new Error(`Resolver missing for request ${requestId} during task ${taskId} cleanup`));
+    let taskId;
+    try {
+      const createResult = await this.request(request, CreateTaskResultSchema, options);
+      if (createResult.task) {
+        taskId = createResult.task.taskId;
+        yield { type: "taskCreated", task: createResult.task };
+      } else {
+        throw new McpError(ErrorCode.InternalError, "Task creation did not return a task");
+      }
+      while (true) {
+        const task = await this.getTask({ taskId }, options);
+        yield { type: "taskStatus", task };
+        if (isTerminal(task.status)) {
+          if (task.status === "completed") {
+            const result = await this.getTaskResult({ taskId }, resultSchema, options);
+            yield { type: "result", result };
+          } else if (task.status === "failed") {
+            yield {
+              type: "error",
+              error: new McpError(ErrorCode.InternalError, `Task ${taskId} failed`)
+            };
+          } else if (task.status === "cancelled") {
+            yield {
+              type: "error",
+              error: new McpError(ErrorCode.InternalError, `Task ${taskId} was cancelled`)
+            };
           }
+          return;
+        }
+        if (task.status === "input_required") {
+          const result = await this.getTaskResult({ taskId }, resultSchema, options);
+          yield { type: "result", result };
+          return;
         }
+        const pollInterval = task.pollInterval ?? this._options?.defaultTaskPollInterval ?? 1000;
+        await new Promise((resolve) => setTimeout(resolve, pollInterval));
+        options?.signal?.throwIfAborted();
       }
+    } catch (error) {
+      yield {
+        type: "error",
+        error: error instanceof McpError ? error : new McpError(ErrorCode.InternalError, String(error))
+      };
     }
   }
-  async _waitForTaskUpdate(taskId, signal) {
-    let interval = this._options?.defaultTaskPollInterval ?? 1000;
-    try {
-      const task = await this._taskStore?.getTask(taskId);
-      if (task?.pollInterval) {
-        interval = task.pollInterval;
-      }
-    } catch {}
+  request(request, resultSchema, options) {
+    const { relatedRequestId, resumptionToken, onresumptiontoken, task, relatedTask } = options ?? {};
     return new Promise((resolve, reject) => {
-      if (signal.aborted) {
-        reject(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
+      const earlyReject = (error) => {
+        reject(error);
+      };
+      if (!this._transport) {
+        earlyReject(new Error("Not connected"));
         return;
       }
-      const timeoutId = setTimeout(resolve, interval);
-      signal.addEventListener("abort", () => {
-        clearTimeout(timeoutId);
-        reject(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
-      }, { once: true });
-    });
-  }
-  requestTaskStore(request, sessionId) {
-    const taskStore = this._taskStore;
-    if (!taskStore) {
-      throw new Error("No task store configured");
-    }
-    return {
-      createTask: async (taskParams) => {
-        if (!request) {
-          throw new Error("No request provided");
-        }
-        return await taskStore.createTask(taskParams, request.id, {
-          method: request.method,
-          params: request.params
-        }, sessionId);
-      },
-      getTask: async (taskId) => {
-        const task = await taskStore.getTask(taskId, sessionId);
-        if (!task) {
-          throw new McpError(ErrorCode.InvalidParams, "Failed to retrieve task: Task not found");
-        }
-        return task;
-      },
-      storeTaskResult: async (taskId, status, result) => {
-        await taskStore.storeTaskResult(taskId, status, result, sessionId);
-        const task = await taskStore.getTask(taskId, sessionId);
-        if (task) {
-          const notification = TaskStatusNotificationSchema.parse({
-            method: "notifications/tasks/status",
-            params: task
-          });
-          await this.notification(notification);
-          if (isTerminal(task.status)) {
-            this._cleanupTaskProgressHandler(taskId);
-          }
-        }
-      },
-      getTaskResult: (taskId) => {
-        return taskStore.getTaskResult(taskId, sessionId);
-      },
-      updateTaskStatus: async (taskId, status, statusMessage) => {
-        const task = await taskStore.getTask(taskId, sessionId);
-        if (!task) {
-          throw new McpError(ErrorCode.InvalidParams, `Task "${taskId}" not found - it may have been cleaned up`);
-        }
-        if (isTerminal(task.status)) {
-          throw new McpError(ErrorCode.InvalidParams, `Cannot update task "${taskId}" from terminal status "${task.status}" to "${status}". Terminal states (completed, failed, cancelled) cannot transition to other states.`);
-        }
-        await taskStore.updateTaskStatus(taskId, status, statusMessage, sessionId);
-        const updatedTask = await taskStore.getTask(taskId, sessionId);
-        if (updatedTask) {
-          const notification = TaskStatusNotificationSchema.parse({
-            method: "notifications/tasks/status",
-            params: updatedTask
-          });
-          await this.notification(notification);
-          if (isTerminal(updatedTask.status)) {
-            this._cleanupTaskProgressHandler(taskId);
+      if (this._options?.enforceStrictCapabilities === true) {
+        try {
+          this.assertCapabilityForMethod(request.method);
+          if (task) {
+            this.assertTaskCapability(request.method);
           }
+        } catch (e) {
+          earlyReject(e);
+          return;
         }
-      },
-      listTasks: (cursor) => {
-        return taskStore.listTasks(cursor, sessionId);
       }
-    };
-  }
-}
-function isPlainObject3(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-function mergeCapabilities(base, additional) {
-  const result = { ...base };
-  for (const key in additional) {
-    const k = key;
-    const addValue = additional[k];
-    if (addValue === undefined)
-      continue;
-    const baseValue = result[k];
-    if (isPlainObject3(baseValue) && isPlainObject3(addValue)) {
-      result[k] = { ...baseValue, ...addValue };
-    } else {
-      result[k] = addValue;
-    }
-  }
-  return result;
-}
-
-// node_modules/@modelcontextprotocol/sdk/dist/esm/validation/ajv-provider.js
-var import_ajv = __toESM(require_ajv(), 1);
-var import_ajv_formats = __toESM(require_dist(), 1);
-function createDefaultAjvInstance() {
-  const ajv = new import_ajv.default({
-    strict: false,
-    validateFormats: true,
-    validateSchema: false,
-    allErrors: true
-  });
-  const addFormats = import_ajv_formats.default;
-  addFormats(ajv);
-  return ajv;
-}
-
-class AjvJsonSchemaValidator {
-  constructor(ajv) {
-    this._ajv = ajv ?? createDefaultAjvInstance();
-  }
-  getValidator(schema) {
-    const ajvValidator = "$id" in schema && typeof schema.$id === "string" ? this._ajv.getSchema(schema.$id) ?? this._ajv.compile(schema) : this._ajv.compile(schema);
-    return (input) => {
-      const valid = ajvValidator(input);
-      if (valid) {
-        return {
-          valid: true,
-          data: input,
-          errorMessage: undefined
+      options?.signal?.throwIfAborted();
+      const messageId = this._requestMessageId++;
+      const jsonrpcRequest = {
+        ...request,
+        jsonrpc: "2.0",
+        id: messageId
+      };
+      if (options?.onprogress) {
+        this._progressHandlers.set(messageId, options.onprogress);
+        jsonrpcRequest.params = {
+          ...request.params,
+          _meta: {
+            ...request.params?._meta || {},
+            progressToken: messageId
+          }
         };
-      } else {
-        return {
-          valid: false,
-          data: undefined,
-          errorMessage: this._ajv.errorsText(ajvValidator.errors)
+      }
+      if (task) {
+        jsonrpcRequest.params = {
+          ...jsonrpcRequest.params,
+          task
         };
       }
-    };
-  }
-}
-
-// node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/server.js
-class ExperimentalServerTasks {
-  constructor(_server) {
-    this._server = _server;
-  }
-  requestStream(request, resultSchema, options) {
-    return this._server.requestStream(request, resultSchema, options);
-  }
-  createMessageStream(params, options) {
-    const clientCapabilities = this._server.getClientCapabilities();
-    if ((params.tools || params.toolChoice) && !clientCapabilities?.sampling?.tools) {
-      throw new Error("Client does not support sampling tools capability.");
-    }
-    if (params.messages.length > 0) {
-      const lastMessage = params.messages[params.messages.length - 1];
-      const lastContent = Array.isArray(lastMessage.content) ? lastMessage.content : [lastMessage.content];
-      const hasToolResults = lastContent.some((c) => c.type === "tool_result");
-      const previousMessage = params.messages.length > 1 ? params.messages[params.messages.length - 2] : undefined;
-      const previousContent = previousMessage ? Array.isArray(previousMessage.content) ? previousMessage.content : [previousMessage.content] : [];
-      const hasPreviousToolUse = previousContent.some((c) => c.type === "tool_use");
-      if (hasToolResults) {
-        if (lastContent.some((c) => c.type !== "tool_result")) {
-          throw new Error("The last message must contain only tool_result content if any is present");
-        }
-        if (!hasPreviousToolUse) {
-          throw new Error("tool_result blocks are not matching any tool_use from the previous message");
-        }
+      if (relatedTask) {
+        jsonrpcRequest.params = {
+          ...jsonrpcRequest.params,
+          _meta: {
+            ...jsonrpcRequest.params?._meta || {},
+            [RELATED_TASK_META_KEY]: relatedTask
+          }
+        };
       }
-      if (hasPreviousToolUse) {
-        const toolUseIds = new Set(previousContent.filter((c) => c.type === "tool_use").map((c) => c.id));
-        const toolResultIds = new Set(lastContent.filter((c) => c.type === "tool_result").map((c) => c.toolUseId));
-        if (toolUseIds.size !== toolResultIds.size || ![...toolUseIds].every((id) => toolResultIds.has(id))) {
-          throw new Error("ids of tool_result blocks and tool_use blocks from previous message do not match");
+      const cancel = (reason) => {
+        this._responseHandlers.delete(messageId);
+        this._progressHandlers.delete(messageId);
+        this._cleanupTimeout(messageId);
+        this._transport?.send({
+          jsonrpc: "2.0",
+          method: "notifications/cancelled",
+          params: {
+            requestId: messageId,
+            reason: String(reason)
+          }
+        }, { relatedRequestId, resumptionToken, onresumptiontoken }).catch((error) => this._onerror(new Error(`Failed to send cancellation: ${error}`)));
+        const error = reason instanceof McpError ? reason : new McpError(ErrorCode.RequestTimeout, String(reason));
+        reject(error);
+      };
+      this._responseHandlers.set(messageId, (response) => {
+        if (options?.signal?.aborted) {
+          return;
         }
-      }
-    }
-    return this.requestStream({
-      method: "sampling/createMessage",
-      params
-    }, CreateMessageResultSchema, options);
-  }
-  elicitInputStream(params, options) {
-    const clientCapabilities = this._server.getClientCapabilities();
-    const mode = params.mode ?? "form";
-    switch (mode) {
-      case "url": {
-        if (!clientCapabilities?.elicitation?.url) {
-          throw new Error("Client does not support url elicitation.");
+        if (response instanceof Error) {
+          return reject(response);
         }
-        break;
-      }
-      case "form": {
-        if (!clientCapabilities?.elicitation?.form) {
-          throw new Error("Client does not support form elicitation.");
+        try {
+          const parseResult = safeParse4(resultSchema, response.result);
+          if (!parseResult.success) {
+            reject(parseResult.error);
+          } else {
+            resolve(parseResult.data);
+          }
+        } catch (error) {
+          reject(error);
         }
-        break;
+      });
+      options?.signal?.addEventListener("abort", () => {
+        cancel(options?.signal?.reason);
+      });
+      const timeout = options?.timeout ?? DEFAULT_REQUEST_TIMEOUT_MSEC;
+      const timeoutHandler = () => cancel(McpError.fromError(ErrorCode.RequestTimeout, "Request timed out", { timeout }));
+      this._setupTimeout(messageId, timeout, options?.maxTotalTimeout, timeoutHandler, options?.resetTimeoutOnProgress ?? false);
+      const relatedTaskId = relatedTask?.taskId;
+      if (relatedTaskId) {
+        const responseResolver = (response) => {
+          const handler = this._responseHandlers.get(messageId);
+          if (handler) {
+            handler(response);
+          } else {
+            this._onerror(new Error(`Response handler missing for side-channeled request ${messageId}`));
+          }
+        };
+        this._requestResolvers.set(messageId, responseResolver);
+        this._enqueueTaskMessage(relatedTaskId, {
+          type: "request",
+          message: jsonrpcRequest,
+          timestamp: Date.now()
+        }).catch((error) => {
+          this._cleanupTimeout(messageId);
+          reject(error);
+        });
+      } else {
+        this._transport.send(jsonrpcRequest, { relatedRequestId, resumptionToken, onresumptiontoken }).catch((error) => {
+          this._cleanupTimeout(messageId);
+          reject(error);
+        });
       }
-    }
-    const normalizedParams = mode === "form" && params.mode === undefined ? { ...params, mode: "form" } : params;
-    return this.requestStream({
-      method: "elicitation/create",
-      params: normalizedParams
-    }, ElicitResultSchema, options);
-  }
-  async getTask(taskId, options) {
-    return this._server.getTask({ taskId }, options);
-  }
-  async getTaskResult(taskId, resultSchema, options) {
-    return this._server.getTaskResult({ taskId }, resultSchema, options);
-  }
-  async listTasks(cursor, options) {
-    return this._server.listTasks(cursor ? { cursor } : undefined, options);
-  }
-  async cancelTask(taskId, options) {
-    return this._server.cancelTask({ taskId }, options);
+    });
   }
-}
-
-// node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/helpers.js
-function assertToolsCallTaskCapability(requests, method, entityName) {
-  if (!requests) {
-    throw new Error(`${entityName} does not support task creation (required for ${method})`);
+  async getTask(params, options) {
+    return this.request({ method: "tasks/get", params }, GetTaskResultSchema, options);
   }
-  switch (method) {
-    case "tools/call":
-      if (!requests.tools?.call) {
-        throw new Error(`${entityName} does not support task creation for tools/call (required for ${method})`);
-      }
-      break;
-    default:
-      break;
+  async getTaskResult(params, resultSchema, options) {
+    return this.request({ method: "tasks/result", params }, resultSchema, options);
   }
-}
-function assertClientRequestTaskCapability(requests, method, entityName) {
-  if (!requests) {
-    throw new Error(`${entityName} does not support task creation (required for ${method})`);
+  async listTasks(params, options) {
+    return this.request({ method: "tasks/list", params }, ListTasksResultSchema, options);
   }
-  switch (method) {
-    case "sampling/createMessage":
-      if (!requests.sampling?.createMessage) {
-        throw new Error(`${entityName} does not support task creation for sampling/createMessage (required for ${method})`);
-      }
-      break;
-    case "elicitation/create":
-      if (!requests.elicitation?.create) {
-        throw new Error(`${entityName} does not support task creation for elicitation/create (required for ${method})`);
-      }
-      break;
-    default:
-      break;
+  async cancelTask(params, options) {
+    return this.request({ method: "tasks/cancel", params }, CancelTaskResultSchema, options);
   }
-}
-
-// node_modules/@modelcontextprotocol/sdk/dist/esm/server/index.js
-class Server extends Protocol {
-  constructor(_serverInfo, options) {
-    super(options);
-    this._serverInfo = _serverInfo;
-    this._loggingLevels = new Map;
-    this.LOG_LEVEL_SEVERITY = new Map(LoggingLevelSchema.options.map((level, index) => [level, index]));
-    this.isMessageIgnored = (level, sessionId) => {
-      const currentLevel = this._loggingLevels.get(sessionId);
-      return currentLevel ? this.LOG_LEVEL_SEVERITY.get(level) < this.LOG_LEVEL_SEVERITY.get(currentLevel) : false;
-    };
-    this._capabilities = options?.capabilities ?? {};
-    this._instructions = options?.instructions;
-    this._jsonSchemaValidator = options?.jsonSchemaValidator ?? new AjvJsonSchemaValidator;
-    this.setRequestHandler(InitializeRequestSchema, (request) => this._oninitialize(request));
-    this.setNotificationHandler(InitializedNotificationSchema, () => this.oninitialized?.());
-    if (this._capabilities.logging) {
-      this.setRequestHandler(SetLevelRequestSchema, async (request, extra) => {
-        const transportSessionId = extra.sessionId || extra.requestInfo?.headers["mcp-session-id"] || undefined;
-        const { level } = request.params;
-        const parseResult = LoggingLevelSchema.safeParse(level);
-        if (parseResult.success) {
-          this._loggingLevels.set(transportSessionId, parseResult.data);
-        }
-        return {};
-      });
+  async notification(notification, options) {
+    if (!this._transport) {
+      throw new Error("Not connected");
     }
-  }
-  get experimental() {
-    if (!this._experimental) {
-      this._experimental = {
-        tasks: new ExperimentalServerTasks(this)
+    this.assertNotificationCapability(notification.method);
+    const relatedTaskId = options?.relatedTask?.taskId;
+    if (relatedTaskId) {
+      const jsonrpcNotification = {
+        ...notification,
+        jsonrpc: "2.0",
+        params: {
+          ...notification.params,
+          _meta: {
+            ...notification.params?._meta || {},
+            [RELATED_TASK_META_KEY]: options.relatedTask
+          }
+        }
       };
+      await this._enqueueTaskMessage(relatedTaskId, {
+        type: "notification",
+        message: jsonrpcNotification,
+        timestamp: Date.now()
+      });
+      return;
     }
-    return this._experimental;
-  }
-  registerCapabilities(capabilities) {
-    if (this.transport) {
-      throw new Error("Cannot register capabilities after connecting to transport");
-    }
-    this._capabilities = mergeCapabilities(this._capabilities, capabilities);
-  }
-  setRequestHandler(requestSchema, handler) {
-    const shape = getObjectShape(requestSchema);
-    const methodSchema = shape?.method;
-    if (!methodSchema) {
-      throw new Error("Schema is missing a method literal");
-    }
-    const methodValue = getLiteralValue(methodSchema);
-    if (typeof methodValue !== "string") {
-      throw new Error("Schema method literal must be a string");
-    }
-    const method = methodValue;
-    if (method === "tools/call") {
-      const wrappedHandler = async (request, extra) => {
-        const validatedRequest = safeParse4(CallToolRequestSchema, request);
-        if (!validatedRequest.success) {
-          const errorMessage = validatedRequest.error instanceof Error ? validatedRequest.error.message : String(validatedRequest.error);
-          throw new McpError(ErrorCode.InvalidParams, `Invalid tools/call request: ${errorMessage}`);
+    const debouncedMethods = this._options?.debouncedNotificationMethods ?? [];
+    const canDebounce = debouncedMethods.includes(notification.method) && !notification.params && !options?.relatedRequestId && !options?.relatedTask;
+    if (canDebounce) {
+      if (this._pendingDebouncedNotifications.has(notification.method)) {
+        return;
+      }
+      this._pendingDebouncedNotifications.add(notification.method);
+      Promise.resolve().then(() => {
+        this._pendingDebouncedNotifications.delete(notification.method);
+        if (!this._transport) {
+          return;
         }
-        const { params } = validatedRequest.data;
-        const result = await Promise.resolve(handler(request, extra));
-        if (params.task) {
-          const taskValidationResult = safeParse4(CreateTaskResultSchema, result);
-          if (!taskValidationResult.success) {
-            const errorMessage = taskValidationResult.error instanceof Error ? taskValidationResult.error.message : String(taskValidationResult.error);
-            throw new McpError(ErrorCode.InvalidParams, `Invalid task creation result: ${errorMessage}`);
-          }
-          return taskValidationResult.data;
+        let jsonrpcNotification = {
+          ...notification,
+          jsonrpc: "2.0"
+        };
+        if (options?.relatedTask) {
+          jsonrpcNotification = {
+            ...jsonrpcNotification,
+            params: {
+              ...jsonrpcNotification.params,
+              _meta: {
+                ...jsonrpcNotification.params?._meta || {},
+                [RELATED_TASK_META_KEY]: options.relatedTask
+              }
+            }
+          };
         }
-        const validationResult = safeParse4(CallToolResultSchema, result);
-        if (!validationResult.success) {
-          const errorMessage = validationResult.error instanceof Error ? validationResult.error.message : String(validationResult.error);
-          throw new McpError(ErrorCode.InvalidParams, `Invalid tools/call result: ${errorMessage}`);
+        this._transport?.send(jsonrpcNotification, options).catch((error) => this._onerror(error));
+      });
+      return;
+    }
+    let jsonrpcNotification = {
+      ...notification,
+      jsonrpc: "2.0"
+    };
+    if (options?.relatedTask) {
+      jsonrpcNotification = {
+        ...jsonrpcNotification,
+        params: {
+          ...jsonrpcNotification.params,
+          _meta: {
+            ...jsonrpcNotification.params?._meta || {},
+            [RELATED_TASK_META_KEY]: options.relatedTask
+          }
         }
-        return validationResult.data;
       };
-      return super.setRequestHandler(requestSchema, wrappedHandler);
     }
-    return super.setRequestHandler(requestSchema, handler);
+    await this._transport.send(jsonrpcNotification, options);
   }
-  assertCapabilityForMethod(method) {
-    switch (method) {
-      case "sampling/createMessage":
-        if (!this._clientCapabilities?.sampling) {
-          throw new Error(`Client does not support sampling (required for ${method})`);
-        }
-        break;
-      case "elicitation/create":
-        if (!this._clientCapabilities?.elicitation) {
-          throw new Error(`Client does not support elicitation (required for ${method})`);
-        }
-        break;
-      case "roots/list":
-        if (!this._clientCapabilities?.roots) {
-          throw new Error(`Client does not support listing roots (required for ${method})`);
-        }
-        break;
-      case "ping":
-        break;
+  setRequestHandler(requestSchema, handler) {
+    const method = getMethodLiteral(requestSchema);
+    this.assertRequestHandlerCapability(method);
+    this._requestHandlers.set(method, (request, extra) => {
+      const parsed = parseWithCompat(requestSchema, request);
+      return Promise.resolve(handler(parsed, extra));
+    });
+  }
+  removeRequestHandler(method) {
+    this._requestHandlers.delete(method);
+  }
+  assertCanSetRequestHandler(method) {
+    if (this._requestHandlers.has(method)) {
+      throw new Error(`A request handler for ${method} already exists, which would be overridden`);
     }
   }
-  assertNotificationCapability(method) {
-    switch (method) {
-      case "notifications/message":
-        if (!this._capabilities.logging) {
-          throw new Error(`Server does not support logging (required for ${method})`);
-        }
-        break;
-      case "notifications/resources/updated":
-      case "notifications/resources/list_changed":
-        if (!this._capabilities.resources) {
-          throw new Error(`Server does not support notifying about resources (required for ${method})`);
-        }
-        break;
-      case "notifications/tools/list_changed":
-        if (!this._capabilities.tools) {
-          throw new Error(`Server does not support notifying of tool list changes (required for ${method})`);
-        }
-        break;
-      case "notifications/prompts/list_changed":
-        if (!this._capabilities.prompts) {
-          throw new Error(`Server does not support notifying of prompt list changes (required for ${method})`);
-        }
-        break;
-      case "notifications/elicitation/complete":
-        if (!this._clientCapabilities?.elicitation?.url) {
-          throw new Error(`Client does not support URL elicitation (required for ${method})`);
+  setNotificationHandler(notificationSchema, handler) {
+    const method = getMethodLiteral(notificationSchema);
+    this._notificationHandlers.set(method, (notification) => {
+      const parsed = parseWithCompat(notificationSchema, notification);
+      return Promise.resolve(handler(parsed));
+    });
+  }
+  removeNotificationHandler(method) {
+    this._notificationHandlers.delete(method);
+  }
+  _cleanupTaskProgressHandler(taskId) {
+    const progressToken = this._taskProgressTokens.get(taskId);
+    if (progressToken !== undefined) {
+      this._progressHandlers.delete(progressToken);
+      this._taskProgressTokens.delete(taskId);
+    }
+  }
+  async _enqueueTaskMessage(taskId, message, sessionId) {
+    if (!this._taskStore || !this._taskMessageQueue) {
+      throw new Error("Cannot enqueue task message: taskStore and taskMessageQueue are not configured");
+    }
+    const maxQueueSize = this._options?.maxTaskQueueSize;
+    await this._taskMessageQueue.enqueue(taskId, message, sessionId, maxQueueSize);
+  }
+  async _clearTaskQueue(taskId, sessionId) {
+    if (this._taskMessageQueue) {
+      const messages = await this._taskMessageQueue.dequeueAll(taskId, sessionId);
+      for (const message of messages) {
+        if (message.type === "request" && isJSONRPCRequest(message.message)) {
+          const requestId = message.message.id;
+          const resolver = this._requestResolvers.get(requestId);
+          if (resolver) {
+            resolver(new McpError(ErrorCode.InternalError, "Task cancelled or completed"));
+            this._requestResolvers.delete(requestId);
+          } else {
+            this._onerror(new Error(`Resolver missing for request ${requestId} during task ${taskId} cleanup`));
+          }
         }
-        break;
-      case "notifications/cancelled":
-        break;
-      case "notifications/progress":
-        break;
+      }
     }
   }
-  assertRequestHandlerCapability(method) {
-    if (!this._capabilities) {
-      return;
+  async _waitForTaskUpdate(taskId, signal) {
+    let interval = this._options?.defaultTaskPollInterval ?? 1000;
+    try {
+      const task = await this._taskStore?.getTask(taskId);
+      if (task?.pollInterval) {
+        interval = task.pollInterval;
+      }
+    } catch {}
+    return new Promise((resolve, reject) => {
+      if (signal.aborted) {
+        reject(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
+        return;
+      }
+      const timeoutId = setTimeout(resolve, interval);
+      signal.addEventListener("abort", () => {
+        clearTimeout(timeoutId);
+        reject(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
+      }, { once: true });
+    });
+  }
+  requestTaskStore(request, sessionId) {
+    const taskStore = this._taskStore;
+    if (!taskStore) {
+      throw new Error("No task store configured");
     }
-    switch (method) {
-      case "completion/complete":
-        if (!this._capabilities.completions) {
-          throw new Error(`Server does not support completions (required for ${method})`);
+    return {
+      createTask: async (taskParams) => {
+        if (!request) {
+          throw new Error("No request provided");
         }
-        break;
-      case "logging/setLevel":
-        if (!this._capabilities.logging) {
-          throw new Error(`Server does not support logging (required for ${method})`);
+        return await taskStore.createTask(taskParams, request.id, {
+          method: request.method,
+          params: request.params
+        }, sessionId);
+      },
+      getTask: async (taskId) => {
+        const task = await taskStore.getTask(taskId, sessionId);
+        if (!task) {
+          throw new McpError(ErrorCode.InvalidParams, "Failed to retrieve task: Task not found");
         }
-        break;
-      case "prompts/get":
-      case "prompts/list":
-        if (!this._capabilities.prompts) {
-          throw new Error(`Server does not support prompts (required for ${method})`);
+        return task;
+      },
+      storeTaskResult: async (taskId, status, result) => {
+        await taskStore.storeTaskResult(taskId, status, result, sessionId);
+        const task = await taskStore.getTask(taskId, sessionId);
+        if (task) {
+          const notification = TaskStatusNotificationSchema.parse({
+            method: "notifications/tasks/status",
+            params: task
+          });
+          await this.notification(notification);
+          if (isTerminal(task.status)) {
+            this._cleanupTaskProgressHandler(taskId);
+          }
         }
-        break;
-      case "resources/list":
-      case "resources/templates/list":
-      case "resources/read":
-        if (!this._capabilities.resources) {
-          throw new Error(`Server does not support resources (required for ${method})`);
+      },
+      getTaskResult: (taskId) => {
+        return taskStore.getTaskResult(taskId, sessionId);
+      },
+      updateTaskStatus: async (taskId, status, statusMessage) => {
+        const task = await taskStore.getTask(taskId, sessionId);
+        if (!task) {
+          throw new McpError(ErrorCode.InvalidParams, `Task "${taskId}" not found - it may have been cleaned up`);
         }
-        break;
-      case "tools/call":
-      case "tools/list":
-        if (!this._capabilities.tools) {
-          throw new Error(`Server does not support tools (required for ${method})`);
+        if (isTerminal(task.status)) {
+          throw new McpError(ErrorCode.InvalidParams, `Cannot update task "${taskId}" from terminal status "${task.status}" to "${status}". Terminal states (completed, failed, cancelled) cannot transition to other states.`);
         }
-        break;
-      case "tasks/get":
-      case "tasks/list":
-      case "tasks/result":
-      case "tasks/cancel":
-        if (!this._capabilities.tasks) {
-          throw new Error(`Server does not support tasks capability (required for ${method})`);
+        await taskStore.updateTaskStatus(taskId, status, statusMessage, sessionId);
+        const updatedTask = await taskStore.getTask(taskId, sessionId);
+        if (updatedTask) {
+          const notification = TaskStatusNotificationSchema.parse({
+            method: "notifications/tasks/status",
+            params: updatedTask
+          });
+          await this.notification(notification);
+          if (isTerminal(updatedTask.status)) {
+            this._cleanupTaskProgressHandler(taskId);
+          }
         }
-        break;
-      case "ping":
-      case "initialize":
-        break;
-    }
-  }
-  assertTaskCapability(method) {
-    assertClientRequestTaskCapability(this._clientCapabilities?.tasks?.requests, method, "Client");
-  }
-  assertTaskHandlerCapability(method) {
-    if (!this._capabilities) {
-      return;
-    }
-    assertToolsCallTaskCapability(this._capabilities.tasks?.requests, method, "Server");
-  }
-  async _oninitialize(request) {
-    const requestedVersion = request.params.protocolVersion;
-    this._clientCapabilities = request.params.capabilities;
-    this._clientVersion = request.params.clientInfo;
-    const protocolVersion = SUPPORTED_PROTOCOL_VERSIONS.includes(requestedVersion) ? requestedVersion : LATEST_PROTOCOL_VERSION;
-    return {
-      protocolVersion,
-      capabilities: this.getCapabilities(),
-      serverInfo: this._serverInfo,
-      ...this._instructions && { instructions: this._instructions }
+      },
+      listTasks: (cursor) => {
+        return taskStore.listTasks(cursor, sessionId);
+      }
     };
   }
-  getClientCapabilities() {
-    return this._clientCapabilities;
+}
+function isPlainObject3(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function mergeCapabilities(base, additional) {
+  const result = { ...base };
+  for (const key in additional) {
+    const k = key;
+    const addValue = additional[k];
+    if (addValue === undefined)
+      continue;
+    const baseValue = result[k];
+    if (isPlainObject3(baseValue) && isPlainObject3(addValue)) {
+      result[k] = { ...baseValue, ...addValue };
+    } else {
+      result[k] = addValue;
+    }
+  }
+  return result;
+}
+
+// node_modules/@modelcontextprotocol/sdk/dist/esm/validation/ajv-provider.js
+var import_ajv = __toESM(require_ajv(), 1);
+var import_ajv_formats = __toESM(require_dist(), 1);
+function createDefaultAjvInstance() {
+  const ajv = new import_ajv.default({
+    strict: false,
+    validateFormats: true,
+    validateSchema: false,
+    allErrors: true
+  });
+  const addFormats = import_ajv_formats.default;
+  addFormats(ajv);
+  return ajv;
+}
+
+class AjvJsonSchemaValidator {
+  constructor(ajv) {
+    this._ajv = ajv ?? createDefaultAjvInstance();
   }
-  getClientVersion() {
-    return this._clientVersion;
+  getValidator(schema) {
+    const ajvValidator = "$id" in schema && typeof schema.$id === "string" ? this._ajv.getSchema(schema.$id) ?? this._ajv.compile(schema) : this._ajv.compile(schema);
+    return (input) => {
+      const valid = ajvValidator(input);
+      if (valid) {
+        return {
+          valid: true,
+          data: input,
+          errorMessage: undefined
+        };
+      } else {
+        return {
+          valid: false,
+          data: undefined,
+          errorMessage: this._ajv.errorsText(ajvValidator.errors)
+        };
+      }
+    };
   }
-  getCapabilities() {
-    return this._capabilities;
+}
+
+// node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/server.js
+class ExperimentalServerTasks {
+  constructor(_server) {
+    this._server = _server;
   }
-  async ping() {
-    return this.request({ method: "ping" }, EmptyResultSchema);
+  requestStream(request, resultSchema, options) {
+    return this._server.requestStream(request, resultSchema, options);
   }
-  async createMessage(params, options) {
-    if (params.tools || params.toolChoice) {
-      if (!this._clientCapabilities?.sampling?.tools) {
-        throw new Error("Client does not support sampling tools capability.");
-      }
+  createMessageStream(params, options) {
+    const clientCapabilities = this._server.getClientCapabilities();
+    if ((params.tools || params.toolChoice) && !clientCapabilities?.sampling?.tools) {
+      throw new Error("Client does not support sampling tools capability.");
     }
     if (params.messages.length > 0) {
       const lastMessage = params.messages[params.messages.length - 1];
@@ -25570,807 +25909,572 @@ class Server extends Protocol {
         }
       }
     }
-    if (params.tools) {
-      return this.request({ method: "sampling/createMessage", params }, CreateMessageResultWithToolsSchema, options);
-    }
-    return this.request({ method: "sampling/createMessage", params }, CreateMessageResultSchema, options);
+    return this.requestStream({
+      method: "sampling/createMessage",
+      params
+    }, CreateMessageResultSchema, options);
   }
-  async elicitInput(params, options) {
+  elicitInputStream(params, options) {
+    const clientCapabilities = this._server.getClientCapabilities();
     const mode = params.mode ?? "form";
     switch (mode) {
       case "url": {
-        if (!this._clientCapabilities?.elicitation?.url) {
+        if (!clientCapabilities?.elicitation?.url) {
           throw new Error("Client does not support url elicitation.");
         }
-        const urlParams = params;
-        return this.request({ method: "elicitation/create", params: urlParams }, ElicitResultSchema, options);
+        break;
       }
       case "form": {
-        if (!this._clientCapabilities?.elicitation?.form) {
+        if (!clientCapabilities?.elicitation?.form) {
           throw new Error("Client does not support form elicitation.");
         }
-        const formParams = params.mode === "form" ? params : { ...params, mode: "form" };
-        const result = await this.request({ method: "elicitation/create", params: formParams }, ElicitResultSchema, options);
-        if (result.action === "accept" && result.content && formParams.requestedSchema) {
-          try {
-            const validator = this._jsonSchemaValidator.getValidator(formParams.requestedSchema);
-            const validationResult = validator(result.content);
-            if (!validationResult.valid) {
-              throw new McpError(ErrorCode.InvalidParams, `Elicitation response content does not match requested schema: ${validationResult.errorMessage}`);
-            }
-          } catch (error) {
-            if (error instanceof McpError) {
-              throw error;
-            }
-            throw new McpError(ErrorCode.InternalError, `Error validating elicitation response: ${error instanceof Error ? error.message : String(error)}`);
-          }
-        }
-        return result;
-      }
-    }
-  }
-  createElicitationCompletionNotifier(elicitationId, options) {
-    if (!this._clientCapabilities?.elicitation?.url) {
-      throw new Error("Client does not support URL elicitation (required for notifications/elicitation/complete)");
-    }
-    return () => this.notification({
-      method: "notifications/elicitation/complete",
-      params: {
-        elicitationId
-      }
-    }, options);
-  }
-  async listRoots(params, options) {
-    return this.request({ method: "roots/list", params }, ListRootsResultSchema, options);
-  }
-  async sendLoggingMessage(params, sessionId) {
-    if (this._capabilities.logging) {
-      if (!this.isMessageIgnored(params.level, sessionId)) {
-        return this.notification({ method: "notifications/message", params });
+        break;
       }
     }
+    const normalizedParams = mode === "form" && params.mode === undefined ? { ...params, mode: "form" } : params;
+    return this.requestStream({
+      method: "elicitation/create",
+      params: normalizedParams
+    }, ElicitResultSchema, options);
   }
-  async sendResourceUpdated(params) {
-    return this.notification({
-      method: "notifications/resources/updated",
-      params
-    });
-  }
-  async sendResourceListChanged() {
-    return this.notification({
-      method: "notifications/resources/list_changed"
-    });
-  }
-  async sendToolListChanged() {
-    return this.notification({ method: "notifications/tools/list_changed" });
-  }
-  async sendPromptListChanged() {
-    return this.notification({ method: "notifications/prompts/list_changed" });
-  }
-}
-
-// node_modules/@modelcontextprotocol/sdk/dist/esm/server/stdio.js
-import process3 from "node:process";
-
-// node_modules/@modelcontextprotocol/sdk/dist/esm/shared/stdio.js
-var STDIO_DEFAULT_MAX_BUFFER_SIZE = 10 * 1024 * 1024;
-
-class ReadBuffer {
-  constructor(options) {
-    this._maxBufferSize = options?.maxBufferSize ?? STDIO_DEFAULT_MAX_BUFFER_SIZE;
+  async getTask(taskId, options) {
+    return this._server.getTask({ taskId }, options);
   }
-  append(chunk) {
-    const newSize = (this._buffer?.length ?? 0) + chunk.length;
-    if (newSize > this._maxBufferSize) {
-      this.clear();
-      throw new Error(`ReadBuffer exceeded maximum size of ${this._maxBufferSize} bytes`);
-    }
-    this._buffer = this._buffer ? Buffer.concat([this._buffer, chunk]) : chunk;
+  async getTaskResult(taskId, resultSchema, options) {
+    return this._server.getTaskResult({ taskId }, resultSchema, options);
   }
-  readMessage() {
-    if (!this._buffer) {
-      return null;
-    }
-    const index = this._buffer.indexOf(`
-`);
-    if (index === -1) {
-      return null;
-    }
-    const line = this._buffer.toString("utf8", 0, index).replace(/\r$/, "");
-    this._buffer = this._buffer.subarray(index + 1);
-    return deserializeMessage(line);
+  async listTasks(cursor, options) {
+    return this._server.listTasks(cursor ? { cursor } : undefined, options);
   }
-  clear() {
-    this._buffer = undefined;
+  async cancelTask(taskId, options) {
+    return this._server.cancelTask({ taskId }, options);
   }
 }
-function deserializeMessage(line) {
-  return JSONRPCMessageSchema.parse(JSON.parse(line));
-}
-function serializeMessage(message) {
-  return JSON.stringify(message) + `
-`;
-}
 
-// node_modules/@modelcontextprotocol/sdk/dist/esm/server/stdio.js
-class StdioServerTransport {
-  constructor(_stdin = process3.stdin, _stdout = process3.stdout, options) {
-    this._stdin = _stdin;
-    this._stdout = _stdout;
-    this._started = false;
-    this._ondata = (chunk) => {
-      try {
-        this._readBuffer.append(chunk);
-        this.processReadBuffer();
-      } catch (error) {
-        this.onerror?.(error);
-        this.close().catch(() => {});
-      }
-    };
-    this._onerror = (error) => {
-      this.onerror?.(error);
-    };
-    this._readBuffer = new ReadBuffer({ maxBufferSize: options?.maxBufferSize });
-  }
-  async start() {
-    if (this._started) {
-      throw new Error("StdioServerTransport already started! If using Server class, note that connect() calls start() automatically.");
-    }
-    this._started = true;
-    this._stdin.on("data", this._ondata);
-    this._stdin.on("error", this._onerror);
-  }
-  processReadBuffer() {
-    while (true) {
-      try {
-        const message = this._readBuffer.readMessage();
-        if (message === null) {
-          break;
-        }
-        this.onmessage?.(message);
-      } catch (error) {
-        this.onerror?.(error);
-      }
-    }
-  }
-  async close() {
-    this._stdin.off("data", this._ondata);
-    this._stdin.off("error", this._onerror);
-    const remainingDataListeners = this._stdin.listenerCount("data");
-    if (remainingDataListeners === 0) {
-      this._stdin.pause();
-    }
-    this._readBuffer.clear();
-    this.onclose?.();
+// node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/helpers.js
+function assertToolsCallTaskCapability(requests, method, entityName) {
+  if (!requests) {
+    throw new Error(`${entityName} does not support task creation (required for ${method})`);
   }
-  send(message) {
-    return new Promise((resolve) => {
-      const json = serializeMessage(message);
-      if (this._stdout.write(json)) {
-        resolve();
-      } else {
-        this._stdout.once("drain", resolve);
+  switch (method) {
+    case "tools/call":
+      if (!requests.tools?.call) {
+        throw new Error(`${entityName} does not support task creation for tools/call (required for ${method})`);
       }
-    });
+      break;
+    default:
+      break;
   }
 }
-
-// packages/workit-mcp/src/server.ts
-import { fileURLToPath as fileURLToPath2 } from "node:url";
-
-// packages/workit-core/src/core/boundary.ts
-import { statSync } from "node:fs";
-var EVENT = {
-  initialization: "initialization",
-  provenance: "provenance",
-  assets: "assets",
-  configurationSource: "configuration_source",
-  hooks: "hooks",
-  mcpConnection: "mcp_connection",
-  migration: "migration",
-  installSteps: "install_steps",
-  uncaughtFailure: "uncaught_failure",
-  toolsFailed: "tools_failed",
-  doctor: "doctor"
-};
-var errorDetail = (err) => {
-  if (err instanceof Error) {
-    return { error_name: err.name, error: err.message };
+function assertClientRequestTaskCapability(requests, method, entityName) {
+  if (!requests) {
+    throw new Error(`${entityName} does not support task creation (required for ${method})`);
   }
-  return { error_name: "unknown", error: String(err) };
-};
-var markSourcesLoaded = (files, loadedAt = Date.now()) => ({
-  loadedAt,
-  files: [...files]
-});
-var changedSourcesSinceLoad = (marker) => {
-  const changed = [];
-  for (const file of marker.files) {
-    try {
-      if (statSync(file).mtimeMs > marker.loadedAt)
-        changed.push(file);
-    } catch {}
+  switch (method) {
+    case "sampling/createMessage":
+      if (!requests.sampling?.createMessage) {
+        throw new Error(`${entityName} does not support task creation for sampling/createMessage (required for ${method})`);
+      }
+      break;
+    case "elicitation/create":
+      if (!requests.elicitation?.create) {
+        throw new Error(`${entityName} does not support task creation for elicitation/create (required for ${method})`);
+      }
+      break;
+    default:
+      break;
   }
-  return changed;
-};
-
-// packages/workit-core/src/core/logger.ts
-import os from "node:os";
-var REDACTED = "[REDACTED]";
-var SECRET_VALUE = /\b(?:Bearer|Basic|Digest|Token)\s+\S+/gi;
-var KEY_EQ_VALUE = /\b([A-Za-z0-9_-]*(?:token|secret|password|passwd|apikey|api[_-]?key|authorization|credential|bearer)[A-Za-z0-9_-]*)([:=]\s*).+/gi;
-var URL_QUERY = /(https?:\/\/[^?#\s]+)\?[^#\s]*/g;
-var SENSITIVE_WORDS = new Set([
-  "token",
-  "secret",
-  "password",
-  "passwd",
-  "authorization",
-  "credential",
-  "credentials",
-  "cookie",
-  "api",
-  "apikey",
-  "apitoken",
-  "accesstoken",
-  "clientsecret",
-  "refreshtoken",
-  "key",
-  "bearer",
-  "prompt",
-  "message",
-  "messages",
-  "content",
-  "body",
-  "args",
-  "argument",
-  "result",
-  "results",
-  "output",
-  "issue",
-  "description",
-  "summary",
-  "payload",
-  "script",
-  "command",
-  "text",
-  "query"
-]);
-var STACK_WORDS = new Set(["stack", "stacktrace", "trace"]);
-var escapeRegExp = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-var homePattern = new RegExp(`${escapeRegExp(os.homedir())}(?=[/\\\\]|$)|\\$HOME(?=[/\\\\]|$)`, "g");
-var applyPatterns = (value) => {
-  let out = value;
-  out = out.replace(SECRET_VALUE, REDACTED);
-  out = out.replace(KEY_EQ_VALUE, "$1$2[REDACTED]");
-  out = out.replace(URL_QUERY, "$1?[REDACTED]");
-  out = out.replace(homePattern, "~");
-  if (process.platform === "win32")
-    out = out.replace(/\\/g, "/");
-  return out;
-};
-var redactSecrets = (value) => applyPatterns(value);
+}
 
-// packages/workit-core/src/core/git.ts
-import { execFileSync } from "node:child_process";
-var run2 = (cwd, args) => {
-  try {
-    const stdout = execFileSync("git", args, {
-      cwd,
-      encoding: "utf8",
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-    return { stdout: stdout.trimEnd(), stderr: "", exitCode: 0 };
-  } catch (error) {
-    const e = error;
-    return {
-      stdout: (e.stdout ?? "").trimEnd(),
-      stderr: (e.stderr ?? "").trimEnd(),
-      exitCode: e.status ?? 1
+// node_modules/@modelcontextprotocol/sdk/dist/esm/server/index.js
+class Server extends Protocol {
+  constructor(_serverInfo, options) {
+    super(options);
+    this._serverInfo = _serverInfo;
+    this._loggingLevels = new Map;
+    this.LOG_LEVEL_SEVERITY = new Map(LoggingLevelSchema.options.map((level, index) => [level, index]));
+    this.isMessageIgnored = (level, sessionId) => {
+      const currentLevel = this._loggingLevels.get(sessionId);
+      return currentLevel ? this.LOG_LEVEL_SEVERITY.get(level) < this.LOG_LEVEL_SEVERITY.get(currentLevel) : false;
     };
-  }
-};
-var gitContext = (workspaceRoot, paths = []) => {
-  const cwd = workspaceRoot;
-  let failure;
-  const runHere = (args) => {
-    const result = run2(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);
+    this._capabilities = options?.capabilities ?? {};
+    this._instructions = options?.instructions;
+    this._jsonSchemaValidator = options?.jsonSchemaValidator ?? new AjvJsonSchemaValidator;
+    this.setRequestHandler(InitializeRequestSchema, (request) => this._oninitialize(request));
+    this.setNotificationHandler(InitializedNotificationSchema, () => this.oninitialized?.());
+    if (this._capabilities.logging) {
+      this.setRequestHandler(SetLevelRequestSchema, async (request, extra) => {
+        const transportSessionId = extra.sessionId || extra.requestInfo?.headers["mcp-session-id"] || undefined;
+        const { level } = request.params;
+        const parseResult = LoggingLevelSchema.safeParse(level);
+        if (parseResult.success) {
+          this._loggingLevels.set(transportSessionId, parseResult.data);
+        }
+        return {};
+      });
     }
   }
-  const pathArgs = paths.length ? ["--", ...paths] : [];
-  const diff_stat = runHere(["diff", "--stat", ...pathArgs]);
-  const cached_stat = runHere(["diff", "--cached", "--stat", ...pathArgs]);
-  const stagedSet = new Set(staged);
-  const unstagedSet = new Set(unstaged);
-  const partial_staged = [...stagedSet].filter((f) => unstagedSet.has(f));
-  return {
-    workspace_root: cwd,
-    branch,
-    status_short,
-    staged,
-    unstaged,
-    untracked,
-    diff_stat: [diff_stat, cached_stat].filter(Boolean).join(`
-`),
-    partial_staged: partial_staged.length > 0,
-    partial_staged_files: partial_staged,
-    ...failure ? { stderr: failure.stderr, exitCode: failure.exitCode } : {}
-  };
-};
-
-// packages/workit-core/src/core/config.ts
-import {
-  copyFileSync,
-  cpSync,
-  existsSync as existsSync5,
-  mkdirSync as mkdirSync2,
-  readFileSync as readFileSync4,
-  readdirSync as readdirSync3,
-  writeFileSync as writeFileSync2
-} from "node:fs";
-import os2 from "node:os";
-import path8 from "node:path";
-var diagnosticLogger;
-var PRESETS = {
-  gitflow: {
-    allowed: ["feature/*", "bugfix/*", "hotfix/*", "release/*"],
-    protected: ["main", "develop", "master", "prod", "production"]
-  },
-  "github-flow": { allowed: ["*"], protected: ["main"] },
-  "trunk-based": { allowed: ["*"], protected: ["main"] },
-  custom: { allowed: [], protected: [] }
-};
-var mergePreset = (preset, input = {}, current = {
-  branchPolicy: { preset, allowed: [], protected: [] }
-}) => {
-  const defs = PRESETS[preset];
-  return {
-    preset,
-    allowed: preset === "custom" ? input.allowed ?? current.branchPolicy.allowed : [...defs.allowed],
-    protected: preset === "custom" ? input.protectedNames ?? current.branchPolicy.protected : [...defs.protected]
-  };
-};
-var resolveConfigDir = () => process.env.WORKFLOW_TOOLKIT_CONFIG ?? process.env.WORKFLOW_TOOLKIT_CONFIG_DIR ?? path8.join(process.env.XDG_CONFIG_HOME || path8.join(os2.homedir(), ".config"), "workit");
-var migratedDir = null;
-var migrationFailed = false;
-var ensureConfigDir = (dir = resolveConfigDir()) => {
-  if (migratedDir === dir)
-    return dir;
-  if (process.env.WORKFLOW_TOOLKIT_CONFIG || process.env.WORKFLOW_TOOLKIT_CONFIG_DIR) {
-    migratedDir = dir;
-    return dir;
+  get experimental() {
+    if (!this._experimental) {
+      this._experimental = {
+        tasks: new ExperimentalServerTasks(this)
+      };
+    }
+    return this._experimental;
   }
-  const legacy = path8.join(process.env.XDG_CONFIG_HOME || path8.join(os2.homedir(), ".config"), "workflow-toolkit");
-  if (!existsSync5(legacy)) {
-    migratedDir = dir;
-    return dir;
+  registerCapabilities(capabilities) {
+    if (this.transport) {
+      throw new Error("Cannot register capabilities after connecting to transport");
+    }
+    this._capabilities = mergeCapabilities(this._capabilities, capabilities);
   }
-  if (!migrationFailed && existsSync5(dir)) {
-    migratedDir = dir;
-    return dir;
+  setRequestHandler(requestSchema, handler) {
+    const shape = getObjectShape(requestSchema);
+    const methodSchema = shape?.method;
+    if (!methodSchema) {
+      throw new Error("Schema is missing a method literal");
+    }
+    const methodValue = getLiteralValue(methodSchema);
+    if (typeof methodValue !== "string") {
+      throw new Error("Schema method literal must be a string");
+    }
+    const method = methodValue;
+    if (method === "tools/call") {
+      const wrappedHandler = async (request, extra) => {
+        const validatedRequest = safeParse4(CallToolRequestSchema, request);
+        if (!validatedRequest.success) {
+          const errorMessage = validatedRequest.error instanceof Error ? validatedRequest.error.message : String(validatedRequest.error);
+          throw new McpError(ErrorCode.InvalidParams, `Invalid tools/call request: ${errorMessage}`);
+        }
+        const { params } = validatedRequest.data;
+        const result = await Promise.resolve(handler(request, extra));
+        if (params.task) {
+          const taskValidationResult = safeParse4(CreateTaskResultSchema, result);
+          if (!taskValidationResult.success) {
+            const errorMessage = taskValidationResult.error instanceof Error ? taskValidationResult.error.message : String(taskValidationResult.error);
+            throw new McpError(ErrorCode.InvalidParams, `Invalid task creation result: ${errorMessage}`);
+          }
+          return taskValidationResult.data;
+        }
+        const validationResult = safeParse4(CallToolResultSchema, result);
+        if (!validationResult.success) {
+          const errorMessage = validationResult.error instanceof Error ? validationResult.error.message : String(validationResult.error);
+          throw new McpError(ErrorCode.InvalidParams, `Invalid tools/call result: ${errorMessage}`);
+        }
+        return validationResult.data;
+      };
+      return super.setRequestHandler(requestSchema, wrappedHandler);
+    }
+    return super.setRequestHandler(requestSchema, handler);
   }
-  migrationFailed = false;
-  mkdirSync2(dir, { recursive: true });
-  diagnosticLogger?.info(EVENT.migration, { from: legacy, to: dir });
-  for (const entry of readdirSync3(legacy, { withFileTypes: true })) {
-    const src = path8.join(legacy, entry.name);
-    const dest = path8.join(dir, entry.name);
-    if (existsSync5(dest))
-      continue;
-    try {
-      if (entry.isDirectory())
-        cpSync(src, dest, { recursive: true });
-      else if (entry.isFile())
-        copyFileSync(src, dest);
-    } catch (err) {
-      migrationFailed = true;
-      diagnosticLogger?.warn(EVENT.migration, { from: src, ok: false, ...errorDetail(err) });
-      console.warn(`[workit] config migration: a file could not be copied to ${dir}; it will be retried on the next run`);
+  assertCapabilityForMethod(method) {
+    switch (method) {
+      case "sampling/createMessage":
+        if (!this._clientCapabilities?.sampling) {
+          throw new Error(`Client does not support sampling (required for ${method})`);
+        }
+        break;
+      case "elicitation/create":
+        if (!this._clientCapabilities?.elicitation) {
+          throw new Error(`Client does not support elicitation (required for ${method})`);
+        }
+        break;
+      case "roots/list":
+        if (!this._clientCapabilities?.roots) {
+          throw new Error(`Client does not support listing roots (required for ${method})`);
+        }
+        break;
+      case "ping":
+        break;
     }
   }
-  if (!migrationFailed)
-    migratedDir = dir;
-  return dir;
-};
-var configDir = () => ensureConfigDir();
-var LOCALE_RE = /^[a-z]{2,3}(-(?:[A-Z]{2}|[0-9]{3}))?$/;
-var DEFAULTS = {
-  locale: "en",
-  localeOptions: ["en", "es-CL", "es-MX", "es-AR", "pt-BR"],
-  timezone: "America/Santiago",
-  branchPolicy: {
-    preset: "gitflow",
-    allowed: [...PRESETS.gitflow.allowed],
-    protected: [...PRESETS.gitflow.protected]
-  },
-  commitPolicy: { preset: "conventional" }
-};
-var readSafe = (p) => {
-  try {
-    return readFileSync4(p, "utf8");
-  } catch {
-    return null;
+  assertNotificationCapability(method) {
+    switch (method) {
+      case "notifications/message":
+        if (!this._capabilities.logging) {
+          throw new Error(`Server does not support logging (required for ${method})`);
+        }
+        break;
+      case "notifications/resources/updated":
+      case "notifications/resources/list_changed":
+        if (!this._capabilities.resources) {
+          throw new Error(`Server does not support notifying about resources (required for ${method})`);
+        }
+        break;
+      case "notifications/tools/list_changed":
+        if (!this._capabilities.tools) {
+          throw new Error(`Server does not support notifying of tool list changes (required for ${method})`);
+        }
+        break;
+      case "notifications/prompts/list_changed":
+        if (!this._capabilities.prompts) {
+          throw new Error(`Server does not support notifying of prompt list changes (required for ${method})`);
+        }
+        break;
+      case "notifications/elicitation/complete":
+        if (!this._clientCapabilities?.elicitation?.url) {
+          throw new Error(`Client does not support URL elicitation (required for ${method})`);
+        }
+        break;
+      case "notifications/cancelled":
+        break;
+      case "notifications/progress":
+        break;
+    }
   }
-};
-var isConfigObject = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
-var parseConfigResult = (raw, file) => {
-  if (raw === null)
-    return { status: "missing", path: file };
-  let parsed;
-  try {
-    parsed = JSON.parse(raw);
-  } catch {
-    return { status: "malformed", path: file, error: `${file} is not valid JSON` };
+  assertRequestHandlerCapability(method) {
+    if (!this._capabilities) {
+      return;
+    }
+    switch (method) {
+      case "completion/complete":
+        if (!this._capabilities.completions) {
+          throw new Error(`Server does not support completions (required for ${method})`);
+        }
+        break;
+      case "logging/setLevel":
+        if (!this._capabilities.logging) {
+          throw new Error(`Server does not support logging (required for ${method})`);
+        }
+        break;
+      case "prompts/get":
+      case "prompts/list":
+        if (!this._capabilities.prompts) {
+          throw new Error(`Server does not support prompts (required for ${method})`);
+        }
+        break;
+      case "resources/list":
+      case "resources/templates/list":
+      case "resources/read":
+        if (!this._capabilities.resources) {
+          throw new Error(`Server does not support resources (required for ${method})`);
+        }
+        break;
+      case "tools/call":
+      case "tools/list":
+        if (!this._capabilities.tools) {
+          throw new Error(`Server does not support tools (required for ${method})`);
+        }
+        break;
+      case "tasks/get":
+      case "tasks/list":
+      case "tasks/result":
+      case "tasks/cancel":
+        if (!this._capabilities.tasks) {
+          throw new Error(`Server does not support tasks capability (required for ${method})`);
+        }
+        break;
+      case "ping":
+      case "initialize":
+        break;
+    }
   }
-  if (!isConfigObject(parsed)) {
-    return { status: "malformed", path: file, error: `${file} is not a JSON object` };
+  assertTaskCapability(method) {
+    assertClientRequestTaskCapability(this._clientCapabilities?.tasks?.requests, method, "Client");
   }
-  const input = parsed;
-  const locale = LOCALE_RE.test(String(input.locale ?? "")) ? input.locale : DEFAULTS.locale;
-  const preset = Object.hasOwn(PRESETS, input.branchPolicy?.preset) ? input.branchPolicy?.preset : "gitflow";
-  const commitPreset = COMMIT_PRESETS.includes(String(input.commitPolicy?.preset ?? "")) ? input.commitPolicy?.preset : "conventional";
-  return {
-    status: "valid",
-    path: file,
-    config: {
-      locale,
-      localeOptions: Array.isArray(input.localeOptions) ? input.localeOptions : DEFAULTS.localeOptions,
-      timezone: input.timezone ?? DEFAULTS.timezone,
-      branchPolicy: mergePreset(preset, {
-        allowed: Array.isArray(input.branchPolicy?.allowed) ? input.branchPolicy.allowed : undefined,
-        protectedNames: Array.isArray(input.branchPolicy?.protected) ? input.branchPolicy.protected : undefined
-      }, DEFAULTS),
-      commitPolicy: {
-        preset: commitPreset,
-        ...typeof input.commitPolicy?.pattern === "string" ? { pattern: input.commitPolicy.pattern } : {}
-      }
-    }
-  };
-};
-var readConfigTyped = (dir) => {
-  const file = path8.join(dir ?? configDir(), "config.json");
-  return parseConfigResult(readSafe(file), file);
-};
-var readConfig = () => {
-  const result = readConfigTyped();
-  if (result.status === "malformed")
-    throw new Error(result.error);
-  return result.config ?? DEFAULTS;
-};
-var resolveBranchPolicy = (config, workspace) => {
-  const wp = workspace?.branchPolicy ?? {};
-  const preset = Object.hasOwn(PRESETS, wp.preset) ? wp.preset : config.branchPolicy?.preset ?? "gitflow";
-  const merged = mergePreset(preset, {
-    allowed: wp.allowed,
-    protectedNames: wp.protected
-  }, config);
-  const allowed = merged.allowed.map((p) => new RegExp(`^${p.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*")}$`, "i"));
-  return {
-    preset,
-    allowed,
-    protected: new Set(merged.protected.map((p) => p.toLowerCase())),
-    integration: wp.integration === "merge" ? "merge" : "pr",
-    defaultTargetBranch: preset === "github-flow" ? "main" : preset === "trunk-based" ? "master" : "develop"
-  };
-};
-var COMMIT_PRESETS = [
-  "conventional",
-  "gitmoji",
-  "ticket-prefix",
-  "freeform",
-  "custom",
-  "auto"
-];
-
-// packages/workit-core/src/core/workspaces.ts
-import { readFileSync as readFileSync5, realpathSync as realpathSync6 } from "node:fs";
-import path9 from "node:path";
-var readWorkspacesResult = (dir = configDir()) => {
-  const file = path9.join(dir, "workspaces.json");
-  let raw;
-  try {
-    raw = readFileSync5(file, "utf8");
-  } catch {
-    return { status: "missing", path: file, entries: [] };
+  assertTaskHandlerCapability(method) {
+    if (!this._capabilities) {
+      return;
+    }
+    assertToolsCallTaskCapability(this._capabilities.tasks?.requests, method, "Server");
   }
-  let parsed;
-  try {
-    parsed = JSON.parse(raw);
-  } catch {
-    return { status: "malformed", path: file, entries: [], error: `${file} is not valid JSON` };
+  async _oninitialize(request) {
+    const requestedVersion = request.params.protocolVersion;
+    this._clientCapabilities = request.params.capabilities;
+    this._clientVersion = request.params.clientInfo;
+    const protocolVersion = SUPPORTED_PROTOCOL_VERSIONS.includes(requestedVersion) ? requestedVersion : LATEST_PROTOCOL_VERSION;
+    return {
+      protocolVersion,
+      capabilities: this.getCapabilities(),
+      serverInfo: this._serverInfo,
+      ...this._instructions && { instructions: this._instructions }
+    };
   }
-  if (!isConfigObject(parsed)) {
-    return { status: "malformed", path: file, entries: [], error: `${file} is not a JSON object` };
+  getClientCapabilities() {
+    return this._clientCapabilities;
   }
-  const list = parsed.workspaces;
-  return {
-    status: "valid",
-    path: file,
-    entries: Array.isArray(list) ? list : []
-  };
-};
-var loadWorkspacesFrom = (dir) => readWorkspacesResult(dir).entries;
-var globToRegExp = (glob) => {
-  let out = "";
-  for (let i = 0;i < glob.length; i++) {
-    const c = glob[i];
-    if (c === "*") {
-      if (glob[i + 1] === "*") {
-        if (glob[i + 2] === "/") {
-          if (out === "")
-            out += "/?";
-          out += "(?:[^/]+/)*";
-          i += 2;
-        } else {
-          if (i + 2 >= glob.length) {
-            if (out.endsWith("/")) {
-              out = out.slice(0, -1);
-              out += "(?:/.*)?";
-            } else {
-              out += ".*";
+  getClientVersion() {
+    return this._clientVersion;
+  }
+  getCapabilities() {
+    return this._capabilities;
+  }
+  async ping() {
+    return this.request({ method: "ping" }, EmptyResultSchema);
+  }
+  async createMessage(params, options) {
+    if (params.tools || params.toolChoice) {
+      if (!this._clientCapabilities?.sampling?.tools) {
+        throw new Error("Client does not support sampling tools capability.");
+      }
+    }
+    if (params.messages.length > 0) {
+      const lastMessage = params.messages[params.messages.length - 1];
+      const lastContent = Array.isArray(lastMessage.content) ? lastMessage.content : [lastMessage.content];
+      const hasToolResults = lastContent.some((c) => c.type === "tool_result");
+      const previousMessage = params.messages.length > 1 ? params.messages[params.messages.length - 2] : undefined;
+      const previousContent = previousMessage ? Array.isArray(previousMessage.content) ? previousMessage.content : [previousMessage.content] : [];
+      const hasPreviousToolUse = previousContent.some((c) => c.type === "tool_use");
+      if (hasToolResults) {
+        if (lastContent.some((c) => c.type !== "tool_result")) {
+          throw new Error("The last message must contain only tool_result content if any is present");
+        }
+        if (!hasPreviousToolUse) {
+          throw new Error("tool_result blocks are not matching any tool_use from the previous message");
+        }
+      }
+      if (hasPreviousToolUse) {
+        const toolUseIds = new Set(previousContent.filter((c) => c.type === "tool_use").map((c) => c.id));
+        const toolResultIds = new Set(lastContent.filter((c) => c.type === "tool_result").map((c) => c.toolUseId));
+        if (toolUseIds.size !== toolResultIds.size || ![...toolUseIds].every((id) => toolResultIds.has(id))) {
+          throw new Error("ids of tool_result blocks and tool_use blocks from previous message do not match");
+        }
+      }
+    }
+    if (params.tools) {
+      return this.request({ method: "sampling/createMessage", params }, CreateMessageResultWithToolsSchema, options);
+    }
+    return this.request({ method: "sampling/createMessage", params }, CreateMessageResultSchema, options);
+  }
+  async elicitInput(params, options) {
+    const mode = params.mode ?? "form";
+    switch (mode) {
+      case "url": {
+        if (!this._clientCapabilities?.elicitation?.url) {
+          throw new Error("Client does not support url elicitation.");
+        }
+        const urlParams = params;
+        return this.request({ method: "elicitation/create", params: urlParams }, ElicitResultSchema, options);
+      }
+      case "form": {
+        if (!this._clientCapabilities?.elicitation?.form) {
+          throw new Error("Client does not support form elicitation.");
+        }
+        const formParams = params.mode === "form" ? params : { ...params, mode: "form" };
+        const result = await this.request({ method: "elicitation/create", params: formParams }, ElicitResultSchema, options);
+        if (result.action === "accept" && result.content && formParams.requestedSchema) {
+          try {
+            const validator = this._jsonSchemaValidator.getValidator(formParams.requestedSchema);
+            const validationResult = validator(result.content);
+            if (!validationResult.valid) {
+              throw new McpError(ErrorCode.InvalidParams, `Elicitation response content does not match requested schema: ${validationResult.errorMessage}`);
             }
-          } else {
-            out += ".*";
+          } catch (error) {
+            if (error instanceof McpError) {
+              throw error;
+            }
+            throw new McpError(ErrorCode.InternalError, `Error validating elicitation response: ${error instanceof Error ? error.message : String(error)}`);
           }
-          i++;
         }
-      } else {
-        out += "[^/]*";
+        return result;
       }
-    } else {
-      out += c.replace(/[.+?^${}()|[\]\\]/g, "\\$&");
     }
   }
-  return new RegExp(`^${out}$`);
-};
-var matchWorkspace = (glob, target) => globToRegExp(glob.replaceAll("\\", "/")).test(target.replaceAll("\\", "/"));
-var realpathOf = (p) => {
-  const real = realpathSync6.native ?? realpathSync6;
-  try {
-    return real(p);
-  } catch {
-    return p;
-  }
-};
-var canonicalGlob = (glob) => {
-  const m = /[*?[\]{]/.exec(glob);
-  const prefix = m ? glob.slice(0, m.index) : glob;
-  const rest = m ? glob.slice(m.index) : "";
-  if (!prefix)
-    return glob;
-  const real = realpathOf(prefix.replace(/\/+$/, "") || "/");
-  return real + (prefix.endsWith("/") ? "/" : "") + rest;
-};
-var resolveWorkspaceFrom = (cwd, dir) => {
-  const targets = [cwd, realpathOf(cwd)].map((p) => p.replaceAll("\\", "/"));
-  for (const entry of loadWorkspacesFrom(dir)) {
-    if (!entry || typeof entry !== "object")
-      continue;
-    const ws = entry;
-    if (typeof ws.glob !== "string" || !ws.glob)
-      continue;
-    const glob = ws.glob.replaceAll("\\", "/");
-    const canonical = canonicalGlob(glob);
-    for (const target of targets) {
-      if (matchWorkspace(glob, target))
-        return ws;
-      if (canonical !== glob && matchWorkspace(canonical, target))
-        return ws;
+  createElicitationCompletionNotifier(elicitationId, options) {
+    if (!this._clientCapabilities?.elicitation?.url) {
+      throw new Error("Client does not support URL elicitation (required for notifications/elicitation/complete)");
     }
+    return () => this.notification({
+      method: "notifications/elicitation/complete",
+      params: {
+        elicitationId
+      }
+    }, options);
   }
-  return null;
-};
-var resolveWorkspace = (cwd) => resolveWorkspaceFrom(cwd, configDir());
-
-// packages/workit-core/src/core/vcs-config.ts
-import fs7 from "node:fs";
-import path10 from "node:path";
-import { spawnSync as spawnSync3 } from "node:child_process";
-var TOKEN_PLACEHOLDER = "YOUR_TOKEN_HERE";
-var vcsConfigPath = () => process.env.WORKFLOW_VCS_CONFIG ?? path10.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;
-  const url = (r.stdout ?? "").trim();
-  if (/github\.com[:/]/.test(url))
-    return "github";
-  if (/gitlab\.com[:/]/.test(url))
-    return "gitlab";
-  return null;
-};
-var readVcsConfig = () => {
-  const file = vcsConfigPath();
-  let raw;
-  try {
-    raw = fs7.readFileSync(file, "utf8");
-  } catch {
-    return { status: "missing", path: file, config: {} };
+  async listRoots(params, options) {
+    return this.request({ method: "roots/list", params }, ListRootsResultSchema, options);
   }
-  let parsed;
-  try {
-    parsed = JSON.parse(raw);
-  } catch {
-    return { status: "malformed", path: file, config: {}, error: `${file} is not valid JSON` };
+  async sendLoggingMessage(params, sessionId) {
+    if (this._capabilities.logging) {
+      if (!this.isMessageIgnored(params.level, sessionId)) {
+        return this.notification({ method: "notifications/message", params });
+      }
+    }
   }
-  if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
-    return { status: "valid", path: file, config: parsed };
+  async sendResourceUpdated(params) {
+    return this.notification({
+      method: "notifications/resources/updated",
+      params
+    });
   }
-  return { status: "malformed", path: file, config: {}, error: `${file} is not a JSON object` };
-};
-function vcsConfig(mode, cwd) {
-  const ws = resolveWorkspace(vcsCwd(cwd));
-  const wsVcs = ws?.vcs ?? {};
-  const wsYt = ws?.youtrack ?? {};
-  const wsIssues = ws?.issues ?? {};
-  const { status: cfgStatus, path: cfgPath, config: cfg, error: cfgError } = readVcsConfig();
-  const root = vcsCwd(cwd);
-  const determinateRoot = cwd !== undefined || process.env.WORKFLOW_WORKSPACE_ROOT !== undefined;
-  const rawProvider = wsVcs.provider ?? (determinateRoot ? remoteProvider(root) : null) ?? cfg.provider ?? null;
-  const provider = rawProvider === null || rawProvider === undefined ? null : String(rawProvider).toLowerCase() || null;
-  const wp = ws?.branchPolicy ?? {};
-  const hasWorkspacePolicy = typeof wp.preset === "string" && Object.hasOwn(PRESETS, wp.preset);
-  const policyDefault = resolveBranchPolicyFor(root).defaultTargetBranch;
-  const defaultTarget = String(wsVcs.defaultTargetBranch ?? (hasWorkspacePolicy ? policyDefault : cfg.defaultTargetBranch ?? policyDefault) ?? "develop");
-  const linkIssues = typeof wsYt.link_issues === "boolean" ? wsYt.link_issues : null;
-  const youtrackBaseUrl = typeof wsYt.baseUrl === "string" ? wsYt.baseUrl : null;
-  let issuesProvider = null;
-  let linkOnPr = null;
-  if (provider === "github" && typeof wsIssues.provider === "string" && wsIssues.provider.toLowerCase() === "github") {
-    issuesProvider = "github";
-    linkOnPr = typeof wsIssues.link_on_pr === "boolean" ? wsIssues.link_on_pr : null;
+  async sendResourceListChanged() {
+    return this.notification({
+      method: "notifications/resources/list_changed"
+    });
   }
-  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
-    };
+  async sendToolListChanged() {
+    return this.notification({ method: "notifications/tools/list_changed" });
   }
-  if (cfgStatus === "malformed") {
-    return { ok: false, error: cfgError, configPath: cfgPath };
+  async sendPromptListChanged() {
+    return this.notification({ method: "notifications/prompts/list_changed" });
   }
-  if (cfgStatus === "missing") {
-    return { ok: false, error: `vcs.json is missing: ${cfgPath}`, configPath: cfgPath };
+}
+
+// node_modules/@modelcontextprotocol/sdk/dist/esm/server/stdio.js
+import process3 from "node:process";
+
+// node_modules/@modelcontextprotocol/sdk/dist/esm/shared/stdio.js
+var STDIO_DEFAULT_MAX_BUFFER_SIZE = 10 * 1024 * 1024;
+
+class ReadBuffer {
+  constructor(options) {
+    this._maxBufferSize = options?.maxBufferSize ?? STDIO_DEFAULT_MAX_BUFFER_SIZE;
   }
-  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
-    };
+  append(chunk) {
+    const newSize = (this._buffer?.length ?? 0) + chunk.length;
+    if (newSize > this._maxBufferSize) {
+      this.clear();
+      throw new Error(`ReadBuffer exceeded maximum size of ${this._maxBufferSize} bytes`);
+    }
+    this._buffer = this._buffer ? Buffer.concat([this._buffer, chunk]) : chunk;
   }
-  const prov = cfg[provider] ?? {};
-  const wsTokenFile = typeof wsVcs.tokenFile === "string" && wsVcs.tokenFile.trim() !== "" ? wsVcs.tokenFile : null;
-  const tokenFile = String(wsTokenFile ?? prov.tokenFile ?? path10.join(configDir(), `${provider}.token`));
-  const tokenPath = path10.resolve(tokenFile);
-  let tokenOk = false;
-  if (fs7.existsSync(tokenPath)) {
-    const token = fs7.readFileSync(tokenPath, "utf8").trim();
-    const placeholder = !token || token === TOKEN_PLACEHOLDER || token.startsWith(TOKEN_PLACEHOLDER);
-    tokenOk = !placeholder;
+  readMessage() {
+    if (!this._buffer) {
+      return null;
+    }
+    const index = this._buffer.indexOf(`
+`);
+    if (index === -1) {
+      return null;
+    }
+    const line = this._buffer.toString("utf8", 0, index).replace(/\r$/, "");
+    this._buffer = this._buffer.subarray(index + 1);
+    return deserializeMessage(line);
   }
-  const out = {
-    ok: true,
-    configPath: path10.resolve(cfgPath),
-    provider,
-    defaultTargetBranch: defaultTarget,
-    pr: cfg.pr ?? {},
-    tokenPath,
-    tokenPresent: fs7.existsSync(tokenPath),
-    tokenReady: tokenOk,
-    workspace_name: ws?.name ?? null,
-    link_issues: linkIssues,
-    youtrack_base_url: youtrackBaseUrl,
-    issues_provider: issuesProvider,
-    link_on_pr: linkOnPr
-  };
-  if (provider === "gitlab") {
-    out.gitlab = {
-      host: prov.host ?? "gitlab.com",
-      apiUrl: prov.apiUrl ?? "https://gitlab.com/api/v4"
-    };
-  } else if (provider === "github") {
-    out.github = { host: prov.host ?? "github.com" };
+  clear() {
+    this._buffer = undefined;
   }
-  if (mode === "summary")
-    delete out.tokenPath;
-  return out;
 }
-function mergedPrStyle(limit = 6, cwd) {
-  const cfg = vcsConfig("load", cwd);
-  if (!cfg.ok || !cfg.tokenReady)
-    return { ok: false, error: "vcs not configured" };
-  const provider = cfg.provider;
-  const token = fs7.readFileSync(cfg.tokenPath, "utf8").trim();
-  const examples = [];
-  const descInfo = (desc, caseInsensitiveNotes = false) => ({
-    hasNotesSection: caseInsensitiveNotes ? /##\s*notes/i.test(desc) : /##\s*Notes/.test(desc),
-    sections: desc.split(`
-`).filter((l) => l.startsWith("## ")).map((l) => l.trim()),
-    descriptionPreview: desc.slice(0, 600)
-  });
-  if (provider === "gitlab") {
-    const remote = 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`]);
+function deserializeMessage(line) {
+  return JSONRPCMessageSchema.parse(JSON.parse(line));
+}
+function serializeMessage(message) {
+  return JSON.stringify(message) + `
+`;
+}
+
+// node_modules/@modelcontextprotocol/sdk/dist/esm/server/stdio.js
+class StdioServerTransport {
+  constructor(_stdin = process3.stdin, _stdout = process3.stdout, options) {
+    this._stdin = _stdin;
+    this._stdout = _stdout;
+    this._started = false;
+    this._ondata = (chunk) => {
+      try {
+        this._readBuffer.append(chunk);
+        this.processReadBuffer();
+      } catch (error) {
+        this.onerror?.(error);
+        this.close().catch(() => {});
+      }
+    };
+    this._onerror = (error) => {
+      this.onerror?.(error);
+    };
+    this._readBuffer = new ReadBuffer({ maxBufferSize: options?.maxBufferSize });
+  }
+  async start() {
+    if (this._started) {
+      throw new Error("StdioServerTransport already started! If using Server class, note that connect() calls start() automatically.");
     }
-    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)
-      });
+    this._started = true;
+    this._stdin.on("data", this._ondata);
+    this._stdin.on("error", this._onerror);
+  }
+  processReadBuffer() {
+    while (true) {
+      try {
+        const message = this._readBuffer.readMessage();
+        if (message === null) {
+          break;
+        }
+        this.onmessage?.(message);
+      } catch (error) {
+        this.onerror?.(error);
+      }
     }
-  } 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) });
+  }
+  async close() {
+    this._stdin.off("data", this._ondata);
+    this._stdin.off("error", this._onerror);
+    const remainingDataListeners = this._stdin.listenerCount("data");
+    if (remainingDataListeners === 0) {
+      this._stdin.pause();
     }
+    this._readBuffer.clear();
+    this.onclose?.();
+  }
+  send(message) {
+    return new Promise((resolve) => {
+      const json = serializeMessage(message);
+      if (this._stdout.write(json)) {
+        resolve();
+      } else {
+        this._stdout.once("drain", resolve);
+      }
+    });
   }
-  return {
-    ok: true,
-    provider,
-    count: examples.length,
-    styleHints: [
-      "Prefer ## Summary bullets + ## Validation or ## Test plan only",
-      "Do not add ## Notes with branch names, commit counts, or diff stats",
-      "Do not paste commit log or diff stat into the body"
-    ],
-    examples
-  };
 }
 
-// packages/workit-core/src/core/branch.ts
-var resolveBranchPolicyFor = (workspaceRoot) => resolveBranchPolicy(readConfig(), resolveWorkspace(workspaceRoot));
+// packages/workit-mcp/src/server.ts
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+
+// packages/workit-core/src/core/logger.ts
+import os2 from "node:os";
+var REDACTED = "[REDACTED]";
+var SECRET_VALUE = /\b(?:Bearer|Basic|Digest|Token)\s+\S+/gi;
+var KEY_EQ_VALUE = /\b([A-Za-z0-9_-]*(?:token|secret|password|passwd|apikey|api[_-]?key|authorization|credential|bearer)[A-Za-z0-9_-]*)([:=]\s*).+/gi;
+var URL_QUERY = /(https?:\/\/[^?#\s]+)\?[^#\s]*/g;
+var SENSITIVE_WORDS = new Set([
+  "token",
+  "secret",
+  "password",
+  "passwd",
+  "authorization",
+  "credential",
+  "credentials",
+  "cookie",
+  "api",
+  "apikey",
+  "apitoken",
+  "accesstoken",
+  "clientsecret",
+  "refreshtoken",
+  "key",
+  "bearer",
+  "prompt",
+  "message",
+  "messages",
+  "content",
+  "body",
+  "args",
+  "argument",
+  "result",
+  "results",
+  "output",
+  "issue",
+  "description",
+  "summary",
+  "payload",
+  "script",
+  "command",
+  "text",
+  "query"
+]);
+var STACK_WORDS = new Set(["stack", "stacktrace", "trace"]);
+var escapeRegExp = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+var homePattern = new RegExp(`${escapeRegExp(os2.homedir())}(?=[/\\\\]|$)|\\$HOME(?=[/\\\\]|$)`, "g");
+var applyPatterns = (value) => {
+  let out = value;
+  out = out.replace(SECRET_VALUE, REDACTED);
+  out = out.replace(KEY_EQ_VALUE, "$1$2[REDACTED]");
+  out = out.replace(URL_QUERY, "$1?[REDACTED]");
+  out = out.replace(homePattern, "~");
+  if (process.platform === "win32")
+    out = out.replace(/\\/g, "/");
+  return out;
+};
+var redactSecrets = (value) => applyPatterns(value);
 
 // packages/workit-core/src/core/pr-create.ts
 import fs8 from "node:fs";