@harness-engineering/cli 4.0.0 → 4.0.1

package/dist/{chunk-363V6GPR.js → chunk-I3CGCZJF.js}

@@ -7,10 +7,10 @@ import {
 import {
   findConfigFile,
   loadConfig
-} from "./chunk-XFHZ7GCI.js";
+} from "./chunk-XAVMTAUT.js";
 import {
   init_dist
-} from "./chunk-KLPX55TI.js";
+} from "./chunk-MMLQPHZ5.js";
 import {
   Ok
 } from "./chunk-BDGTZRZ6.js";
@@ -50,18 +50,18 @@ async function handleCheckDocs(input) {
     const projectPath = sanitizePath(input.path);
     const scope = input.scope ?? "coverage";
     if (scope === "integrity") {
-      const { validateKnowledgeMap } = await import("./dist-IPVFYGY2.js");
+      const { validateKnowledgeMap } = await import("./dist-6D2F2J57.js");
       const result2 = await validateKnowledgeMap(projectPath);
       return resultToMcpResponse(result2);
     }
     if (scope === "all") {
-      const { checkDocCoverage: checkDocCoverage2, validateKnowledgeMap } = await import("./dist-IPVFYGY2.js");
+      const { checkDocCoverage: checkDocCoverage2, validateKnowledgeMap } = await import("./dist-6D2F2J57.js");
       const domain2 = input.domain ?? "src";
-      const { loadGraphStore: loadGraphStore2 } = await import("./graph-loader-HHXN5FLP.js");
+      const { loadGraphStore: loadGraphStore2 } = await import("./graph-loader-STFGYKZH.js");
       const store2 = await loadGraphStore2(projectPath);
       let graphCoverage2;
       if (store2) {
-        const { Assembler } = await import("./dist-OWHMNL4W.js");
+        const { Assembler } = await import("./dist-DWBTZXR5.js");
         const assembler = new Assembler(store2);
         const report = assembler.checkCoverage();
         graphCoverage2 = {
@@ -94,13 +94,13 @@ async function handleCheckDocs(input) {
       }
       return resultToMcpResponse(Ok({ coverage, integrity }));
     }
-    const { checkDocCoverage } = await import("./dist-IPVFYGY2.js");
+    const { checkDocCoverage } = await import("./dist-6D2F2J57.js");
     const domain = input.domain ?? "src";
-    const { loadGraphStore } = await import("./graph-loader-HHXN5FLP.js");
+    const { loadGraphStore } = await import("./graph-loader-STFGYKZH.js");
     const store = await loadGraphStore(projectPath);
     let graphCoverage;
     if (store) {
-      const { Assembler } = await import("./dist-OWHMNL4W.js");
+      const { Assembler } = await import("./dist-DWBTZXR5.js");
       const assembler = new Assembler(store);
       const report = assembler.checkCoverage();
       graphCoverage = {

package/dist/{chunk-MSBJ445U.js → chunk-JPVOI7GP.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-RC3OI5NK.js";
 import {
   resolveProjectConfig
-} from "./chunk-ZEYAOYJL.js";
+} from "./chunk-SEA2PFVI.js";
 import {
   sanitizePath
 } from "./chunk-W6Y7ZW3Y.js";
@@ -38,7 +38,7 @@ async function handleCheckDependencies(input) {
   const configResult = resolveProjectConfig(projectPath);
   if (!configResult.ok) return resultToMcpResponse(configResult);
   try {
-    const { validateDependencies, TypeScriptParser } = await import("./dist-IPVFYGY2.js");
+    const { validateDependencies, TypeScriptParser } = await import("./dist-6D2F2J57.js");
     const config = configResult.value;
     const rawLayers = Array.isArray(config.layers) ? config.layers : [];
     const layers = rawLayers.map((l) => ({
@@ -47,11 +47,11 @@ async function handleCheckDependencies(input) {
       allowedDependencies: l.allowedDependencies
     }));
     const parser = new TypeScriptParser();
-    const { loadGraphStore } = await import("./graph-loader-HHXN5FLP.js");
+    const { loadGraphStore } = await import("./graph-loader-STFGYKZH.js");
     const store = await loadGraphStore(projectPath);
     let graphDependencyData;
     if (store) {
-      const { GraphConstraintAdapter } = await import("./dist-OWHMNL4W.js");
+      const { GraphConstraintAdapter } = await import("./dist-DWBTZXR5.js");
       const adapter = new GraphConstraintAdapter(store);
       const graphData = adapter.computeDependencyGraph();
       graphDependencyData = {
@@ -69,7 +69,7 @@ async function handleCheckDependencies(input) {
     if (store) {
       const designTokenNodes = store.findNodes({ type: "design_token" });
       if (designTokenNodes.length > 0) {
-        const { DesignConstraintAdapter } = await import("./dist-OWHMNL4W.js");
+        const { DesignConstraintAdapter } = await import("./dist-DWBTZXR5.js");
         const designAdapter = new DesignConstraintAdapter(store);
         const fileNodes = store.findNodes({ type: "file" });
         for (const fileNode of fileNodes) {

package/dist/{chunk-6NCREWWM.js → chunk-M7F2PPN3.js}

@@ -27,7 +27,7 @@ var runSecurityScanDefinition = {
 };
 async function handleRunSecurityScan(input) {
   try {
-    const core = await import("./dist-IPVFYGY2.js");
+    const core = await import("./dist-6D2F2J57.js");
     const projectRoot = sanitizePath(input.path);
     let configData = {};
     try {
@@ -50,7 +50,7 @@ async function handleRunSecurityScan(input) {
     if (input.files && input.files.length > 0) {
       filesToScan = input.files.map((f) => path.resolve(projectRoot, f));
     } else {
-      const { globFiles } = await import("./glob-helper-GLZAURJC.js");
+      const { globFiles } = await import("./glob-helper-VR6UCZZB.js");
       filesToScan = await globFiles(projectRoot, securityConfig.exclude);
     }
     const result = await scanner.scanFiles(filesToScan);
@@ -114,7 +114,7 @@ var getSecurityTrendsDefinition = {
 };
 async function handleGetSecurityTrends(input) {
   try {
-    const core = await import("./dist-IPVFYGY2.js");
+    const core = await import("./dist-6D2F2J57.js");
     const projectRoot = sanitizePath(input.path);
     const manager = new core.SecurityTimelineManager(projectRoot);
     const trendOptions = {};

package/dist/{chunk-KLPX55TI.js → chunk-MMLQPHZ5.js}

@@ -31,7 +31,7 @@ import {
   resetParserCache,
   resolveFileToLayer,
   validateDependencies
-} from "./chunk-N55WOGN3.js";
+} from "./chunk-6YFHUIGT.js";
 import {
   AuthAuditEntrySchema,
   AuthTokenPublicSchema,
@@ -87,7 +87,7 @@ import {
   init_dist as init_dist2,
   queryTraceability,
   skipDirGlobs
-} from "./chunk-PP6ZRL5T.js";
+} from "./chunk-WZJR6SOI.js";
 import {
   ArchBaselineSchema,
   ArchConfigSchema,
@@ -5965,16 +5965,7 @@ function quoteYamlScalar(value) {
   const escaped = value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
   return `"${escaped}"`;
 }
-function parseShard(md) {
-  let data;
-  let content;
-  try {
-    const parsed = matter3(md);
-    data = parsed.data;
-    content = parsed.content;
-  } catch (err) {
-    return Err(new Error(`Shard frontmatter is not valid YAML: ${err.message}`));
-  }
+function parseShardFrontmatter(data) {
   const slug = data.slug;
   if (typeof slug !== "string" || slug.length === 0) {
     return Err(new Error("Shard frontmatter missing required field: slug"));
@@ -5990,6 +5981,21 @@ function parseShard(md) {
       new Error(`Shard "${slug}" has invalid order: "${String(rawOrder)}" (must be a number)`)
     );
   }
+  return Ok({ slug, milestone, order });
+}
+function parseShard(md) {
+  let data;
+  let content;
+  try {
+    const parsed = matter3(md);
+    data = parsed.data;
+    content = parsed.content;
+  } catch (err) {
+    return Err(new Error(`Shard frontmatter is not valid YAML: ${err.message}`));
+  }
+  const frontmatterResult = parseShardFrontmatter(data);
+  if (!frontmatterResult.ok) return frontmatterResult;
+  const { slug, milestone, order } = frontmatterResult.value;
   const nameMatch = content.match(H3_NAME);
   if (!nameMatch) {
     return Err(new Error(`Shard "${slug}" is missing its "### <name>" heading`));
@@ -6011,6 +6017,17 @@ function serializeShard(shard) {
   return [...frontmatter, ...serializeFeature(shard.feature)].join("\n") + "\n";
 }
 function parseMeta(md) {
+  const block = parseFrontmatterBlock(md);
+  if (!block.ok) return Err(block.error);
+  const { data, body } = block.value;
+  const frontmatter = buildFrontmatter(data);
+  if (!frontmatter.ok) return Err(frontmatter.error);
+  const milestones = parseMilestones2(data);
+  if (!milestones.ok) return Err(milestones.error);
+  const meta = { frontmatter: frontmatter.value, milestones: milestones.value };
+  return attachAssignmentHistory(meta, body);
+}
+function parseFrontmatterBlock(md) {
   const match = md.match(FRONTMATTER);
   if (!match) {
     return Err(new Error("_meta.md is missing or has malformed YAML frontmatter"));
@@ -6022,6 +6039,9 @@ function parseMeta(md) {
   } catch (err) {
     return Err(new Error(`_meta.md frontmatter is not valid YAML: ${err.message}`));
   }
+  return Ok({ data, body: match[2] ?? "" });
+}
+function buildFrontmatter(data) {
   const project = data.project;
   const rawVersion = data.version;
   const lastSynced = data.last_synced;
@@ -6040,12 +6060,16 @@ function parseMeta(md) {
   const frontmatter = { project, version, lastSynced, lastManualEdit };
   if (typeof data.created === "string") frontmatter.created = data.created;
   if (typeof data.updated === "string") frontmatter.updated = data.updated;
+  return Ok(frontmatter);
+}
+function parseMilestones2(data) {
   const rawMilestones = data.milestones;
   if (!Array.isArray(rawMilestones) || !rawMilestones.every((m) => typeof m === "string")) {
     return Err(new Error("_meta.md frontmatter `milestones` must be a list of strings"));
   }
-  const meta = { frontmatter, milestones: rawMilestones };
-  const body = match[2] ?? "";
+  return Ok(rawMilestones);
+}
+function attachAssignmentHistory(meta, body) {
   if (body.includes("## Assignment History")) {
     const history = parseAssignmentHistory(body);
     if (!history.ok) return Err(history.error);
@@ -6078,43 +6102,49 @@ function isRegression(from, to) {
   return STATUS_RANK[to] < STATUS_RANK[from];
 }
 function assembleRoadmap(shards, meta) {
+  const byMilestone = groupShardsByMilestone(shards);
+  const ordered = orderMilestoneNames(meta, byMilestone);
+  const milestones = ordered.map((name) => buildMilestone(name, byMilestone));
+  return {
+    frontmatter: meta.frontmatter,
+    milestones,
+    assignmentHistory: meta.assignmentHistory ?? []
+  };
+}
+function groupShardsByMilestone(shards) {
   const byMilestone = /* @__PURE__ */ new Map();
   for (const shard of shards) {
     const bucket = byMilestone.get(shard.milestone);
     if (bucket) bucket.push(shard);
     else byMilestone.set(shard.milestone, [shard]);
   }
+  return byMilestone;
+}
+function orderMilestoneNames(meta, byMilestone) {
   const ordered = [];
   const seen = /* @__PURE__ */ new Set();
-  for (const name of meta.milestones) {
+  const append = (name) => {
     if (!seen.has(name)) {
       ordered.push(name);
       seen.add(name);
     }
-  }
-  for (const name of byMilestone.keys()) {
-    if (!seen.has(name)) {
-      ordered.push(name);
-      seen.add(name);
-    }
-  }
-  const milestones = ordered.map((name) => {
-    const bucket = [...byMilestone.get(name) ?? []];
-    bucket.sort(
-      (a, b) => a.order - b.order || STATUS_RANK[b.feature.status] - STATUS_RANK[a.feature.status] || // Deterministic code-unit comparison (NOT localeCompare, whose ICU/locale
-      // collation is environment-dependent and threatens byte-stable regen).
-      (a.slug < b.slug ? -1 : a.slug > b.slug ? 1 : 0)
-    );
-    return {
-      name,
-      isBacklog: name === "Backlog",
-      features: bucket.map((s) => s.feature)
-    };
-  });
+  };
+  for (const name of meta.milestones) append(name);
+  for (const name of byMilestone.keys()) append(name);
+  return ordered;
+}
+function compareShards(a, b) {
+  return a.order - b.order || STATUS_RANK[b.feature.status] - STATUS_RANK[a.feature.status] || // Deterministic code-unit comparison (NOT localeCompare, whose ICU/locale
+  // collation is environment-dependent and threatens byte-stable regen).
+  (a.slug < b.slug ? -1 : a.slug > b.slug ? 1 : 0);
+}
+function buildMilestone(name, byMilestone) {
+  const bucket = [...byMilestone.get(name) ?? []];
+  bucket.sort(compareShards);
   return {
-    frontmatter: meta.frontmatter,
-    milestones,
-    assignmentHistory: meta.assignmentHistory ?? []
+    name,
+    isBacklog: name === "Backlog",
+    features: bucket.map((s) => s.feature)
   };
 }
 function joinPath(dir, name) {
@@ -13270,6 +13300,21 @@ function linearFromPriority(p) {
       return 0;
   }
 }
+function metaDerivedFields(meta, issue) {
+  return {
+    spec: meta.spec ?? null,
+    plans: meta.plan ? [meta.plan] : [],
+    blockedBy: meta.blocked_by ?? [],
+    assignee: assigneeDisplayName(issue.assignee),
+    priority: meta.priority ?? priorityFromLinear(issue.priority),
+    milestone: meta.milestone ?? null,
+    createdAt: issue.createdAt ?? (/* @__PURE__ */ new Date(0)).toISOString(),
+    updatedAt: issue.updatedAt ?? null
+  };
+}
+function assigneeDisplayName(assignee) {
+  return assignee?.displayName ?? assignee?.name ?? null;
+}
 function metaFrom(feature) {
   const meta = {};
   if (feature.spec != null) meta.spec = feature.spec;
@@ -13279,6 +13324,25 @@ function metaFrom(feature) {
   if (feature.milestone != null) meta.milestone = feature.milestone;
   return meta;
 }
+function collectHistoryEvents(nodes) {
+  const events = [];
+  for (const c of nodes ?? []) {
+    const parsed = parseHistoryComment(c.body);
+    if (parsed) events.push(parsed);
+  }
+  return events;
+}
+function parseHistoryComment(body) {
+  if (!body || !body.includes(HISTORY_MARKER)) return null;
+  const m = /```json\s*([\s\S]*?)\s*```/.exec(body);
+  if (!m?.[1]) return null;
+  try {
+    const parsed = JSON.parse(m[1]);
+    if (parsed && typeof parsed.type === "string") return parsed;
+  } catch {
+  }
+  return null;
+}
 function createTrackerClient(config) {
   if (config.kind === "github-issues") {
     const token = config.token ?? process.env.GITHUB_TOKEN;
@@ -13725,6 +13789,50 @@ function checkRoadmapHealth(roadmap, options) {
   }
   return findings;
 }
+function demoteUnactionablePlanned(feature, milestoneName, changes) {
+  if (!isUnactionablePlanned(feature)) return;
+  feature.status = "backlog";
+  changes.push({
+    kind: "demoted",
+    feature: feature.name,
+    from: milestoneName,
+    to: "backlog"
+  });
+}
+function restoreAssigneeInvariant(feature, milestoneName, changes) {
+  if (feature.status !== "in-progress" && feature.assignee !== null) {
+    changes.push({
+      kind: "unassigned",
+      feature: feature.name,
+      from: milestoneName,
+      to: feature.assignee
+    });
+    feature.assignee = null;
+  } else if (feature.status === "in-progress" && feature.assignee === null) {
+    feature.status = "planned";
+    changes.push({
+      kind: "demoted",
+      feature: feature.name,
+      from: milestoneName,
+      to: "planned"
+    });
+  }
+}
+function groomFeature(feature, milestoneName, context, archived, changes) {
+  demoteUnactionablePlanned(feature, milestoneName, changes);
+  restoreAssigneeInvariant(feature, milestoneName, changes);
+  if (context.archiveDone && feature.status === "done" && !context.archive && !context.isIntake) {
+    archived.push(feature);
+    changes.push({
+      kind: "archived",
+      feature: feature.name,
+      from: milestoneName,
+      to: "Shipped"
+    });
+    return false;
+  }
+  return true;
+}
 function groomRoadmap(roadmap, options) {
   const opts = resolveOptions(options);
   const archiveDone = options?.archiveDone ?? true;
@@ -13732,49 +13840,14 @@ function groomRoadmap(roadmap, options) {
   const archived = [];
   const changes = [];
   for (const milestone of next.milestones) {
-    const archive = opts.isArchive(milestone.name);
-    const isIntake = milestone.name === opts.intakeMilestone;
-    const kept = [];
-    for (const feature of milestone.features) {
-      if (isUnactionablePlanned(feature)) {
-        feature.status = "backlog";
-        changes.push({
-          kind: "demoted",
-          feature: feature.name,
-          from: milestone.name,
-          to: "backlog"
-        });
-      }
-      if (feature.status !== "in-progress" && feature.assignee !== null) {
-        changes.push({
-          kind: "unassigned",
-          feature: feature.name,
-          from: milestone.name,
-          to: feature.assignee
-        });
-        feature.assignee = null;
-      } else if (feature.status === "in-progress" && feature.assignee === null) {
-        feature.status = "planned";
-        changes.push({
-          kind: "demoted",
-          feature: feature.name,
-          from: milestone.name,
-          to: "planned"
-        });
-      }
-      if (archiveDone && feature.status === "done" && !archive && !isIntake) {
-        archived.push(feature);
-        changes.push({
-          kind: "archived",
-          feature: feature.name,
-          from: milestone.name,
-          to: "Shipped"
-        });
-        continue;
-      }
-      kept.push(feature);
-    }
-    milestone.features = kept;
+    const context = {
+      archiveDone,
+      archive: opts.isArchive(milestone.name),
+      isIntake: milestone.name === opts.intakeMilestone
+    };
+    milestone.features = milestone.features.filter(
+      (feature) => groomFeature(feature, milestone.name, context, archived, changes)
+    );
   }
   next.milestones = next.milestones.filter(
     (m) => m.features.length > 0 || m.name === opts.intakeMilestone
@@ -15060,7 +15133,7 @@ function arrayLen(arr) {
   return Array.isArray(arr) ? arr.length : 0;
 }
 async function gatherEntropyBlock(projectPath) {
-  const { EntropyAnalyzer: EntropyAnalyzer2 } = await import("./analyzer-V633GUHY-MBCQWKDU.js");
+  const { EntropyAnalyzer: EntropyAnalyzer2 } = await import("./analyzer-V633GUHY-OV335HGM.js");
   const analyzer = new EntropyAnalyzer2({
     rootDir: projectPath,
     include: ["src/**/*.ts", "src/**/*.tsx", "packages/*/src/**/*.ts"],
@@ -21823,14 +21896,7 @@ ${JSON.stringify(event)}`;
           name: issue.title,
           status: statusFromStateType(issue.state?.type),
           summary,
-          spec: meta.spec ?? null,
-          plans: meta.plan ? [meta.plan] : [],
-          blockedBy: meta.blocked_by ?? [],
-          assignee: issue.assignee?.displayName ?? issue.assignee?.name ?? null,
-          priority: meta.priority ?? priorityFromLinear(issue.priority),
-          milestone: meta.milestone ?? null,
-          createdAt: issue.createdAt ?? (/* @__PURE__ */ new Date(0)).toISOString(),
-          updatedAt: issue.updatedAt ?? null
+          ...metaDerivedFields(meta, issue)
         };
       }
       /** Resolve (and cache) the team's first state id of each workflow type. */
@@ -21858,6 +21924,12 @@ ${JSON.stringify(event)}`;
         if (!r.ok) return r;
         return Ok(r.value.users?.nodes?.[0]?.id ?? null);
       }
+      /** Resolve an assignee to a Linear user id, or null when absent/unresolved. */
+      async assigneeIdFor(assignee) {
+        if (!assignee) return null;
+        const userR = await this.resolveUserId(assignee);
+        return userR.ok && userR.value ? userR.value : null;
+      }
       // ── Reads ──────────────────────────────────────────────────────────────
       async fetchAll() {
         const r = await this.gql(
@@ -21888,18 +21960,9 @@ ${JSON.stringify(event)}`;
       async create(feature) {
         const stateR = await this.resolveStateId(feature.status ?? "backlog");
         if (!stateR.ok) return stateR;
-        const body = serializeBodyBlock(feature.summary ?? "", metaFrom(feature));
-        const input = {
-          teamId: this.teamId,
-          title: feature.name,
-          description: body,
-          stateId: stateR.value,
-          priority: linearFromPriority(feature.priority)
-        };
-        if (feature.assignee) {
-          const userR = await this.resolveUserId(feature.assignee);
-          if (userR.ok && userR.value) input.assigneeId = userR.value;
-        }
+        const input = this.buildCreateInput(feature, stateR.value);
+        const assigneeId = await this.assigneeIdFor(feature.assignee);
+        if (assigneeId) input.assigneeId = assigneeId;
         const r = await this.gql(
           `mutation($input:IssueCreateInput!){ issueCreate(input:$input){ issue { ${ISSUE_FIELDS} } } }`,
           { input }
@@ -21909,6 +21972,16 @@ ${JSON.stringify(event)}`;
         if (!issue) return Err(new Error("Linear issueCreate returned no issue"));
         return Ok(this.featureFromIssue(issue));
       }
+      /** Assemble the IssueCreateInput payload for a new feature (sans assignee, which is resolved async). */
+      buildCreateInput(feature, stateId) {
+        return {
+          teamId: this.teamId,
+          title: feature.name,
+          description: serializeBodyBlock(feature.summary ?? "", metaFrom(feature)),
+          stateId,
+          priority: linearFromPriority(feature.priority)
+        };
+      }
       /** Shared issueUpdate with optional optimistic-concurrency check on updatedAt. */
       async issueUpdate(externalId, input, ifMatch) {
         const id = this.toIssueId(externalId);
@@ -21935,6 +22008,26 @@ ${JSON.stringify(event)}`;
         if (!issue) return Err(new Error("Linear issueUpdate returned no issue"));
         return Ok(this.featureFromIssue(issue));
       }
+      /**
+       * Merge body-backed patch fields into the current issue's harness-meta block,
+       * returning the serialized description (so the meta block isn't clobbered).
+       */
+      async mergedDescription(externalId, patch) {
+        const cur = await this.fetchById(externalId);
+        if (!cur.ok) return cur;
+        if (!cur.value) return Err(new Error(`Linear issue not found: ${externalId}`));
+        const f = cur.value.feature;
+        const merged = {
+          name: patch.name ?? f.name,
+          summary: patch.summary ?? f.summary,
+          spec: patch.spec !== void 0 ? patch.spec : f.spec,
+          plans: patch.plans !== void 0 ? patch.plans : f.plans,
+          blockedBy: patch.blockedBy !== void 0 ? patch.blockedBy : f.blockedBy,
+          priority: patch.priority !== void 0 ? patch.priority : f.priority,
+          milestone: patch.milestone !== void 0 ? patch.milestone : f.milestone
+        };
+        return Ok(serializeBodyBlock(merged.summary ?? "", metaFrom(merged)));
+      }
       async update(externalId, patch, ifMatch) {
         const input = {};
         if (patch.name !== void 0) input.title = patch.name;
@@ -21953,31 +22046,23 @@ ${JSON.stringify(event)}`;
           "milestone"
         ];
         if (bodyFields.some((k) => patch[k] !== void 0)) {
-          const cur = await this.fetchById(externalId);
-          if (!cur.ok) return cur;
-          if (!cur.value) return Err(new Error(`Linear issue not found: ${externalId}`));
-          const f = cur.value.feature;
-          const merged = {
-            name: patch.name ?? f.name,
-            summary: patch.summary ?? f.summary,
-            spec: patch.spec !== void 0 ? patch.spec : f.spec,
-            plans: patch.plans !== void 0 ? patch.plans : f.plans,
-            blockedBy: patch.blockedBy !== void 0 ? patch.blockedBy : f.blockedBy,
-            priority: patch.priority !== void 0 ? patch.priority : f.priority,
-            milestone: patch.milestone !== void 0 ? patch.milestone : f.milestone
-          };
-          input.description = serializeBodyBlock(merged.summary ?? "", metaFrom(merged));
-        }
-        if (patch.assignee !== void 0) {
-          if (patch.assignee === null) {
-            input.assigneeId = null;
-          } else {
-            const userR = await this.resolveUserId(patch.assignee);
-            if (userR.ok && userR.value) input.assigneeId = userR.value;
-          }
+          const descR = await this.mergedDescription(externalId, patch);
+          if (!descR.ok) return descR;
+          input.description = descR.value;
         }
+        await this.applyAssigneeUpdate(patch, input);
         return this.issueUpdate(externalId, input, ifMatch);
       }
+      /** Resolve `patch.assignee` (name → user id, or explicit null to unassign) into the update input. */
+      async applyAssigneeUpdate(patch, input) {
+        if (patch.assignee === void 0) return;
+        if (patch.assignee === null) {
+          input.assigneeId = null;
+          return;
+        }
+        const userR = await this.resolveUserId(patch.assignee);
+        if (userR.ok && userR.value) input.assigneeId = userR.value;
+      }
       async claim(externalId, assignee, ifMatch) {
         const userR = await this.resolveUserId(assignee);
         if (!userR.ok) return userR;
@@ -22017,17 +22102,7 @@ ${JSON.stringify(event)}
           { id: this.toIssueId(externalId) }
         );
         if (!r.ok) return r;
-        const events = [];
-        for (const c of r.value.issue?.comments?.nodes ?? []) {
-          if (!c.body || !c.body.includes(HISTORY_MARKER)) continue;
-          const m = /```json\s*([\s\S]*?)\s*```/.exec(c.body);
-          if (!m?.[1]) continue;
-          try {
-            const parsed = JSON.parse(m[1]);
-            if (parsed && typeof parsed.type === "string") events.push(parsed);
-          } catch {
-          }
-        }
+        const events = collectHistoryEvents(r.value.issue?.comments?.nodes);
         return Ok(typeof limit === "number" ? events.slice(0, limit) : events);
       }
     };