@staff0rd/assist 0.576.0 → 0.578.0

package/dist/index.js

@@ -6,7 +6,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "@staff0rd/assist",
-  version: "0.576.0",
+  version: "0.578.0",
   type: "module",
   main: "dist/index.js",
   bin: {
@@ -14914,12 +14914,12 @@ async function link(fromId, toId, opts) {
   const { orm } = await getReady();
   const fromItem = await loadItem(orm, fromNum);
   if (!fromItem) return void fail4(`Item ${from} not found.`);
-  const toItem = await loadItem(orm, toNum);
-  if (!toItem) return void fail4(`Item ${to} not found.`);
+  const toItem2 = await loadItem(orm, toNum);
+  if (!toItem2) return void fail4(`Item ${to} not found.`);
   if (!validateLinkTarget(fromItem, fromNum, toNum, linkType)) return;
   if (await createsCycle(orm, linkType, fromNum, toNum)) return;
   await orm.insert(links).values({ itemId: fromNum, type: linkType, targetId: toNum });
-  console.log(chalk85.green(`Linked ${from} ${linkType} ${to} (${toItem.name})`));
+  console.log(chalk85.green(`Linked ${from} ${linkType} ${to} (${toItem2.name})`));
 }
 
 // src/commands/backlog/unlink.ts
@@ -16820,6 +16820,12 @@ function findBuiltinDenyRaw(rawCommand) {
 // src/shared/isApprovedRead.ts
 import { resolve as resolve13, sep } from "path";
 
+// src/shared/appliesFixStructure.ts
+var APPLY_RE = /^assist\s+github\s+issue\s+fix-structure\b.*\s--apply\b/;
+function appliesFixStructure(command) {
+  return APPLY_RE.test(command);
+}
+
 // src/shared/tokenize.ts
 function tokenize(command) {
   const tokens = [];
@@ -17046,6 +17052,7 @@ function isApprovedRead(command, toolName = "Bash") {
   if (isCdToCwd(command)) return "cd to current directory";
   const cdRead = isCdToReadAllowedDir(command);
   if (cdRead) return cdRead;
+  if (appliesFixStructure(command)) return void 0;
   const matchedRead = findCliRead(command);
   if (matchedRead) return `Read-only CLI command: ${matchedRead}`;
   const matchedWrite = findCliWrite(command);
@@ -20695,309 +20702,178 @@ function parseTopCount(value) {
   return Number.parseInt(value, 10);
 }
 
-// src/commands/github/issue/commentIssue.ts
-import { execFileSync as execFileSync6 } from "child_process";
+// src/commands/github/issue/fixStructure/applyAndVerifySubtree.ts
+import chalk163 from "chalk";
 
-// src/shared/validateProposedContent.ts
-function validateProposedContent(labels, title, body) {
-  const { subject, context } = labels;
-  if (title.toLowerCase().includes("claude")) {
-    console.error(`Error: ${subject} title must not reference Claude`);
-    process.exit(1);
-  }
-  if (body.toLowerCase().includes("claude")) {
-    console.error(`Error: ${subject} body must not reference Claude`);
-    process.exit(1);
-  }
-  const titleBacklogIds = findBacklogRefs(title);
-  if (titleBacklogIds.length > 0) {
-    console.error(
-      backlogRefError(`${subject} title`, context, titleBacklogIds)
-    );
-    process.exit(1);
-  }
-  const bodyBacklogIds = findBacklogRefs(body);
-  if (bodyBacklogIds.length > 0) {
-    console.error(backlogRefError(`${subject} body`, context, bodyBacklogIds));
-    process.exit(1);
-  }
-}
+// src/commands/github/issue/fixStructure/applyFixStructurePlan.ts
+import chalk162 from "chalk";
 
-// src/commands/github/issue/reviewProposedIssueComment.ts
-import { randomUUID as randomUUID7 } from "crypto";
-async function reviewProposedIssueComment(title, body) {
-  const sessionId = process.env.ASSIST_SESSION_ID;
-  if (process.env.ASSIST_SESSION !== "1" || !sessionId) return;
-  await awaitPreviewApproval("GitHub issue comment preview", {
-    sessionId,
-    requestId: randomUUID7(),
-    title,
-    body,
-    prNumber: null,
-    kind: "github-issue-comment"
+// src/shared/runGhGraphqlJson.ts
+import { spawnSync as spawnSync5 } from "child_process";
+function runGhGraphqlJson(query, vars = {}) {
+  const result = spawnSync5("gh", ["api", "graphql", "--input", "-"], {
+    encoding: "utf8",
+    windowsHide: true,
+    input: JSON.stringify({ query, variables: vars }),
+    maxBuffer: 64 * 1024 * 1024
   });
+  if (result.status !== 0) throw new Error(result.stderr || result.stdout);
+  throwOnGraphqlErrors(result.stdout);
+  return result.stdout;
 }
 
-// src/commands/github/issue/commentIssue.ts
-var USAGE = "Usage: assist github issue comment <number> --body <body> [-R <owner>/<repo>]";
-async function commentIssue(numberArg, options2) {
-  const number = Number.parseInt(numberArg, 10);
-  if (!Number.isInteger(number) || number <= 0 || !options2.body) {
-    console.error(USAGE);
-    process.exit(1);
-  }
-  const { body } = options2;
-  const target = options2.repo ? `${options2.repo}#${number}` : `issue #${number}`;
-  validateProposedContent(
-    { subject: "Comment", context: "GitHub issues" },
-    "",
-    body
-  );
-  await reviewProposedIssueComment(`Comment on ${target}`, body);
-  const args = ["issue", "comment", String(number), "--body", body];
-  if (options2.repo) args.push("--repo", options2.repo);
-  try {
-    execFileSync6("gh", args, { stdio: "inherit" });
-  } catch {
-    process.exit(1);
-  }
-  console.log(`Comment posted to ${target}`);
+// src/commands/github/issue/fixStructure/removeIssueLabels.ts
+var MUTATION = `mutation($labelableId: ID!, $labelIds: [ID!]!) {
+	removeLabelsFromLabelable(input: { labelableId: $labelableId, labelIds: $labelIds }) {
+		labelable { __typename }
+	}
+}`;
+function removeIssueLabels(issueId, labelIds) {
+  runGhGraphqlJson(MUTATION, { labelableId: issueId, labelIds });
 }
 
-// src/commands/github/issue/createIssue.ts
-import { execFileSync as execFileSync7 } from "child_process";
-
-// src/commands/github/issue/reviewProposedIssue.ts
-import { randomUUID as randomUUID8 } from "crypto";
-async function reviewProposedIssue(title, body) {
-  const sessionId = process.env.ASSIST_SESSION_ID;
-  if (process.env.ASSIST_SESSION !== "1" || !sessionId) return;
-  await awaitPreviewApproval("GitHub issue preview", {
-    sessionId,
-    requestId: randomUUID8(),
-    title,
-    body,
-    prNumber: null,
-    kind: "github-issue"
-  });
+// src/commands/github/issue/fixStructure/updateIssueType.ts
+var MUTATION2 = `mutation($issueId: ID!, $issueTypeId: ID!) {
+	updateIssueIssueType(input: { issueId: $issueId, issueTypeId: $issueTypeId }) {
+		issue { id }
+	}
+}`;
+function updateIssueType(issueId, issueTypeId) {
+  runGhGraphqlJson(MUTATION2, { issueId, issueTypeId });
 }
 
-// src/commands/github/issue/createIssue.ts
-var USAGE2 = "Usage: assist github issue create --title <title> --body <body> [-R <owner>/<repo>]";
-async function createIssue(options2) {
-  if (!options2.title || !options2.body) {
-    console.error(USAGE2);
-    process.exit(1);
-  }
-  const { title, body } = options2;
-  validateProposedContent(
-    { subject: "Issue", context: "GitHub issues" },
-    title,
-    body
-  );
-  await reviewProposedIssue(title, body);
-  const args = ["issue", "create", "--title", title, "--body", body];
-  if (options2.repo) args.push("--repo", options2.repo);
+// src/commands/github/issue/fixStructure/writeLineNow.ts
+import { writeSync as writeSync2 } from "fs";
+function writeLineNow(line) {
+  const text18 = `${line}
+`;
   try {
-    execFileSync7("gh", args, { stdio: "inherit" });
+    writeSync2(1, text18);
   } catch {
-    process.exit(1);
+    process.stdout.write(text18);
   }
 }
 
-// src/commands/sessions/shared/inWebSession.ts
-function inWebSession() {
-  return process.env.ASSIST_SESSION === "1" && !!process.env.ASSIST_SESSION_ID;
-}
-
-// src/commands/github/issue/fetchIssue.ts
-import { execFileSync as execFileSync8 } from "child_process";
-function fetchIssue2(number, repo) {
-  const args = [
-    "issue",
-    "view",
-    String(number),
-    "--json",
-    "title,body,updatedAt,url"
-  ];
-  if (repo) args.push("--repo", repo);
-  let raw;
-  try {
-    raw = execFileSync8("gh", args, { encoding: "utf8" });
-  } catch {
-    console.error(`Could not fetch issue #${number} with gh issue view`);
-    process.exit(1);
-  }
-  try {
-    return JSON.parse(raw);
-  } catch {
-    console.error(`Could not parse the gh issue view output for #${number}`);
-    process.exit(1);
+// src/commands/github/issue/fixStructure/applyFixStructurePlan.ts
+function applyFixStructurePlan(plan2) {
+  for (const entry of plan2.entries) {
+    const where = chalk162.cyan(`${entry.issue.repo}#${entry.issue.number}`);
+    const { typeChange, labelRemovals } = entry;
+    if (typeChange) {
+      writeLineNow(
+        `${where} type ${typeChange.from ?? "no type"} -> ${typeChange.to}`
+      );
+      updateIssueType(entry.issue.id, typeChange.typeId);
+    }
+    if (labelRemovals.length > 0) {
+      writeLineNow(
+        `${where} removing ${labelRemovals.map((label2) => label2.name).join(", ")}`
+      );
+      removeIssueLabels(
+        entry.issue.id,
+        labelRemovals.map((label2) => label2.id)
+      );
+    }
   }
 }
 
-// src/commands/github/issue/resumeIssueBody.ts
-import { existsSync as existsSync48, readFileSync as readFileSync37 } from "fs";
-
-// src/commands/github/issue/issueWorkingFile.ts
-import { join as join50 } from "path";
-function issueWorkingFile(slug, number) {
-  const [owner = "unknown", repo = "unknown"] = slug.split("/");
-  const dir = join50(getStoreDir(), "github-issues", owner, repo);
-  return {
-    dir,
-    bodyPath: join50(dir, `${number}.md`),
-    metaPath: join50(dir, `${number}.json`)
-  };
-}
-
-// src/commands/github/issue/resumeIssueBody.ts
-function resumeIssueBody(slug, number, updatedAt) {
-  const { bodyPath, metaPath } = issueWorkingFile(slug, number);
-  if (!existsSync48(bodyPath) || !existsSync48(metaPath)) return void 0;
-  try {
-    const meta = JSON.parse(readFileSync37(metaPath, "utf8"));
-    if (meta.updatedAt !== updatedAt) return void 0;
-    return readFileSync37(bodyPath, "utf8");
-  } catch {
-    return void 0;
-  }
+// src/commands/github/issue/fixStructure/assertNothingTooDeep.ts
+function describe2(entry, leaf) {
+  const parent = entry.parent;
+  const under = parent ? ` under ${parent.repo}#${parent.number}` : "";
+  return `${entry.issue.repo}#${entry.issue.number}${under} sits below ${leaf}, the leaf level`;
 }
-
-// src/commands/github/issue/validateIssueBody.ts
-function validateIssueBody(title, body) {
-  validateProposedContent(
-    { subject: "Issue", context: "GitHub issues" },
-    title,
-    body
+function assertNothingTooDeep(tooDeep, chain2) {
+  if (tooDeep.length === 0) return;
+  const leaf = chain2[chain2.length - 1] ?? "the leaf";
+  throw new Error(
+    [
+      ...tooDeep.map((entry) => describe2(entry, leaf)),
+      "Re-parent those issues or aim the run at a deeper target"
+    ].join("\n")
   );
 }
 
-// src/commands/github/issue/writeIssueWorkingFile.ts
-import { mkdirSync as mkdirSync16, writeFileSync as writeFileSync31 } from "fs";
-function writeIssueWorkingFile(slug, number, target, updatedAt, body) {
-  const { dir, bodyPath, metaPath } = issueWorkingFile(slug, number);
-  mkdirSync16(dir, { recursive: true });
-  writeFileSync31(bodyPath, body);
-  writeFileSync31(
-    metaPath,
-    `${JSON.stringify({ target, updatedAt }, null, 2)}
-`
+// src/commands/github/issue/fixStructure/assertNoResidualDrift.ts
+function describe3(entry) {
+  const where = `${entry.issue.repo}#${entry.issue.number}`;
+  const notes = [];
+  if (entry.typeChange) {
+    notes.push(
+      `${where} is still ${entry.typeChange.from ?? "untyped"}, not ${entry.typeChange.to}`
+    );
+  }
+  for (const label2 of entry.labelRemovals) {
+    notes.push(`${where} still carries ${label2.name}`);
+  }
+  return notes;
+}
+function assertNoResidualDrift(plan2, chain2) {
+  assertNothingTooDeep(plan2.tooDeep, chain2);
+  const residual = plan2.entries.flatMap(describe3);
+  if (residual.length === 0) return;
+  throw new Error(
+    ["The subtree still drifts after applying:", ...residual].join("\n")
   );
-  return bodyPath;
 }
 
-// src/commands/github/issue/prepareIssueEdit.ts
-function slugFromUrl(url) {
-  const match = /github\.com\/([^/]+\/[^/]+)\//.exec(url ?? "");
-  return match ? match[1] : "unknown/unknown";
-}
-function prepareIssueEdit(number, repo, fresh) {
-  const issue = fetchIssue2(number, repo);
-  const slug = repo ?? slugFromUrl(issue.url);
-  const target = `${slug}#${number}`;
-  const resumed = fresh ? void 0 : resumeIssueBody(slug, number, issue.updatedAt);
-  const body = resumed ?? issue.body;
-  validateIssueBody(issue.title, body);
-  const save = (markdown) => writeIssueWorkingFile(slug, number, target, issue.updatedAt, markdown);
-  const bodyPath = save(body);
-  if (resumed !== void 0)
-    console.log(`Previewing the in-progress markdown from ${bodyPath}`);
-  return {
-    title: issue.title,
-    target,
-    updatedAt: issue.updatedAt,
-    body,
-    bodyPath,
-    save
-  };
-}
+// src/commands/github/issue/fixStructure/issueFieldsFragment.ts
+var issueFieldsFragment = `fragment issueFields on Issue {
+	id
+	number
+	title
+	issueType { name }
+	repository { nameWithOwner }
+	labels(first: 100) { nodes { id name } pageInfo { hasNextPage } }
+	subIssues(first: 100) { nodes { id } pageInfo { hasNextPage } }
+}`;
 
-// src/commands/github/issue/pushIssueBody.ts
-import { execFileSync as execFileSync9 } from "child_process";
-function pushIssueBody(number, repo, bodyPath) {
-  const args = ["issue", "edit", String(number), "--body-file", bodyPath];
-  if (repo) args.push("--repo", repo);
-  try {
-    execFileSync9("gh", args, { stdio: "inherit" });
-  } catch {
-    process.exit(1);
+// src/commands/github/issue/fixStructure/parseIssueNode.ts
+function parseIssueNode(node) {
+  const raw = node;
+  const repo = raw.repository?.nameWithOwner ?? "";
+  const where = `${repo}#${raw.number}`;
+  if (raw.labels?.pageInfo?.hasNextPage) {
+    throw new Error(
+      `${where} carries more than 100 labels, which is not supported`
+    );
   }
-}
-
-// src/commands/github/issue/pushUnchangedIssue.ts
-function pushUnchangedIssue(number, repo, target, fetchedAt, bodyPath) {
-  if (fetchIssue2(number, repo).updatedAt !== fetchedAt) {
-    console.error(
-      `${target} was updated on GitHub after it was fetched. Nothing was pushed; the markdown is at ${bodyPath}`
+  if (raw.subIssues?.pageInfo?.hasNextPage) {
+    throw new Error(
+      `${where} has more than 100 sub-issues, which is not supported`
     );
-    process.exit(1);
   }
-  pushIssueBody(number, repo, bodyPath);
-  console.log(`Issue body updated on ${target}`);
-}
-
-// src/commands/github/issue/reviewProposedIssueEdit.ts
-import { randomUUID as randomUUID9 } from "crypto";
-async function reviewProposedIssueEdit(title, body, working) {
-  const sessionId = process.env.ASSIST_SESSION_ID;
-  if (process.env.ASSIST_SESSION !== "1" || !sessionId) return body;
-  const decision = await awaitPreviewApproval(
-    "GitHub issue edit preview",
-    {
-      sessionId,
-      requestId: randomUUID9(),
-      title,
-      body,
-      prNumber: null,
-      kind: "github-issue-edit"
-    },
-    {
-      saveEditedBody: working.save,
-      rejectionAdvice: `Nothing was pushed. The pane's markdown, including any collapses already applied, is at ${working.path}. Revise that file in place \u2014 do not recompose the body from scratch \u2014 then re-run this command to preview the revision.`
-    }
-  );
-  return decision.body ?? body;
+  return {
+    id: raw.id,
+    number: raw.number,
+    title: raw.title,
+    repo,
+    typeName: raw.issueType?.name ?? null,
+    labels: (raw.labels?.nodes ?? []).filter((label2) => label2 !== null),
+    childIds: (raw.subIssues?.nodes ?? []).filter((child) => child !== null).map((child) => child.id)
+  };
 }
 
-// src/commands/github/issue/viewIssue.ts
-import { execFileSync as execFileSync10 } from "child_process";
-function viewIssue(number, repo) {
-  const args = ["issue", "view", String(number)];
-  if (repo) args.push("--repo", repo);
-  try {
-    execFileSync10("gh", args, { stdio: "inherit" });
-  } catch {
-    process.exit(1);
-  }
+// src/commands/github/issue/fixStructure/fetchRootIssue.ts
+var QUERY = `query($owner: String!, $repo: String!, $number: Int!) {
+	repository(owner: $owner, name: $repo) {
+		issue(number: $number) { ...issueFields }
+	}
 }
-
-// src/commands/github/issue/editIssue.ts
-var USAGE3 = "Usage: assist github issue edit <number> [-R <owner>/<repo>]";
-async function editIssue(numberArg, options2) {
-  const number = Number.parseInt(numberArg, 10);
-  if (!Number.isInteger(number) || number <= 0) {
-    console.error(USAGE3);
-    process.exit(1);
-  }
-  if (!inWebSession()) {
-    viewIssue(number, options2.repo);
-    return;
+${issueFieldsFragment}`;
+function fetchRootIssue(target) {
+  const raw = runGhGraphqlJson(QUERY, {
+    owner: target.owner,
+    repo: target.repo,
+    number: target.number
+  });
+  const issue = JSON.parse(raw).data?.repository?.issue;
+  if (!issue) {
+    throw new Error(
+      `No issue ${target.owner}/${target.repo}#${target.number} could be read`
+    );
   }
-  const issue = prepareIssueEdit(number, options2.repo, options2.fresh);
-  const edited = await reviewProposedIssueEdit(
-    `Edit ${issue.target}: ${issue.title}`,
-    issue.body,
-    { path: issue.bodyPath, save: issue.save }
-  );
-  validateIssueBody(issue.title, edited);
-  pushUnchangedIssue(
-    number,
-    options2.repo,
-    issue.target,
-    issue.updatedAt,
-    issue.bodyPath
-  );
+  return parseIssueNode(issue);
 }
 
 // src/commands/github/issue/fixStructure/matchedLabels.ts
@@ -21095,127 +20971,110 @@ function buildFixStructurePlan(issues, options2) {
   };
 }
 
-// src/shared/runGhGraphqlJson.ts
-import { spawnSync as spawnSync5 } from "child_process";
-function runGhGraphqlJson(query, vars = {}) {
-  const result = spawnSync5("gh", ["api", "graphql", "--input", "-"], {
-    encoding: "utf8",
-    windowsHide: true,
-    input: JSON.stringify({ query, variables: vars }),
-    maxBuffer: 64 * 1024 * 1024
-  });
-  if (result.status !== 0) throw new Error(result.stderr || result.stdout);
-  throwOnGraphqlErrors(result.stdout);
-  return result.stdout;
+// src/commands/github/issue/fixStructure/fetchSubtreeIssues.ts
+var QUERY2 = `query($ids: [ID!]!) {
+	nodes(ids: $ids) { ... on Issue { ...issueFields } }
 }
-
-// src/commands/github/issue/fixStructure/issueFieldsFragment.ts
-var issueFieldsFragment = `fragment issueFields on Issue {
-	id
-	number
-	title
-	issueType { name }
-	repository { nameWithOwner }
-	labels(first: 100) { nodes { id name } pageInfo { hasNextPage } }
-	subIssues(first: 100) { nodes { id } pageInfo { hasNextPage } }
-}`;
-
-// src/commands/github/issue/fixStructure/parseIssueNode.ts
-function parseIssueNode(node) {
-  const raw = node;
-  const repo = raw.repository?.nameWithOwner ?? "";
-  const where = `${repo}#${raw.number}`;
-  if (raw.labels?.pageInfo?.hasNextPage) {
-    throw new Error(
-      `${where} carries more than 100 labels, which is not supported`
-    );
+${issueFieldsFragment}`;
+var BATCH = 50;
+function fetchSubtreeIssues(ids) {
+  const issues = [];
+  for (let start3 = 0; start3 < ids.length; start3 += BATCH) {
+    const raw = runGhGraphqlJson(QUERY2, {
+      ids: ids.slice(start3, start3 + BATCH)
+    });
+    const nodes = JSON.parse(raw).data?.nodes ?? [];
+    for (const node of nodes) {
+      if (node) issues.push(parseIssueNode(node));
+    }
   }
-  if (raw.subIssues?.pageInfo?.hasNextPage) {
-    throw new Error(
-      `${where} has more than 100 sub-issues, which is not supported`
-    );
+  return issues;
+}
+
+// src/commands/github/issue/fixStructure/walkSubtree.ts
+function walkSubtree(root, maxDepth, fetchIssues = fetchSubtreeIssues) {
+  const placed = [{ ...root, depth: 0, parentId: null }];
+  const seen = /* @__PURE__ */ new Set([root.id]);
+  let frontier = placed;
+  for (let depth = 1; depth <= maxDepth && frontier.length > 0; depth += 1) {
+    const parentOf2 = /* @__PURE__ */ new Map();
+    for (const parent of frontier) {
+      for (const childId of parent.childIds) {
+        if (seen.has(childId)) continue;
+        seen.add(childId);
+        parentOf2.set(childId, parent.id);
+      }
+    }
+    if (parentOf2.size === 0) break;
+    const children = fetchIssues([...parentOf2.keys()]).map((issue) => ({
+      ...issue,
+      depth,
+      parentId: parentOf2.get(issue.id) ?? null
+    }));
+    placed.push(...children);
+    frontier = children;
   }
-  return {
-    id: raw.id,
-    number: raw.number,
-    title: raw.title,
-    repo,
-    typeName: raw.issueType?.name ?? null,
-    labels: (raw.labels?.nodes ?? []).filter((label2) => label2 !== null),
-    childIds: (raw.subIssues?.nodes ?? []).filter((child) => child !== null).map((child) => child.id)
-  };
+  return placed;
 }
 
-// src/commands/github/issue/fixStructure/fetchRootIssue.ts
-var QUERY = `query($owner: String!, $repo: String!, $number: Int!) {
-	repository(owner: $owner, name: $repo) {
-		issue(number: $number) { ...issueFields }
-	}
+// src/commands/github/issue/fixStructure/planSubtree.ts
+function planSubtree(root, context) {
+  const depth = context.chain.length - context.rootLevelIndex;
+  return buildFixStructurePlan(walkSubtree(root, depth), context);
 }
-${issueFieldsFragment}`;
-function fetchRootIssue(target) {
-  const raw = runGhGraphqlJson(QUERY, {
-    owner: target.owner,
-    repo: target.repo,
-    number: target.number
-  });
-  const issue = JSON.parse(raw).data?.repository?.issue;
-  if (!issue) {
-    throw new Error(
-      `No issue ${target.owner}/${target.repo}#${target.number} could be read`
-    );
-  }
-  return parseIssueNode(issue);
+
+// src/commands/github/issue/fixStructure/applyAndVerifySubtree.ts
+function applyAndVerifySubtree(target, plan2, context) {
+  if (plan2.typeChangeCount === 0 && plan2.labelRemovalCount === 0) return;
+  applyFixStructurePlan(plan2);
+  writeLineNow(chalk163.dim("Re-walking the subtree to confirm"));
+  assertNoResidualDrift(
+    planSubtree(fetchRootIssue(target), context),
+    context.chain
+  );
+  writeLineNow(chalk163.green("Subtree normalised"));
 }
 
 // src/commands/github/issue/fixStructure/printFixStructurePlan.ts
-import chalk162 from "chalk";
+import chalk164 from "chalk";
 function annotate(entry) {
   const notes = [];
   if (entry.level === null) {
-    notes.push(chalk162.red("deeper than the leaf level"));
+    notes.push(chalk164.red("deeper than the leaf level"));
   } else if (entry.typeChange) {
     notes.push(
-      chalk162.yellow(
+      chalk164.yellow(
         `${entry.typeChange.from ?? "no type"} -> ${entry.typeChange.to}`
       )
     );
   } else {
-    notes.push(chalk162.dim(entry.issue.typeName ?? "no type"));
+    notes.push(chalk164.dim(entry.issue.typeName ?? "no type"));
   }
   for (const label2 of entry.labelRemovals) {
-    notes.push(chalk162.yellow(`-${label2.name}`));
+    notes.push(chalk164.yellow(`-${label2.name}`));
   }
   return notes;
 }
 function formatCount(count8, noun) {
   return `${count8} ${noun}${count8 === 1 ? "" : "s"}`;
 }
-function printFixStructurePlan(plan2, chain2) {
-  console.log(chalk162.dim(`chain: ${chain2.join(" > ")}`));
+function printFixStructurePlan(plan2, chain2, apply) {
+  writeLineNow(chalk164.dim(`chain: ${chain2.join(" > ")}`));
   for (const entry of plan2.entries) {
     const indent3 = "  ".repeat(entry.issue.depth);
-    const name = chalk162.cyan(`${entry.issue.repo}#${entry.issue.number}`);
-    console.log(
+    const name = chalk164.cyan(`${entry.issue.repo}#${entry.issue.number}`);
+    writeLineNow(
       `${indent3}${name} ${entry.issue.title} [${annotate(entry).join(", ")}]`
     );
   }
-  for (const { issue, parent } of plan2.tooDeep) {
-    const where = parent ? ` under ${parent.repo}#${parent.number}` : "";
-    console.error(
-      chalk162.red(
-        `${issue.repo}#${issue.number}${where} sits below ${chain2[chain2.length - 1]}, the leaf level`
-      )
-    );
-  }
   if (plan2.typeChangeCount === 0 && plan2.labelRemovalCount === 0) {
-    console.log(chalk162.green("Nothing to change"));
+    writeLineNow(chalk164.green("Nothing to change"));
     return;
   }
-  console.log(
+  writeLineNow(
     `${formatCount(plan2.typeChangeCount, "type change")}, ${formatCount(plan2.labelRemovalCount, "label removal")} planned`
   );
-  console.log(chalk162.dim("Dry run \u2014 nothing written"));
+  if (!apply) writeLineNow(chalk164.dim("Dry run \u2014 nothing written"));
 }
 
 // src/commands/github/issue/fixStructure/resolveFixStructureTarget.ts
@@ -21251,7 +21110,7 @@ function resolveFixStructureTarget(target, repo) {
 }
 
 // src/commands/github/issue/fixStructure/resolveOrgIssueTypes.ts
-var QUERY2 = `query($owner: String!) {
+var QUERY3 = `query($owner: String!) {
 	organization(login: $owner) {
 		issueTypes(first: 50) { nodes { id name } }
 	}
@@ -21264,7 +21123,7 @@ function missingOrg(owner) {
 function resolveOrgIssueTypes(owner) {
   let raw;
   try {
-    raw = runGhGraphqlJson(QUERY2, { owner });
+    raw = runGhGraphqlJson(QUERY3, { owner });
   } catch (error) {
     const message3 = error instanceof Error ? error.message : String(error);
     if (message3.includes("Could not resolve to an Organization")) {
@@ -21307,52 +21166,6 @@ function resolveRootLevelIndex(chain2, targetTypeName, level) {
 // src/commands/github/issue/fixStructure/types.ts
 var defaultTypeChain = ["Epic", "Story", "Subtask"];
 
-// src/commands/github/issue/fixStructure/fetchSubtreeIssues.ts
-var QUERY3 = `query($ids: [ID!]!) {
-	nodes(ids: $ids) { ... on Issue { ...issueFields } }
-}
-${issueFieldsFragment}`;
-var BATCH = 50;
-function fetchSubtreeIssues(ids) {
-  const issues = [];
-  for (let start3 = 0; start3 < ids.length; start3 += BATCH) {
-    const raw = runGhGraphqlJson(QUERY3, {
-      ids: ids.slice(start3, start3 + BATCH)
-    });
-    const nodes = JSON.parse(raw).data?.nodes ?? [];
-    for (const node of nodes) {
-      if (node) issues.push(parseIssueNode(node));
-    }
-  }
-  return issues;
-}
-
-// src/commands/github/issue/fixStructure/walkSubtree.ts
-function walkSubtree(root, maxDepth, fetchIssues = fetchSubtreeIssues) {
-  const placed = [{ ...root, depth: 0, parentId: null }];
-  const seen = /* @__PURE__ */ new Set([root.id]);
-  let frontier = placed;
-  for (let depth = 1; depth <= maxDepth && frontier.length > 0; depth += 1) {
-    const parentOf2 = /* @__PURE__ */ new Map();
-    for (const parent of frontier) {
-      for (const childId of parent.childIds) {
-        if (seen.has(childId)) continue;
-        seen.add(childId);
-        parentOf2.set(childId, parent.id);
-      }
-    }
-    if (parentOf2.size === 0) break;
-    const children = fetchIssues([...parentOf2.keys()]).map((issue) => ({
-      ...issue,
-      depth,
-      parentId: parentOf2.get(issue.id) ?? null
-    }));
-    placed.push(...children);
-    frontier = children;
-  }
-  return placed;
-}
-
 // src/commands/github/issue/fixStructure/fixStructure.ts
 function fixStructure(target, options2) {
   const chain2 = defaultTypeChain;
@@ -21364,15 +21177,17 @@ function fixStructure(target, options2) {
       root.typeName,
       options2.level
     );
-    const issueTypes = resolveOrgIssueTypes(resolved.owner);
-    const issues = walkSubtree(root, chain2.length - index3);
-    const plan2 = buildFixStructurePlan(issues, {
+    const context = {
       chain: chain2,
       rootLevelIndex: index3,
       rootAsserted: asserted,
-      issueTypes
-    });
-    printFixStructurePlan(plan2, chain2);
+      issueTypes: resolveOrgIssueTypes(resolved.owner),
+      stripLabels: []
+    };
+    const plan2 = planSubtree(root, context);
+    printFixStructurePlan(plan2, chain2, options2.apply === true);
+    assertNothingTooDeep(plan2.tooDeep, chain2);
+    if (options2.apply) applyAndVerifySubtree(resolved, plan2, context);
   } catch (error) {
     console.error(error instanceof Error ? error.message : String(error));
     process.exit(1);
@@ -21383,19 +21198,20 @@ function fixStructure(target, options2) {
 var chain = defaultTypeChain.join(" > ");
 var levels = defaultTypeChain.map((name) => name.toLowerCase()).join("|");
 function registerFixStructure(issueCommand) {
-  issueCommand.command("fix-structure <target>").description("Report the issue type drift across one issue subtree").option(
+  issueCommand.command("fix-structure <target>").description("Normalise the issue types across one issue subtree").option(
     "-R, --repo <owner/repo>",
     "Repository a bare issue number belongs to"
   ).option(
     "--level <level>",
     `The target's own position in the ${chain} chain, when it cannot be inferred from its type`
-  ).addHelpText(
+  ).option("--apply", "Write the planned changes instead of reporting them").addHelpText(
     "after",
     `
 Walks the subtree reachable from <target> via sub-issues and reports the type each issue should carry: every level below the target is typed to the next level down the ${chain} chain. Nothing outside the subtree is ever read or written.
 The target's own level is inferred from its issue type, so aiming at a story types its children as subtasks. When the target's type is not in the chain the level cannot be inferred, and --level ${levels} asserts it instead \u2014 which also plans the target's own type.
 The target is owner/repo#number, a github.com issue URL, or a bare number with --repo.
-This reports only; nothing is written.`
+Without --apply nothing is written. With --apply each write is announced before it is issued, and the subtree is re-walked afterwards so any residual drift fails the run.
+Anything nested below the leaf level fails the run before a single write, naming the offender and its parent.`
   ).action(fixStructure);
 }
 
@@ -21410,9 +21226,136 @@ async function readBodyArgument(value) {
   return body;
 }
 
-// src/commands/registerGithubIssue.ts
-function registerGithubIssue(githubCommand) {
-  const issueCommand = githubCommand.command("issue").description("GitHub issue utilities");
+// src/commands/github/issue/commentIssue.ts
+import { execFileSync as execFileSync6 } from "child_process";
+
+// src/shared/validateProposedContent.ts
+function validateProposedContent(labels, title, body) {
+  const { subject, context } = labels;
+  if (title.toLowerCase().includes("claude")) {
+    console.error(`Error: ${subject} title must not reference Claude`);
+    process.exit(1);
+  }
+  if (body.toLowerCase().includes("claude")) {
+    console.error(`Error: ${subject} body must not reference Claude`);
+    process.exit(1);
+  }
+  const titleBacklogIds = findBacklogRefs(title);
+  if (titleBacklogIds.length > 0) {
+    console.error(
+      backlogRefError(`${subject} title`, context, titleBacklogIds)
+    );
+    process.exit(1);
+  }
+  const bodyBacklogIds = findBacklogRefs(body);
+  if (bodyBacklogIds.length > 0) {
+    console.error(backlogRefError(`${subject} body`, context, bodyBacklogIds));
+    process.exit(1);
+  }
+}
+
+// src/commands/github/issue/reviewProposedIssueComment.ts
+import { randomUUID as randomUUID7 } from "crypto";
+async function reviewProposedIssueComment(title, body) {
+  const sessionId = process.env.ASSIST_SESSION_ID;
+  if (process.env.ASSIST_SESSION !== "1" || !sessionId) return;
+  await awaitPreviewApproval("GitHub issue comment preview", {
+    sessionId,
+    requestId: randomUUID7(),
+    title,
+    body,
+    prNumber: null,
+    kind: "github-issue-comment"
+  });
+}
+
+// src/commands/github/issue/commentIssue.ts
+var USAGE = "Usage: assist github issue comment <number> --body <body> [-R <owner>/<repo>]";
+async function commentIssue(numberArg, options2) {
+  const number = Number.parseInt(numberArg, 10);
+  if (!Number.isInteger(number) || number <= 0 || !options2.body) {
+    console.error(USAGE);
+    process.exit(1);
+  }
+  const { body } = options2;
+  const target = options2.repo ? `${options2.repo}#${number}` : `issue #${number}`;
+  validateProposedContent(
+    { subject: "Comment", context: "GitHub issues" },
+    "",
+    body
+  );
+  await reviewProposedIssueComment(`Comment on ${target}`, body);
+  const args = ["issue", "comment", String(number), "--body", body];
+  if (options2.repo) args.push("--repo", options2.repo);
+  try {
+    execFileSync6("gh", args, { stdio: "inherit" });
+  } catch {
+    process.exit(1);
+  }
+  console.log(`Comment posted to ${target}`);
+}
+
+// src/commands/github/issue/registerCommentIssue.ts
+function registerCommentIssue(issueCommand) {
+  issueCommand.command("comment <number>").description("Comment on a GitHub issue (body of - reads it from stdin)").option("--body <body>", "Comment body (- reads it from stdin)").option(
+    "-R, --repo <owner/repo>",
+    "Target repository (defaults to the current repo)"
+  ).addHelpText(
+    "after",
+    "\nThe comment is outward-facing: write it for the repo's readers, not the team. It is rejected if it references Claude or an assist backlog item.\nIn an assist web session the body is previewed for approve/reject first (with inline comments); nothing is posted until it is approved."
+  ).action(
+    async (number, options2) => {
+      await commentIssue(number, {
+        ...options2,
+        body: options2.body ? await readBodyArgument(options2.body) : void 0
+      });
+    }
+  );
+}
+
+// src/commands/github/issue/createIssue.ts
+import { execFileSync as execFileSync7 } from "child_process";
+
+// src/commands/github/issue/reviewProposedIssue.ts
+import { randomUUID as randomUUID8 } from "crypto";
+async function reviewProposedIssue(title, body) {
+  const sessionId = process.env.ASSIST_SESSION_ID;
+  if (process.env.ASSIST_SESSION !== "1" || !sessionId) return;
+  await awaitPreviewApproval("GitHub issue preview", {
+    sessionId,
+    requestId: randomUUID8(),
+    title,
+    body,
+    prNumber: null,
+    kind: "github-issue"
+  });
+}
+
+// src/commands/github/issue/createIssue.ts
+var USAGE2 = "Usage: assist github issue create --title <title> --body <body> [-R <owner>/<repo>]";
+async function createIssue(options2) {
+  if (!options2.title || !options2.body) {
+    console.error(USAGE2);
+    process.exit(1);
+  }
+  const { title, body } = options2;
+  validateProposedContent(
+    { subject: "Issue", context: "GitHub issues" },
+    title,
+    body
+  );
+  await reviewProposedIssue(title, body);
+  const args = ["issue", "create", "--title", title, "--body", body];
+  if (options2.repo) args.push("--repo", options2.repo);
+  try {
+    execFileSync7("gh", args, { stdio: "inherit" });
+  } catch {
+    process.exit(1);
+  }
+}
+
+// src/commands/github/issue/registerCreateIssue.ts
+function registerCreateIssue(issueCommand) {
   issueCommand.command("create").description("Create a GitHub issue").option("--title <title>", "Issue title").option("--body <body>", "Issue body").option(
     "-R, --repo <owner/repo>",
     "Target repository (defaults to the current repo)"
@@ -21420,6 +21363,205 @@ function registerGithubIssue(githubCommand) {
     "after",
     "\nThere is no What/Why/How template: an issue reports a problem, and the target repo's own issue template is unknowable from here. Write the body as the repo's maintainers would expect.\nIn an assist web session the title and body are previewed for approve/reject first (with inline comments); nothing is created until it is approved."
   ).action(createIssue);
+}
+
+// src/commands/sessions/shared/inWebSession.ts
+function inWebSession() {
+  return process.env.ASSIST_SESSION === "1" && !!process.env.ASSIST_SESSION_ID;
+}
+
+// src/commands/github/issue/fetchIssue.ts
+import { execFileSync as execFileSync8 } from "child_process";
+function fetchIssue2(number, repo) {
+  const args = [
+    "issue",
+    "view",
+    String(number),
+    "--json",
+    "title,body,updatedAt,url"
+  ];
+  if (repo) args.push("--repo", repo);
+  let raw;
+  try {
+    raw = execFileSync8("gh", args, { encoding: "utf8" });
+  } catch {
+    console.error(`Could not fetch issue #${number} with gh issue view`);
+    process.exit(1);
+  }
+  try {
+    return JSON.parse(raw);
+  } catch {
+    console.error(`Could not parse the gh issue view output for #${number}`);
+    process.exit(1);
+  }
+}
+
+// src/commands/github/issue/resumeIssueBody.ts
+import { existsSync as existsSync48, readFileSync as readFileSync37 } from "fs";
+
+// src/commands/github/issue/issueWorkingFile.ts
+import { join as join50 } from "path";
+function issueWorkingFile(slug, number) {
+  const [owner = "unknown", repo = "unknown"] = slug.split("/");
+  const dir = join50(getStoreDir(), "github-issues", owner, repo);
+  return {
+    dir,
+    bodyPath: join50(dir, `${number}.md`),
+    metaPath: join50(dir, `${number}.json`)
+  };
+}
+
+// src/commands/github/issue/resumeIssueBody.ts
+function resumeIssueBody(slug, number, updatedAt) {
+  const { bodyPath, metaPath } = issueWorkingFile(slug, number);
+  if (!existsSync48(bodyPath) || !existsSync48(metaPath)) return void 0;
+  try {
+    const meta = JSON.parse(readFileSync37(metaPath, "utf8"));
+    if (meta.updatedAt !== updatedAt) return void 0;
+    return readFileSync37(bodyPath, "utf8");
+  } catch {
+    return void 0;
+  }
+}
+
+// src/commands/github/issue/validateIssueBody.ts
+function validateIssueBody(title, body) {
+  validateProposedContent(
+    { subject: "Issue", context: "GitHub issues" },
+    title,
+    body
+  );
+}
+
+// src/commands/github/issue/writeIssueWorkingFile.ts
+import { mkdirSync as mkdirSync16, writeFileSync as writeFileSync31 } from "fs";
+function writeIssueWorkingFile(slug, number, target, updatedAt, body) {
+  const { dir, bodyPath, metaPath } = issueWorkingFile(slug, number);
+  mkdirSync16(dir, { recursive: true });
+  writeFileSync31(bodyPath, body);
+  writeFileSync31(
+    metaPath,
+    `${JSON.stringify({ target, updatedAt }, null, 2)}
+`
+  );
+  return bodyPath;
+}
+
+// src/commands/github/issue/prepareIssueEdit.ts
+function slugFromUrl(url) {
+  const match = /github\.com\/([^/]+\/[^/]+)\//.exec(url ?? "");
+  return match ? match[1] : "unknown/unknown";
+}
+function prepareIssueEdit(number, repo, fresh) {
+  const issue = fetchIssue2(number, repo);
+  const slug = repo ?? slugFromUrl(issue.url);
+  const target = `${slug}#${number}`;
+  const resumed = fresh ? void 0 : resumeIssueBody(slug, number, issue.updatedAt);
+  const body = resumed ?? issue.body;
+  validateIssueBody(issue.title, body);
+  const save = (markdown) => writeIssueWorkingFile(slug, number, target, issue.updatedAt, markdown);
+  const bodyPath = save(body);
+  if (resumed !== void 0)
+    console.log(`Previewing the in-progress markdown from ${bodyPath}`);
+  return {
+    title: issue.title,
+    target,
+    updatedAt: issue.updatedAt,
+    body,
+    bodyPath,
+    save
+  };
+}
+
+// src/commands/github/issue/pushIssueBody.ts
+import { execFileSync as execFileSync9 } from "child_process";
+function pushIssueBody(number, repo, bodyPath) {
+  const args = ["issue", "edit", String(number), "--body-file", bodyPath];
+  if (repo) args.push("--repo", repo);
+  try {
+    execFileSync9("gh", args, { stdio: "inherit" });
+  } catch {
+    process.exit(1);
+  }
+}
+
+// src/commands/github/issue/pushUnchangedIssue.ts
+function pushUnchangedIssue(number, repo, target, fetchedAt, bodyPath) {
+  if (fetchIssue2(number, repo).updatedAt !== fetchedAt) {
+    console.error(
+      `${target} was updated on GitHub after it was fetched. Nothing was pushed; the markdown is at ${bodyPath}`
+    );
+    process.exit(1);
+  }
+  pushIssueBody(number, repo, bodyPath);
+  console.log(`Issue body updated on ${target}`);
+}
+
+// src/commands/github/issue/reviewProposedIssueEdit.ts
+import { randomUUID as randomUUID9 } from "crypto";
+async function reviewProposedIssueEdit(title, body, working) {
+  const sessionId = process.env.ASSIST_SESSION_ID;
+  if (process.env.ASSIST_SESSION !== "1" || !sessionId) return body;
+  const decision = await awaitPreviewApproval(
+    "GitHub issue edit preview",
+    {
+      sessionId,
+      requestId: randomUUID9(),
+      title,
+      body,
+      prNumber: null,
+      kind: "github-issue-edit"
+    },
+    {
+      saveEditedBody: working.save,
+      rejectionAdvice: `Nothing was pushed. The pane's markdown, including any collapses already applied, is at ${working.path}. Revise that file in place \u2014 do not recompose the body from scratch \u2014 then re-run this command to preview the revision.`
+    }
+  );
+  return decision.body ?? body;
+}
+
+// src/commands/github/issue/viewIssue.ts
+import { execFileSync as execFileSync10 } from "child_process";
+function viewIssue(number, repo) {
+  const args = ["issue", "view", String(number)];
+  if (repo) args.push("--repo", repo);
+  try {
+    execFileSync10("gh", args, { stdio: "inherit" });
+  } catch {
+    process.exit(1);
+  }
+}
+
+// src/commands/github/issue/editIssue.ts
+var USAGE3 = "Usage: assist github issue edit <number> [-R <owner>/<repo>]";
+async function editIssue(numberArg, options2) {
+  const number = Number.parseInt(numberArg, 10);
+  if (!Number.isInteger(number) || number <= 0) {
+    console.error(USAGE3);
+    process.exit(1);
+  }
+  if (!inWebSession()) {
+    viewIssue(number, options2.repo);
+    return;
+  }
+  const issue = prepareIssueEdit(number, options2.repo, options2.fresh);
+  const edited = await reviewProposedIssueEdit(
+    `Edit ${issue.target}: ${issue.title}`,
+    issue.body,
+    { path: issue.bodyPath, save: issue.save }
+  );
+  validateIssueBody(issue.title, edited);
+  pushUnchangedIssue(
+    number,
+    options2.repo,
+    issue.target,
+    issue.updatedAt,
+    issue.bodyPath
+  );
+}
+
+// src/commands/github/issue/registerEditIssue.ts
+function registerEditIssue(issueCommand) {
   issueCommand.command("edit <number>").description("Edit an existing GitHub issue's body in the preview pane").option(
     "-R, --repo <owner/repo>",
     "Target repository (defaults to the current repo)"
@@ -21430,20 +21572,14 @@ function registerGithubIssue(githubCommand) {
     "after",
     "\nFetches the issue's current body and opens it in the assist web preview pane, where it can be reworked before it is pushed back. Approving pushes the pane's markdown to the issue; nothing is pushed if the issue moved on GitHub after it was fetched, or outside a web session.\nRejecting writes the pane's markdown to a working file and names it: revise that file in place and re-run to preview the revision, which keeps any collapses already applied. A re-run resumes from the working file while the issue has not moved on GitHub; --fresh discards it and re-fetches.\nOnly the body is touched \u2014 the title, labels, assignees and state are left alone."
   ).action(editIssue);
-  issueCommand.command("comment <number>").description("Comment on a GitHub issue (body of - reads it from stdin)").option("--body <body>", "Comment body (- reads it from stdin)").option(
-    "-R, --repo <owner/repo>",
-    "Target repository (defaults to the current repo)"
-  ).addHelpText(
-    "after",
-    "\nThe comment is outward-facing: write it for the repo's readers, not the team. It is rejected if it references Claude or an assist backlog item.\nIn an assist web session the body is previewed for approve/reject first (with inline comments); nothing is posted until it is approved."
-  ).action(
-    async (number, options2) => {
-      await commentIssue(number, {
-        ...options2,
-        body: options2.body ? await readBodyArgument(options2.body) : void 0
-      });
-    }
-  );
+}
+
+// src/commands/registerGithubIssue.ts
+function registerGithubIssue(githubCommand) {
+  const issueCommand = githubCommand.command("issue").description("GitHub issue utilities");
+  registerCreateIssue(issueCommand);
+  registerEditIssue(issueCommand);
+  registerCommentIssue(issueCommand);
   registerFixStructure(issueCommand);
 }
 
@@ -21684,7 +21820,7 @@ function registerHandover(program2) {
 }
 
 // src/commands/jira/acceptanceCriteria.ts
-import chalk163 from "chalk";
+import chalk165 from "chalk";
 
 // src/commands/jira/adfToText.ts
 function renderInline(node) {
@@ -21751,7 +21887,7 @@ function acceptanceCriteria(issueKey) {
   const parsed = fetchIssue(issueKey, field);
   const acValue = parsed?.fields?.[field];
   if (!acValue) {
-    console.log(chalk163.yellow(`No acceptance criteria found on ${issueKey}.`));
+    console.log(chalk165.yellow(`No acceptance criteria found on ${issueKey}.`));
     return;
   }
   if (typeof acValue === "string") {
@@ -21817,14 +21953,14 @@ async function jiraAuth() {
 }
 
 // src/commands/jira/viewIssue.ts
-import chalk164 from "chalk";
+import chalk166 from "chalk";
 function viewIssue2(issueKey) {
   const parsed = fetchIssue(issueKey, "summary,description");
   const fields = parsed?.fields;
   const summary = fields?.summary;
   const description = fields?.description;
   if (summary) {
-    console.log(chalk164.bold(summary));
+    console.log(chalk166.bold(summary));
   }
   if (description) {
     if (summary) console.log();
@@ -21838,7 +21974,7 @@ function viewIssue2(issueKey) {
   }
   if (!summary && !description) {
     console.log(
-      chalk164.yellow(`No summary or description found on ${issueKey}.`)
+      chalk166.yellow(`No summary or description found on ${issueKey}.`)
     );
   }
 }
@@ -21873,7 +22009,7 @@ import { randomUUID as randomUUID10 } from "crypto";
 
 // src/commands/review/checkoutPr.ts
 import { execFileSync as execFileSync12 } from "child_process";
-import chalk165 from "chalk";
+import chalk167 from "chalk";
 
 // src/commands/sessions/daemon/daemonLog.ts
 var RING_CAPACITY = 1e3;
@@ -22485,7 +22621,7 @@ async function checkoutPr(number) {
   try {
     execFileSync12("gh", ["pr", "checkout", number], { stdio: "inherit" });
   } catch {
-    console.error(chalk165.red(`gh pr checkout ${number} failed; aborting.`));
+    console.error(chalk167.red(`gh pr checkout ${number} failed; aborting.`));
     process.exit(1);
   }
 }
@@ -22622,15 +22758,15 @@ function registerList(program2) {
 // src/commands/mermaid/index.ts
 import { mkdirSync as mkdirSync18, readdirSync as readdirSync11 } from "fs";
 import { resolve as resolve16 } from "path";
-import chalk168 from "chalk";
+import chalk170 from "chalk";
 
 // src/commands/mermaid/exportFile.ts
 import { readFileSync as readFileSync39, writeFileSync as writeFileSync32 } from "fs";
 import { basename as basename17, extname as extname2, resolve as resolve15 } from "path";
-import chalk167 from "chalk";
+import chalk169 from "chalk";
 
 // src/commands/mermaid/renderBlock.ts
-import chalk166 from "chalk";
+import chalk168 from "chalk";
 async function renderBlock(krokiUrl, source) {
   const response = await fetch(`${krokiUrl}/mermaid/svg`, {
     method: "POST",
@@ -22639,7 +22775,7 @@ async function renderBlock(krokiUrl, source) {
   });
   if (!response.ok) {
     console.error(
-      chalk166.red(
+      chalk168.red(
         `Kroki request failed: ${response.status} ${response.statusText}`
       )
     );
@@ -22657,19 +22793,19 @@ async function exportFile(file, outDir, krokiUrl, onlyIndex) {
   if (onlyIndex !== void 0) {
     if (onlyIndex < 1 || onlyIndex > blocks.length) {
       console.error(
-        chalk167.red(
+        chalk169.red(
           `${file}: --index ${onlyIndex} out of range (file has ${blocks.length} diagram(s))`
         )
       );
       process.exit(1);
     }
     console.log(
-      chalk167.gray(
+      chalk169.gray(
         `${file} \u2014 rendering diagram ${onlyIndex} of ${blocks.length}`
       )
     );
   } else {
-    console.log(chalk167.gray(`${file} \u2014 ${blocks.length} diagram(s)`));
+    console.log(chalk169.gray(`${file} \u2014 ${blocks.length} diagram(s)`));
   }
   for (const [i, source] of blocks.entries()) {
     const idx = i + 1;
@@ -22677,7 +22813,7 @@ async function exportFile(file, outDir, krokiUrl, onlyIndex) {
     const outPath = resolve15(outDir, `${stem}-${idx}.svg`);
     const svg = await renderBlock(krokiUrl, source);
     writeFileSync32(outPath, svg, "utf8");
-    console.log(chalk167.green(`  \u2192 ${outPath}`));
+    console.log(chalk169.green(`  \u2192 ${outPath}`));
   }
 }
 function extractMermaidBlocks(markdown) {
@@ -22693,18 +22829,18 @@ async function mermaidExport(file, options2 = {}) {
   if (options2.index !== void 0) {
     if (!Number.isInteger(options2.index) || options2.index < 1) {
       console.error(
-        chalk168.red(`--index must be a positive integer (got ${options2.index})`)
+        chalk170.red(`--index must be a positive integer (got ${options2.index})`)
       );
       process.exit(1);
     }
     if (!file) {
-      console.error(chalk168.red("--index requires a file argument"));
+      console.error(chalk170.red("--index requires a file argument"));
       process.exit(1);
     }
   }
   const files = file ? [file] : readdirSync11(process.cwd()).filter((name) => name.toLowerCase().endsWith(".md")).sort();
   if (files.length === 0) {
-    console.log(chalk168.gray("No markdown files found in current directory."));
+    console.log(chalk170.gray("No markdown files found in current directory."));
     return;
   }
   for (const f of files) {
@@ -22727,11 +22863,191 @@ function registerMermaid(program2) {
   configHelp(cmd, mermaidConfigHelp);
 }
 
+// src/commands/miro/runExtract.ts
+import { stringify } from "yaml";
+
+// src/commands/miro/MiroExtractError.ts
+var MiroExtractError = class extends Error {
+  constructor(message3) {
+    super(message3);
+    this.name = "MiroExtractError";
+  }
+};
+
+// src/commands/miro/stripHtml.ts
+var namedEntities = {
+  amp: "&",
+  apos: "'",
+  gt: ">",
+  lt: "<",
+  nbsp: " ",
+  quot: '"'
+};
+function decodeEntity(_match, entity) {
+  if (entity.startsWith("#")) {
+    const code = entity.startsWith("#x") || entity.startsWith("#X") ? Number.parseInt(entity.slice(2), 16) : Number.parseInt(entity.slice(1), 10);
+    return Number.isNaN(code) ? _match : String.fromCodePoint(code);
+  }
+  return namedEntities[entity.toLowerCase()] ?? _match;
+}
+function stripHtml2(content) {
+  return content.replace(/<br\s*\/?>/gi, " ").replace(/<\/(?:p|div|li|h[1-6])>/gi, " ").replace(/<[^>]*>/g, "").replace(/&(#[0-9a-f]+|[a-z]+);/gi, decodeEntity).replace(/\s+/g, " ").trim();
+}
+
+// src/commands/miro/normaliseItems.ts
+var frameCoordinates = "parent_top_left";
+function describe4(item) {
+  return `  ${item.id ?? "(no id)"} (${item.type ?? "unknown type"}): relativeTo=${item.position?.relativeTo ?? "missing"}`;
+}
+function coordinateSpaceError(rejected) {
+  return new MiroExtractError(
+    `${rejected.length} item(s) are not in frame coordinates (position.relativeTo must be "${frameCoordinates}"):
+${rejected.slice(0, 5).map(describe4).join(
+      "\n"
+    )}
+
+Dump the frame with board_list_items using ?moveToWidget=<frame id> so every item shares one coordinate space.`
+  );
+}
+function toItem(item) {
+  const halfWidth = (item.geometry?.width ?? 0) / 2;
+  const halfHeight = (item.geometry?.height ?? 0) / 2;
+  const x = item.position?.x ?? 0;
+  const y = item.position?.y ?? 0;
+  return {
+    id: item.id ?? "",
+    type: item.type ?? "",
+    text: stripHtml2(item.data?.content ?? ""),
+    left: x - halfWidth,
+    top: y - halfHeight,
+    right: x + halfWidth,
+    bottom: y + halfHeight
+  };
+}
+function normaliseItems(items2) {
+  const rejected = items2.filter(
+    (item) => item.position?.relativeTo !== frameCoordinates
+  );
+  if (rejected.length > 0) throw coordinateSpaceError(rejected);
+  return items2.map(toItem);
+}
+
+// src/commands/miro/parseAnchorId.ts
+function parseAnchorId(value) {
+  const trimmed = value.trim();
+  const link3 = /[?&]moveToWidget=([^&#]+)/.exec(trimmed);
+  return link3 ? decodeURIComponent(link3[1]).trim() : trimmed;
+}
+
+// src/commands/miro/readMiroItems.ts
+import { readFileSync as readFileSync40 } from "fs";
+function tryParse(text18) {
+  try {
+    return JSON.parse(text18);
+  } catch {
+    return void 0;
+  }
+}
+function toPage(value) {
+  const record = value ?? {};
+  if (Array.isArray(record.data)) return { data: record.data };
+  return record.id ? { data: [record] } : {};
+}
+function parseJsonLines(raw, file) {
+  return raw.split("\n").map((line) => line.trim()).filter(Boolean).map((line) => {
+    const parsed = tryParse(line);
+    if (parsed === void 0)
+      throw new MiroExtractError(
+        `${file} is not valid JSON or JSON lines. Save the raw board_list_items response pages without editing them.`
+      );
+    return toPage(parsed);
+  });
+}
+function parsePages(raw, file) {
+  const parsed = tryParse(raw);
+  if (parsed === void 0) return parseJsonLines(raw, file);
+  return Array.isArray(parsed) ? parsed.map(toPage) : [toPage(parsed)];
+}
+function readMiroItems(file) {
+  const items2 = parsePages(readFileSync40(file, "utf8"), file).flatMap(
+    (page) => page.data ?? []
+  );
+  if (items2.length === 0)
+    throw new MiroExtractError(
+      `No board items found in ${file}. Dump the frame with board_list_items, paging until has_more is false.`
+    );
+  return items2;
+}
+
+// src/commands/miro/selectBoxes.ts
+var boxTypes = /* @__PURE__ */ new Set(["shape", "sticky_note"]);
+function findAnchor(items2, id) {
+  const anchor = items2.find((item) => item.id === id);
+  if (!anchor)
+    throw new MiroExtractError(
+      `No item with id ${id} in the supplied items. Re-dump the frame so the anchor is included, then try again.`
+    );
+  return anchor;
+}
+function isBox(item) {
+  return boxTypes.has(item.type) && item.text.length > 0;
+}
+function centreInside(rect, item) {
+  const x = (item.left + item.right) / 2;
+  const y = (item.top + item.bottom) / 2;
+  return x >= rect.left && x <= rect.right && y >= rect.top && y <= rect.bottom;
+}
+function selectBoxes(items2, topLeftId, bottomRightId) {
+  const topLeft = findAnchor(items2, topLeftId);
+  const bottomRight = findAnchor(items2, bottomRightId);
+  const rect = {
+    left: topLeft.left,
+    top: topLeft.top,
+    right: bottomRight.right,
+    bottom: bottomRight.bottom
+  };
+  return items2.filter((item) => isBox(item) && centreInside(rect, item)).sort((a, b) => a.left - b.left || a.top - b.top);
+}
+
+// src/commands/miro/runExtract.ts
+function requireItems(file) {
+  if (!file)
+    throw new MiroExtractError(
+      "--items <file> is required: a file of raw board_list_items response pages."
+    );
+  return file;
+}
+function requireAnchors(options2) {
+  if (!options2.topLeft || !options2.bottomRight)
+    throw new MiroExtractError(
+      "Both --top-left <id|link> and --bottom-right <id|link> are required."
+    );
+  return [parseAnchorId(options2.topLeft), parseAnchorId(options2.bottomRight)];
+}
+function runExtract(options2) {
+  const [topLeft, bottomRight] = requireAnchors(options2);
+  const items2 = normaliseItems(readMiroItems(requireItems(options2.items)));
+  const boxes = selectBoxes(items2, topLeft, bottomRight);
+  process.stdout.write(stringify(boxes.map((box) => box.text)));
+}
+
+// src/commands/miro/registerMiro.ts
+function registerMiro(program2) {
+  const miroCommand = program2.command("miro").description("Miro board utilities");
+  miroCommand.command("extract").description("Print the text of every box inside a rectangle on a board").option("--items <file>", "File of raw board_list_items response pages").option(
+    "--top-left <id>",
+    "Widget id or ?moveToWidget=<id> link of the top-left box"
+  ).option(
+    "--bottom-right <id>",
+    "Widget id or ?moveToWidget=<id> link of the bottom-right box"
+  ).action(runExtract);
+}
+
 // src/commands/netcap/netcap.ts
 import { mkdir as mkdir4 } from "fs/promises";
 import { createServer as createServer2 } from "http";
 import { dirname as dirname28 } from "path";
-import chalk170 from "chalk";
+import chalk172 from "chalk";
 
 // src/commands/netcap/corsHeaders.ts
 var corsHeaders = {
@@ -22810,7 +23126,7 @@ function createNetcapHandler(options2) {
 import { cp, readFile as readFile4, writeFile as writeFile4 } from "fs/promises";
 import { networkInterfaces } from "os";
 import { join as join58 } from "path";
-import chalk169 from "chalk";
+import chalk171 from "chalk";
 
 // src/commands/netcap/netcapExtensionDir.ts
 import { dirname as dirname27, join as join57 } from "path";
@@ -22854,7 +23170,7 @@ async function prepareExtensionForLoad(port, filter = "") {
   const host = lanIPv4();
   if (!host) {
     console.log(
-      chalk169.yellow("could not determine the WSL IP for the extension")
+      chalk171.yellow("could not determine the WSL IP for the extension")
     );
     await configureBackground(source, "127.0.0.1", port, filter);
     return source;
@@ -22865,7 +23181,7 @@ async function prepareExtensionForLoad(port, filter = "") {
     return WSL_WINDOWS_PATH;
   } catch {
     console.log(
-      chalk169.yellow(`could not copy extension to ${WSL_WINDOWS_PATH}`)
+      chalk171.yellow(`could not copy extension to ${WSL_WINDOWS_PATH}`)
     );
     return source;
   }
@@ -22898,30 +23214,30 @@ async function netcap(options2) {
   let count8 = 0;
   const handler = createNetcapHandler({
     outPath,
-    onPing: () => console.log(chalk170.dim("ping from extension")),
+    onPing: () => console.log(chalk172.dim("ping from extension")),
     onCapture: (entry) => {
       count8 += 1;
       console.log(
-        chalk170.green(`captured #${count8}`),
-        chalk170.dim(`${entry.method ?? "?"} ${entry.url ?? "?"}`)
+        chalk172.green(`captured #${count8}`),
+        chalk172.dim(`${entry.method ?? "?"} ${entry.url ?? "?"}`)
       );
     }
   });
   const server = createServer2(handler);
   server.listen(port, () => {
     console.log(
-      chalk170.bold(`netcap receiver listening on http://127.0.0.1:${port}`)
+      chalk172.bold(`netcap receiver listening on http://127.0.0.1:${port}`)
     );
-    console.log(chalk170.dim(`appending captures to ${outPath}`));
+    console.log(chalk172.dim(`appending captures to ${outPath}`));
     if (filter)
-      console.log(chalk170.dim(`forwarding only URLs matching "${filter}"`));
-    console.log(chalk170.dim(`load the unpacked extension from ${extensionPath}`));
-    console.log(chalk170.dim("press Ctrl-C to stop"));
+      console.log(chalk172.dim(`forwarding only URLs matching "${filter}"`));
+    console.log(chalk172.dim(`load the unpacked extension from ${extensionPath}`));
+    console.log(chalk172.dim("press Ctrl-C to stop"));
   });
   process.on("SIGINT", () => {
     server.close();
     console.log(
-      chalk170.bold(
+      chalk172.bold(
         `
 netcap stopped \u2014 captured ${count8} ${count8 === 1 ? "entry" : "entries"} to ${outPath}`
       )
@@ -22933,10 +23249,10 @@ netcap stopped \u2014 captured ${count8} ${count8 === 1 ? "entry" : "entries"} t
 // src/commands/netcap/netcapExtract.ts
 import { writeFileSync as writeFileSync33 } from "fs";
 import { join as join61 } from "path";
-import chalk171 from "chalk";
+import chalk173 from "chalk";
 
 // src/commands/netcap/extractPostsFromCapture.ts
-import { readFileSync as readFileSync40 } from "fs";
+import { readFileSync as readFileSync41 } from "fs";
 
 // src/commands/netcap/parseRscRows.ts
 var isRscRef = (v) => typeof v === "string" && /^\$[0-9a-fL@]/.test(v);
@@ -23332,7 +23648,7 @@ function extractVoyagerPosts(body) {
 
 // src/commands/netcap/extractPostsFromCapture.ts
 function captureEntries(captureFile) {
-  const lines2 = readFileSync40(captureFile, "utf8").split("\n").filter(Boolean);
+  const lines2 = readFileSync41(captureFile, "utf8").split("\n").filter(Boolean);
   const entries = [];
   for (const line of lines2) {
     let entry;
@@ -23381,8 +23697,8 @@ function netcapExtract(file) {
   writeFileSync33(outFile, `${JSON.stringify(posts, null, 2)}
 `);
   console.log(
-    chalk171.green(`extracted ${posts.length} posts`),
-    chalk171.dim(`-> ${outFile}`)
+    chalk173.green(`extracted ${posts.length} posts`),
+    chalk173.dim(`-> ${outFile}`)
   );
 }
 
@@ -23403,7 +23719,7 @@ function registerNetcap(program2) {
 }
 
 // src/commands/news/add/index.ts
-import chalk172 from "chalk";
+import chalk174 from "chalk";
 import enquirer8 from "enquirer";
 async function add2(url) {
   if (!url) {
@@ -23425,10 +23741,10 @@ async function add2(url) {
   const { orm } = await getReady();
   const added = await addFeed(orm, url);
   if (!added) {
-    console.log(chalk172.yellow("Feed already exists"));
+    console.log(chalk174.yellow("Feed already exists"));
     return;
   }
-  console.log(chalk172.green(`Added feed: ${url}`));
+  console.log(chalk174.green(`Added feed: ${url}`));
 }
 
 // src/commands/registerNews.ts
@@ -23475,7 +23791,7 @@ function registerPiHook(program2) {
 }
 
 // src/commands/prompts/printPromptsTable.ts
-import chalk173 from "chalk";
+import chalk175 from "chalk";
 function truncate(str, max) {
   if (str.length <= max) return str;
   return `${str.slice(0, max - 1)}\u2026`;
@@ -23493,14 +23809,14 @@ function printPromptsTable(rows) {
     "Command".padEnd(commandWidth),
     "Repos"
   ].join("  ");
-  console.log(chalk173.dim(header));
-  console.log(chalk173.dim("-".repeat(header.length)));
+  console.log(chalk175.dim(header));
+  console.log(chalk175.dim("-".repeat(header.length)));
   for (const row of rows) {
     const count8 = String(row.count).padStart(countWidth);
     const tool = row.tool.padEnd(toolWidth);
     const command = truncate(row.command, 60).padEnd(commandWidth);
     console.log(
-      `${chalk173.yellow(count8)}  ${tool}  ${command}  ${chalk173.dim(row.repos)}`
+      `${chalk175.yellow(count8)}  ${tool}  ${command}  ${chalk175.dim(row.repos)}`
     );
   }
 }
@@ -23906,7 +24222,7 @@ import { tmpdir as tmpdir6 } from "os";
 import { join as join63 } from "path";
 
 // src/commands/prs/loadCommentsCache.ts
-import { existsSync as existsSync54, readFileSync as readFileSync41, unlinkSync as unlinkSync13 } from "fs";
+import { existsSync as existsSync54, readFileSync as readFileSync42, unlinkSync as unlinkSync13 } from "fs";
 import { parse as parse2 } from "yaml";
 
 // src/commands/prs/commentsCachePath.ts
@@ -23929,7 +24245,7 @@ function loadCommentsCache(org, repo, prNumber) {
   if (!existsSync54(cachePath)) {
     return null;
   }
-  const content = readFileSync41(cachePath, "utf8");
+  const content = readFileSync42(cachePath, "utf8");
   return parse2(content);
 }
 function deleteCommentsCache(org, repo, prNumber) {
@@ -24121,7 +24437,7 @@ function fetchLineComments(org, repo, prNumber, threadInfo) {
 // src/commands/prs/listComments/updateCommentsCache.ts
 import { mkdirSync as mkdirSync19, writeFileSync as writeFileSync36 } from "fs";
 import { dirname as dirname29 } from "path";
-import { stringify } from "yaml";
+import { stringify as stringify2 } from "yaml";
 
 // src/commands/prs/removeStaleCommentsCaches.ts
 import { readdirSync as readdirSync12, unlinkSync as unlinkSync16 } from "fs";
@@ -24149,7 +24465,7 @@ function writeCommentsCache(org, repo, prNumber, comments3) {
     fetchedAt: (/* @__PURE__ */ new Date()).toISOString(),
     comments: comments3
   };
-  writeFileSync36(cachePath, stringify(cacheData));
+  writeFileSync36(cachePath, stringify2(cacheData));
 }
 function updateCommentsCache(org, repo, prNumber, comments3) {
   removeStaleCommentsCaches();
@@ -24167,13 +24483,13 @@ function agentFooter(unresolvedCount) {
 }
 
 // src/commands/prs/listComments/commentStyle.ts
-import chalk174 from "chalk";
+import chalk176 from "chalk";
 var plain = (text18) => text18;
 function colouredState(state) {
   const label2 = `[${state}]`;
-  if (state === "APPROVED") return chalk174.green(label2);
-  if (state === "CHANGES_REQUESTED") return chalk174.red(label2);
-  return chalk174.yellow(label2);
+  if (state === "APPROVED") return chalk176.green(label2);
+  if (state === "CHANGES_REQUESTED") return chalk176.red(label2);
+  return chalk176.yellow(label2);
 }
 function commentStyle() {
   if (isClaudeCode()) {
@@ -24187,9 +24503,9 @@ function commentStyle() {
     };
   }
   return {
-    cyan: chalk174.cyan,
-    bold: chalk174.bold,
-    dim: chalk174.dim,
+    cyan: chalk176.cyan,
+    bold: chalk176.bold,
+    dim: chalk176.dim,
     state: colouredState,
     diffHunk: true,
     agent: false
@@ -24359,13 +24675,13 @@ import { execSync as execSync48 } from "child_process";
 import enquirer9 from "enquirer";
 
 // src/commands/prs/prs/displayPaginated/printPr.ts
-import chalk175 from "chalk";
+import chalk177 from "chalk";
 var STATUS_MAP = {
-  MERGED: (pr) => pr.mergedAt ? { label: chalk175.magenta("merged"), date: pr.mergedAt } : null,
-  CLOSED: (pr) => pr.closedAt ? { label: chalk175.red("closed"), date: pr.closedAt } : null
+  MERGED: (pr) => pr.mergedAt ? { label: chalk177.magenta("merged"), date: pr.mergedAt } : null,
+  CLOSED: (pr) => pr.closedAt ? { label: chalk177.red("closed"), date: pr.closedAt } : null
 };
 function defaultStatus(pr) {
-  return { label: chalk175.green("opened"), date: pr.createdAt };
+  return { label: chalk177.green("opened"), date: pr.createdAt };
 }
 function getStatus2(pr) {
   return STATUS_MAP[pr.state]?.(pr) ?? defaultStatus(pr);
@@ -24374,11 +24690,11 @@ function formatDate(dateStr) {
   return new Date(dateStr).toISOString().split("T")[0];
 }
 function formatPrHeader(pr, status3) {
-  return `${chalk175.cyan(`#${pr.number}`)} ${pr.title} ${chalk175.dim(`(${pr.author.login},`)} ${status3.label} ${chalk175.dim(`${formatDate(status3.date)})`)}`;
+  return `${chalk177.cyan(`#${pr.number}`)} ${pr.title} ${chalk177.dim(`(${pr.author.login},`)} ${status3.label} ${chalk177.dim(`${formatDate(status3.date)})`)}`;
 }
 function logPrDetails(pr) {
   console.log(
-    chalk175.dim(`  ${pr.changedFiles.toLocaleString()} files | ${pr.url}`)
+    chalk177.dim(`  ${pr.changedFiles.toLocaleString()} files | ${pr.url}`)
   );
   console.log();
 }
@@ -25093,10 +25409,10 @@ function registerPrs(program2) {
 }
 
 // src/commands/ravendb/ravendbAuth.ts
-import chalk181 from "chalk";
+import chalk183 from "chalk";
 
 // src/shared/createConnectionAuth.ts
-import chalk176 from "chalk";
+import chalk178 from "chalk";
 function listConnections(connections, format) {
   if (connections.length === 0) {
     console.log("No connections configured.");
@@ -25109,7 +25425,7 @@ function listConnections(connections, format) {
 function removeConnection(connections, name, save) {
   const filtered = connections.filter((c) => c.name !== name);
   if (filtered.length === connections.length) {
-    console.error(chalk176.red(`Connection "${name}" not found.`));
+    console.error(chalk178.red(`Connection "${name}" not found.`));
     process.exit(1);
   }
   save(filtered);
@@ -25155,15 +25471,15 @@ function saveConnections(connections) {
 }
 
 // src/commands/ravendb/promptConnection.ts
-import chalk179 from "chalk";
+import chalk181 from "chalk";
 
 // src/commands/ravendb/selectOpSecret.ts
-import chalk178 from "chalk";
+import chalk180 from "chalk";
 import Enquirer2 from "enquirer";
 
 // src/commands/ravendb/searchItems.ts
 import { execSync as execSync51 } from "child_process";
-import chalk177 from "chalk";
+import chalk179 from "chalk";
 function opExec(args) {
   return execSync51(`op ${args}`, {
     encoding: "utf8",
@@ -25176,7 +25492,7 @@ function searchItems(search2) {
     items2 = JSON.parse(opExec("item list --format=json"));
   } catch {
     console.error(
-      chalk177.red(
+      chalk179.red(
         "Failed to search 1Password. Ensure the CLI is installed and you are signed in."
       )
     );
@@ -25190,7 +25506,7 @@ function getItemFields(itemId2) {
     const item = JSON.parse(opExec(`item get "${itemId2}" --format=json`));
     return item.fields.filter((f) => f.reference && f.label);
   } catch {
-    console.error(chalk177.red("Failed to get item details from 1Password."));
+    console.error(chalk179.red("Failed to get item details from 1Password."));
     process.exit(1);
   }
 }
@@ -25209,7 +25525,7 @@ async function selectOpSecret(searchTerm) {
   }).run();
   const items2 = searchItems(search2);
   if (items2.length === 0) {
-    console.error(chalk178.red(`No items found matching "${search2}".`));
+    console.error(chalk180.red(`No items found matching "${search2}".`));
     process.exit(1);
   }
   const itemId2 = await selectOne(
@@ -25218,7 +25534,7 @@ async function selectOpSecret(searchTerm) {
   );
   const fields = getItemFields(itemId2);
   if (fields.length === 0) {
-    console.error(chalk178.red("No fields with references found on this item."));
+    console.error(chalk180.red("No fields with references found on this item."));
     process.exit(1);
   }
   const ref = await selectOne(
@@ -25232,7 +25548,7 @@ async function selectOpSecret(searchTerm) {
 async function promptConnection(existingNames) {
   const name = await promptInput("name", "Connection name:");
   if (existingNames.includes(name)) {
-    console.error(chalk179.red(`Connection "${name}" already exists.`));
+    console.error(chalk181.red(`Connection "${name}" already exists.`));
     process.exit(1);
   }
   const url = await promptInput(
@@ -25241,22 +25557,22 @@ async function promptConnection(existingNames) {
   );
   const database = await promptInput("database", "Database name:");
   if (!name || !url || !database) {
-    console.error(chalk179.red("All fields are required."));
+    console.error(chalk181.red("All fields are required."));
     process.exit(1);
   }
   const apiKeyRef = await selectOpSecret();
-  console.log(chalk179.dim(`Using: ${apiKeyRef}`));
+  console.log(chalk181.dim(`Using: ${apiKeyRef}`));
   return { name, url, database, apiKeyRef };
 }
 
 // src/commands/ravendb/ravendbSetConnection.ts
-import chalk180 from "chalk";
+import chalk182 from "chalk";
 function ravendbSetConnection(name) {
   const raw = loadGlobalConfigRaw();
   const ravendb = raw.ravendb ?? {};
   const connections = ravendb.connections ?? [];
   if (!connections.some((c) => c.name === name)) {
-    console.error(chalk180.red(`Connection "${name}" not found.`));
+    console.error(chalk182.red(`Connection "${name}" not found.`));
     console.error(
       `Available: ${connections.map((c) => c.name).join(", ") || "(none)"}`
     );
@@ -25272,16 +25588,16 @@ function ravendbSetConnection(name) {
 var ravendbAuth = createConnectionAuth({
   load: loadConnections,
   save: saveConnections,
-  format: (c) => `${chalk181.bold(c.name)}  ${c.url}  db=${c.database}  key=${c.apiKeyRef}`,
+  format: (c) => `${chalk183.bold(c.name)}  ${c.url}  db=${c.database}  key=${c.apiKeyRef}`,
   promptNew: promptConnection,
   onFirst: (c) => ravendbSetConnection(c.name)
 });
 
 // src/commands/ravendb/ravendbCollections.ts
-import chalk185 from "chalk";
+import chalk187 from "chalk";
 
 // src/commands/ravendb/ravenFetch.ts
-import chalk183 from "chalk";
+import chalk185 from "chalk";
 
 // src/commands/ravendb/getAccessToken.ts
 var OAUTH_URL = "https://amazon-useast-1-oauth.ravenhq.com/ApiKeys/OAuth/AccessToken";
@@ -25318,10 +25634,10 @@ ${errorText}`
 
 // src/commands/ravendb/resolveOpSecret.ts
 import { execSync as execSync52 } from "child_process";
-import chalk182 from "chalk";
+import chalk184 from "chalk";
 function resolveOpSecret(reference) {
   if (!reference.startsWith("op://")) {
-    console.error(chalk182.red(`Invalid secret reference: must start with op://`));
+    console.error(chalk184.red(`Invalid secret reference: must start with op://`));
     process.exit(1);
   }
   try {
@@ -25331,7 +25647,7 @@ function resolveOpSecret(reference) {
     }).trim();
   } catch {
     console.error(
-      chalk182.red(
+      chalk184.red(
         "Failed to resolve secret reference. Ensure 1Password CLI is installed and you are signed in."
       )
     );
@@ -25358,7 +25674,7 @@ async function ravenFetch(connection, path80) {
   if (!response.ok) {
     const body = await response.text();
     console.error(
-      chalk183.red(`RavenDB error: ${response.status} ${response.statusText}`)
+      chalk185.red(`RavenDB error: ${response.status} ${response.statusText}`)
     );
     console.error(body.substring(0, 500));
     process.exit(1);
@@ -25367,7 +25683,7 @@ async function ravenFetch(connection, path80) {
 }
 
 // src/commands/ravendb/resolveConnection.ts
-import chalk184 from "chalk";
+import chalk186 from "chalk";
 function loadRavendb() {
   const raw = loadGlobalConfigRaw();
   const ravendb = raw.ravendb;
@@ -25381,7 +25697,7 @@ function resolveConnection(name) {
   const connectionName = name ?? defaultConnection;
   if (!connectionName) {
     console.error(
-      chalk184.red(
+      chalk186.red(
         "No connection specified and no default set. Use assist ravendb set-connection <name> or pass a connection name."
       )
     );
@@ -25389,7 +25705,7 @@ function resolveConnection(name) {
   }
   const connection = connections.find((c) => c.name === connectionName);
   if (!connection) {
-    console.error(chalk184.red(`Connection "${connectionName}" not found.`));
+    console.error(chalk186.red(`Connection "${connectionName}" not found.`));
     console.error(
       `Available: ${connections.map((c) => c.name).join(", ") || "(none)"}`
     );
@@ -25420,15 +25736,15 @@ async function ravendbCollections(connectionName) {
     return;
   }
   for (const c of collections) {
-    console.log(`${chalk185.bold(c.Name)}  ${c.CountOfDocuments} docs`);
+    console.log(`${chalk187.bold(c.Name)}  ${c.CountOfDocuments} docs`);
   }
 }
 
 // src/commands/ravendb/ravendbQuery.ts
-import chalk187 from "chalk";
+import chalk189 from "chalk";
 
 // src/commands/ravendb/fetchAllPages.ts
-import chalk186 from "chalk";
+import chalk188 from "chalk";
 
 // src/commands/ravendb/buildQueryPath.ts
 function buildQueryPath(opts) {
@@ -25466,7 +25782,7 @@ async function fetchAllPages(connection, opts) {
     allResults.push(...results);
     start3 += results.length;
     process.stderr.write(
-      `\r${chalk186.dim(`Fetched ${allResults.length}/${totalResults}`)}`
+      `\r${chalk188.dim(`Fetched ${allResults.length}/${totalResults}`)}`
     );
     if (start3 >= totalResults) break;
     if (opts.limit !== void 0 && allResults.length >= opts.limit) break;
@@ -25481,7 +25797,7 @@ async function fetchAllPages(connection, opts) {
 async function ravendbQuery(connectionName, collection, options2) {
   const resolved = resolveArgs(connectionName, collection);
   if (!resolved.collection && !options2.query) {
-    console.error(chalk187.red("Provide a collection name or --query filter."));
+    console.error(chalk189.red("Provide a collection name or --query filter."));
     process.exit(1);
   }
   const { collection: col } = resolved;
@@ -25520,7 +25836,7 @@ import { spawn as spawn6 } from "child_process";
 import * as path42 from "path";
 
 // src/commands/refactor/logViolations.ts
-import chalk188 from "chalk";
+import chalk190 from "chalk";
 var DEFAULT_MAX_LINES2 = 100;
 function logViolations(violations, maxLines = DEFAULT_MAX_LINES2) {
   if (violations.length === 0) {
@@ -25529,43 +25845,43 @@ function logViolations(violations, maxLines = DEFAULT_MAX_LINES2) {
     }
     return;
   }
-  console.error(chalk188.red(`
+  console.error(chalk190.red(`
 Refactor check failed:
 `));
-  console.error(chalk188.red(`  The following files exceed ${maxLines} lines:
+  console.error(chalk190.red(`  The following files exceed ${maxLines} lines:
 `));
   for (const violation of violations) {
-    console.error(chalk188.red(`  ${violation.file} (${violation.lines} lines)`));
+    console.error(chalk190.red(`  ${violation.file} (${violation.lines} lines)`));
   }
   console.error(
-    chalk188.yellow(
+    chalk190.yellow(
       `
   Each file needs to be sensibly refactored, or if there is no sensible
   way to refactor it, ignore it with:
 `
     )
   );
-  console.error(chalk188.gray(`    assist refactor ignore <file>
+  console.error(chalk190.gray(`    assist refactor ignore <file>
 `));
   if (process.env.CLAUDECODE) {
-    console.error(chalk188.cyan(`
+    console.error(chalk190.cyan(`
   ## Extracting Code to New Files
 `));
     console.error(
-      chalk188.cyan(
+      chalk190.cyan(
         `  When extracting logic from one file to another, consider where the extracted code belongs:
 `
       )
     );
     console.error(
-      chalk188.cyan(
+      chalk190.cyan(
         `  1. Keep related logic together: If the extracted code is tightly coupled to the
      original file's domain, create a new folder containing both the original and extracted files.
 `
       )
     );
     console.error(
-      chalk188.cyan(
+      chalk190.cyan(
         `  2. Share common utilities: If the extracted code can be reused across multiple
      domains, move it to a common/shared folder.
 `
@@ -25721,7 +26037,7 @@ async function check(pattern2, options2) {
 
 // src/commands/refactor/extract/index.ts
 import path50 from "path";
-import chalk191 from "chalk";
+import chalk193 from "chalk";
 
 // src/commands/refactor/extract/applyExtraction.ts
 import { SyntaxKind as SyntaxKind4 } from "ts-morph";
@@ -26320,23 +26636,23 @@ function buildPlan2(functionName, sourceFile, sourcePath, destPath, project) {
 
 // src/commands/refactor/extract/displayPlan.ts
 import path46 from "path";
-import chalk189 from "chalk";
+import chalk191 from "chalk";
 function section2(title) {
   return `
-  ${chalk189.cyan(title)}`;
+  ${chalk191.cyan(title)}`;
 }
 function displayImporters(plan2, cwd) {
   if (plan2.importersToUpdate.length === 0) return;
   console.log(section2("Update importers:"));
   for (const imp of plan2.importersToUpdate) {
     const rel = path46.relative(cwd, imp.file.getFilePath());
-    console.log(`    ${chalk189.dim(rel)}: \u2192 import from "${imp.relPath}"`);
+    console.log(`    ${chalk191.dim(rel)}: \u2192 import from "${imp.relPath}"`);
   }
 }
 function displayPlan(functionName, relDest, plan2, cwd) {
-  console.log(chalk189.bold(`Extract: ${functionName} \u2192 ${relDest}
+  console.log(chalk191.bold(`Extract: ${functionName} \u2192 ${relDest}
 `));
-  console.log(`  ${chalk189.cyan("Functions to move:")}`);
+  console.log(`  ${chalk191.cyan("Functions to move:")}`);
   for (const name of plan2.extractedNames) {
     console.log(`    ${name}`);
   }
@@ -26370,7 +26686,7 @@ function displayPlan(functionName, relDest, plan2, cwd) {
 
 // src/commands/refactor/extract/loadProjectFile.ts
 import path49 from "path";
-import chalk190 from "chalk";
+import chalk192 from "chalk";
 import { Project as Project4 } from "ts-morph";
 
 // src/commands/refactor/extract/findTsConfig.ts
@@ -26462,7 +26778,7 @@ function loadProjectFile(file) {
   });
   const sourceFile = project.getSourceFile(sourcePath);
   if (!sourceFile) {
-    console.log(chalk190.red(`File not found in project: ${file}`));
+    console.log(chalk192.red(`File not found in project: ${file}`));
     process.exit(1);
   }
   return { project, sourceFile };
@@ -26485,19 +26801,19 @@ async function extract(file, functionName, destination, options2 = {}) {
   displayPlan(functionName, relDest, plan2, cwd);
   if (options2.apply) {
     await applyExtraction(functionName, sourceFile, destPath, plan2, project);
-    console.log(chalk191.green("\nExtraction complete"));
+    console.log(chalk193.green("\nExtraction complete"));
   } else {
-    console.log(chalk191.dim("\nDry run. Use --apply to execute."));
+    console.log(chalk193.dim("\nDry run. Use --apply to execute."));
   }
 }
 
 // src/commands/refactor/ignore.ts
 import fs33 from "fs";
-import chalk192 from "chalk";
+import chalk194 from "chalk";
 var REFACTOR_YML_PATH2 = "refactor.yml";
 function ignore2(file) {
   if (!fs33.existsSync(file)) {
-    console.error(chalk192.red(`Error: File does not exist: ${file}`));
+    console.error(chalk194.red(`Error: File does not exist: ${file}`));
     process.exit(1);
   }
   const content = fs33.readFileSync(file, "utf8");
@@ -26513,7 +26829,7 @@ function ignore2(file) {
     fs33.writeFileSync(REFACTOR_YML_PATH2, entry);
   }
   console.log(
-    chalk192.green(
+    chalk194.green(
       `Added ${file} to refactor ignore list (max ${maxLines} lines)`
     )
   );
@@ -26522,12 +26838,12 @@ function ignore2(file) {
 // src/commands/refactor/rename/index.ts
 import fs36 from "fs";
 import path55 from "path";
-import chalk195 from "chalk";
+import chalk197 from "chalk";
 
 // src/commands/refactor/rename/applyRename.ts
 import fs35 from "fs";
 import path52 from "path";
-import chalk193 from "chalk";
+import chalk195 from "chalk";
 
 // src/commands/refactor/restructure/computeRewrites/index.ts
 import path51 from "path";
@@ -26632,13 +26948,13 @@ function applyRename(rewrites, sourcePath, destPath, cwd) {
   const updatedContents = applyRewrites(rewrites);
   for (const [file, content] of updatedContents) {
     fs35.writeFileSync(file, content, "utf8");
-    console.log(chalk193.cyan(`  Updated imports in ${path52.relative(cwd, file)}`));
+    console.log(chalk195.cyan(`  Updated imports in ${path52.relative(cwd, file)}`));
   }
   const destDir = path52.dirname(destPath);
   if (!fs35.existsSync(destDir)) fs35.mkdirSync(destDir, { recursive: true });
   fs35.renameSync(sourcePath, destPath);
   console.log(
-    chalk193.white(
+    chalk195.white(
       `  Moved ${path52.relative(cwd, sourcePath)} \u2192 ${path52.relative(cwd, destPath)}`
     )
   );
@@ -26725,16 +27041,16 @@ function computeRenameRewrites(sourcePath, destPath) {
 
 // src/commands/refactor/rename/printRenamePreview.ts
 import path54 from "path";
-import chalk194 from "chalk";
+import chalk196 from "chalk";
 function printRenamePreview(rewrites, cwd) {
   for (const rewrite of rewrites) {
     console.log(
-      chalk194.dim(
+      chalk196.dim(
         `  ${path54.relative(cwd, rewrite.file)}: ${rewrite.oldSpecifier} \u2192 ${rewrite.newSpecifier}`
       )
     );
   }
-  console.log(chalk194.dim("Dry run. Use --apply to execute."));
+  console.log(chalk196.dim("Dry run. Use --apply to execute."));
 }
 
 // src/commands/refactor/rename/index.ts
@@ -26745,20 +27061,20 @@ async function rename(source, destination, options2 = {}) {
   const relSource = path55.relative(cwd, sourcePath);
   const relDest = path55.relative(cwd, destPath);
   if (!fs36.existsSync(sourcePath)) {
-    console.log(chalk195.red(`File not found: ${source}`));
+    console.log(chalk197.red(`File not found: ${source}`));
     process.exit(1);
   }
   if (destPath !== sourcePath && fs36.existsSync(destPath)) {
-    console.log(chalk195.red(`Destination already exists: ${destination}`));
+    console.log(chalk197.red(`Destination already exists: ${destination}`));
     process.exit(1);
   }
-  console.log(chalk195.bold(`Rename: ${relSource} \u2192 ${relDest}`));
-  console.log(chalk195.dim("Loading project..."));
-  console.log(chalk195.dim("Scanning imports across the project..."));
+  console.log(chalk197.bold(`Rename: ${relSource} \u2192 ${relDest}`));
+  console.log(chalk197.dim("Loading project..."));
+  console.log(chalk197.dim("Scanning imports across the project..."));
   const rewrites = computeRenameRewrites(sourcePath, destPath);
   const affectedFiles = new Set(rewrites.map((r) => r.file)).size;
   console.log(
-    chalk195.dim(
+    chalk197.dim(
       `${rewrites.length} import path(s) to update across ${affectedFiles} file(s)`
     )
   );
@@ -26767,11 +27083,11 @@ async function rename(source, destination, options2 = {}) {
     return;
   }
   applyRename(rewrites, sourcePath, destPath, cwd);
-  console.log(chalk195.green("Done"));
+  console.log(chalk197.green("Done"));
 }
 
 // src/commands/refactor/renameSymbol/index.ts
-import chalk196 from "chalk";
+import chalk198 from "chalk";
 
 // src/commands/refactor/renameSymbol/findSymbol.ts
 import { SyntaxKind as SyntaxKind15 } from "ts-morph";
@@ -26817,33 +27133,33 @@ async function renameSymbol(file, oldName, newName, options2 = {}) {
   const { project, sourceFile } = loadProjectFile(file);
   const symbol = findSymbol(sourceFile, oldName);
   if (!symbol) {
-    console.log(chalk196.red(`Symbol "${oldName}" not found in ${file}`));
+    console.log(chalk198.red(`Symbol "${oldName}" not found in ${file}`));
     process.exit(1);
   }
   const grouped = groupReferences(symbol, cwd);
   const totalRefs = [...grouped.values()].reduce((s, l) => s + l.length, 0);
   console.log(
-    chalk196.bold(`Rename: ${oldName} \u2192 ${newName} (${totalRefs} references)
+    chalk198.bold(`Rename: ${oldName} \u2192 ${newName} (${totalRefs} references)
 `)
   );
   for (const [refFile, lines2] of grouped) {
     console.log(
-      `  ${chalk196.dim(refFile)}: lines ${chalk196.cyan(lines2.join(", "))}`
+      `  ${chalk198.dim(refFile)}: lines ${chalk198.cyan(lines2.join(", "))}`
     );
   }
   if (options2.apply) {
     symbol.rename(newName);
     await project.save();
-    console.log(chalk196.green(`
+    console.log(chalk198.green(`
 Renamed ${oldName} \u2192 ${newName}`));
   } else {
-    console.log(chalk196.dim("\nDry run. Use --apply to execute."));
+    console.log(chalk198.dim("\nDry run. Use --apply to execute."));
   }
 }
 
 // src/commands/refactor/restructure/index.ts
 import path63 from "path";
-import chalk199 from "chalk";
+import chalk201 from "chalk";
 
 // src/commands/refactor/restructure/clusterDirectories.ts
 import path57 from "path";
@@ -26922,50 +27238,50 @@ function clusterFiles(graph) {
 
 // src/commands/refactor/restructure/displayPlan.ts
 import path59 from "path";
-import chalk197 from "chalk";
+import chalk199 from "chalk";
 function relPath(filePath) {
   return path59.relative(process.cwd(), filePath);
 }
 function displayMoves(plan2) {
   if (plan2.moves.length === 0) return;
-  console.log(chalk197.bold("\nFile moves:"));
+  console.log(chalk199.bold("\nFile moves:"));
   for (const move2 of plan2.moves) {
     console.log(
-      `  ${chalk197.red(relPath(move2.from))} \u2192 ${chalk197.green(relPath(move2.to))}`
+      `  ${chalk199.red(relPath(move2.from))} \u2192 ${chalk199.green(relPath(move2.to))}`
     );
-    console.log(chalk197.dim(`    ${move2.reason}`));
+    console.log(chalk199.dim(`    ${move2.reason}`));
   }
 }
 function displayRewrites(rewrites) {
   if (rewrites.length === 0) return;
   const affectedFiles = new Set(rewrites.map((r) => r.file));
-  console.log(chalk197.bold(`
+  console.log(chalk199.bold(`
 Import rewrites (${affectedFiles.size} files):`));
   for (const file of affectedFiles) {
-    console.log(`  ${chalk197.cyan(relPath(file))}:`);
+    console.log(`  ${chalk199.cyan(relPath(file))}:`);
     for (const { oldSpecifier, newSpecifier } of rewrites.filter(
       (r) => r.file === file
     )) {
       console.log(
-        `    ${chalk197.red(`"${oldSpecifier}"`)} \u2192 ${chalk197.green(`"${newSpecifier}"`)}`
+        `    ${chalk199.red(`"${oldSpecifier}"`)} \u2192 ${chalk199.green(`"${newSpecifier}"`)}`
       );
     }
   }
 }
 function displayPlan2(plan2) {
   if (plan2.warnings.length > 0) {
-    console.log(chalk197.yellow("\nWarnings:"));
-    for (const w of plan2.warnings) console.log(chalk197.yellow(`  ${w}`));
+    console.log(chalk199.yellow("\nWarnings:"));
+    for (const w of plan2.warnings) console.log(chalk199.yellow(`  ${w}`));
   }
   if (plan2.newDirectories.length > 0) {
-    console.log(chalk197.bold("\nNew directories:"));
+    console.log(chalk199.bold("\nNew directories:"));
     for (const dir of plan2.newDirectories)
-      console.log(chalk197.green(`  ${dir}/`));
+      console.log(chalk199.green(`  ${dir}/`));
   }
   displayMoves(plan2);
   displayRewrites(plan2.rewrites);
   console.log(
-    chalk197.dim(
+    chalk199.dim(
       `
 Summary: ${plan2.moves.length} file(s) moved, ${plan2.rewrites.length} imports rewritten`
     )
@@ -26975,18 +27291,18 @@ Summary: ${plan2.moves.length} file(s) moved, ${plan2.rewrites.length} imports r
 // src/commands/refactor/restructure/executePlan.ts
 import fs37 from "fs";
 import path60 from "path";
-import chalk198 from "chalk";
+import chalk200 from "chalk";
 function executePlan(plan2) {
   const updatedContents = applyRewrites(plan2.rewrites);
   for (const [file, content] of updatedContents) {
     fs37.writeFileSync(file, content, "utf8");
     console.log(
-      chalk198.cyan(`  Rewrote imports in ${path60.relative(process.cwd(), file)}`)
+      chalk200.cyan(`  Rewrote imports in ${path60.relative(process.cwd(), file)}`)
     );
   }
   for (const dir of plan2.newDirectories) {
     fs37.mkdirSync(dir, { recursive: true });
-    console.log(chalk198.green(`  Created ${path60.relative(process.cwd(), dir)}/`));
+    console.log(chalk200.green(`  Created ${path60.relative(process.cwd(), dir)}/`));
   }
   for (const move2 of plan2.moves) {
     const targetDir = path60.dirname(move2.to);
@@ -26995,7 +27311,7 @@ function executePlan(plan2) {
     }
     fs37.renameSync(move2.from, move2.to);
     console.log(
-      chalk198.white(
+      chalk200.white(
         `  Moved ${path60.relative(process.cwd(), move2.from)} \u2192 ${path60.relative(process.cwd(), move2.to)}`
       )
     );
@@ -27010,7 +27326,7 @@ function removeEmptyDirectories(dirs) {
     if (entries.length === 0) {
       fs37.rmdirSync(dir);
       console.log(
-        chalk198.dim(
+        chalk200.dim(
           `  Removed empty directory ${path60.relative(process.cwd(), dir)}`
         )
       );
@@ -27143,22 +27459,22 @@ async function restructure(pattern2, options2 = {}) {
   const targetPattern = pattern2 ?? "src";
   const files = findSourceFiles2(targetPattern);
   if (files.length === 0) {
-    console.log(chalk199.yellow("No files found matching pattern"));
+    console.log(chalk201.yellow("No files found matching pattern"));
     return;
   }
   const tsConfigPath = findTsConfig(path63.resolve(files[0]));
   const plan2 = buildPlan3(files, tsConfigPath);
   if (plan2.moves.length === 0) {
-    console.log(chalk199.green("No restructuring needed"));
+    console.log(chalk201.green("No restructuring needed"));
     return;
   }
   displayPlan2(plan2);
   if (options2.apply) {
-    console.log(chalk199.bold("\nApplying changes..."));
+    console.log(chalk201.bold("\nApplying changes..."));
     executePlan(plan2);
-    console.log(chalk199.green("\nRestructuring complete"));
+    console.log(chalk201.green("\nRestructuring complete"));
   } else {
-    console.log(chalk199.dim("\nDry run. Use --apply to execute."));
+    console.log(chalk201.dim("\nDry run. Use --apply to execute."));
   }
 }
 
@@ -27481,7 +27797,7 @@ function gatherContext() {
 }
 
 // src/commands/review/postReviewToPr.ts
-import { readFileSync as readFileSync42 } from "fs";
+import { readFileSync as readFileSync43 } from "fs";
 
 // src/commands/review/carriedUnanchoredFindings.ts
 function carriedUnanchoredFindings(unanchored) {
@@ -27685,15 +28001,15 @@ function runReviewSubmission(mutation, body) {
 }
 
 // src/commands/review/submitBodyOnlyReview.ts
-var MUTATION = `mutation($prId: ID!, $body: String) { addPullRequestReview(input: { pullRequestId: $prId, event: COMMENT, body: $body }) { pullRequestReview { id } } }`;
+var MUTATION3 = `mutation($prId: ID!, $body: String) { addPullRequestReview(input: { pullRequestId: $prId, event: COMMENT, body: $body }) { pullRequestReview { id } } }`;
 function submitBodyOnlyReview(body) {
-  runReviewSubmission(MUTATION, body);
+  runReviewSubmission(MUTATION3, body);
 }
 
 // src/commands/review/submitPendingReview.ts
-var MUTATION2 = `mutation($prId: ID!, $body: String) { submitPullRequestReview(input: { pullRequestId: $prId, event: COMMENT, body: $body }) { pullRequestReview { id } } }`;
+var MUTATION4 = `mutation($prId: ID!, $body: String) { submitPullRequestReview(input: { pullRequestId: $prId, event: COMMENT, body: $body }) { pullRequestReview { id } } }`;
 function submitPendingReview(body) {
-  runReviewSubmission(MUTATION2, body);
+  runReviewSubmission(MUTATION4, body);
 }
 
 // src/commands/review/postAndMaybeSubmit.ts
@@ -27816,18 +28132,18 @@ function partitionFindingsByDiff(findings, index3) {
 }
 
 // src/commands/review/warnOutOfDiff.ts
-import chalk200 from "chalk";
+import chalk202 from "chalk";
 function warnOutOfDiff(outOfDiff) {
   if (outOfDiff.length === 0) return;
   console.warn(
-    chalk200.yellow(
+    chalk202.yellow(
       `Moved ${outOfDiff.length} finding(s) whose lines fall outside the PR diff into the review body (GitHub cannot anchor a comment on these):`
     )
   );
   for (const finding of outOfDiff) {
     const range = finding.startLine !== void 0 ? `${finding.startLine}-${finding.line}` : `${finding.line}`;
     console.warn(
-      `  ${chalk200.yellow("\xB7")} ${finding.title} ${chalk200.dim(
+      `  ${chalk202.yellow("\xB7")} ${finding.title} ${chalk202.dim(
         `(${finding.file}:${range})`
       )}`
     );
@@ -27851,18 +28167,18 @@ function selectInDiffFindings(lineBound, prDiff) {
 }
 
 // src/commands/review/warnUnlocated.ts
-import chalk201 from "chalk";
+import chalk203 from "chalk";
 function warnUnlocated(unlocated) {
   if (unlocated.length === 0) return;
   console.warn(
-    chalk201.yellow(
+    chalk203.yellow(
       `Moved ${unlocated.length} finding(s) without a parseable file:line into the review body:`
     )
   );
   for (const finding of unlocated) {
-    const where = finding.location || chalk201.dim("missing");
+    const where = finding.location || chalk203.dim("missing");
     console.warn(
-      `  ${chalk201.yellow("\xB7")} ${finding.title} ${chalk201.dim(`(${where})`)}`
+      `  ${chalk203.yellow("\xB7")} ${finding.title} ${chalk203.dim(`(${where})`)}`
     );
   }
 }
@@ -27929,7 +28245,7 @@ async function confirmPost(prNumber, work, options2) {
   return promptConfirm(`Post ${work} to PR #${prNumber}?`, false);
 }
 async function postFindingsToPr(prInfo, synthesisPath, options2) {
-  const markdown = readFileSync42(synthesisPath, "utf8");
+  const markdown = readFileSync43(synthesisPath, "utf8");
   const { inDiff, unanchored } = selectPostableFindings(markdown, prInfo);
   const carried = carriedUnanchoredFindings(unanchored);
   if (inDiff.length === 0 && carried.length === 0) return NOTHING_POSTED;
@@ -28818,7 +29134,7 @@ async function runReviewers(reviewDir, claudePath, codexPath, stdinPrompt, optio
 }
 
 // src/commands/review/synthesise.ts
-import { readFileSync as readFileSync43 } from "fs";
+import { readFileSync as readFileSync44 } from "fs";
 
 // src/commands/review/buildSynthesisStdin.ts
 var SYNTHESIS_PROMPT = `You are consolidating two independent code reviews of the same change. The original review request is in request.md. The two reviews are in claude.md and codex.md in the current working directory.
@@ -28883,7 +29199,7 @@ Files:
 
 // src/commands/review/synthesise.ts
 function printSummary2(synthesisPath) {
-  const markdown = readFileSync43(synthesisPath, "utf8");
+  const markdown = readFileSync44(synthesisPath, "utf8");
   console.log("");
   console.log(buildReviewSummary(markdown));
   console.log("");
@@ -29117,7 +29433,7 @@ function registerReview(program2) {
 }
 
 // src/commands/seq/seqAuth.ts
-import chalk203 from "chalk";
+import chalk205 from "chalk";
 
 // src/commands/seq/loadConnections.ts
 function loadConnections2() {
@@ -29146,10 +29462,10 @@ function setDefaultConnection(name) {
 }
 
 // src/shared/assertUniqueName.ts
-import chalk202 from "chalk";
+import chalk204 from "chalk";
 function assertUniqueName(existingNames, name) {
   if (existingNames.includes(name)) {
-    console.error(chalk202.red(`Connection "${name}" already exists.`));
+    console.error(chalk204.red(`Connection "${name}" already exists.`));
     process.exit(1);
   }
 }
@@ -29167,16 +29483,16 @@ async function promptConnection2(existingNames) {
 var seqAuth = createConnectionAuth({
   load: loadConnections2,
   save: saveConnections2,
-  format: (c) => `${chalk203.bold(c.name)}  ${c.url}`,
+  format: (c) => `${chalk205.bold(c.name)}  ${c.url}`,
   promptNew: promptConnection2,
   onFirst: (c) => setDefaultConnection(c.name)
 });
 
 // src/commands/seq/seqQuery.ts
-import chalk207 from "chalk";
+import chalk209 from "chalk";
 
 // src/commands/seq/fetchSeq.ts
-import chalk204 from "chalk";
+import chalk206 from "chalk";
 async function fetchSeq(conn, path80, params) {
   const url = `${conn.url}${path80}?${params}`;
   const response = await fetch(url, {
@@ -29187,7 +29503,7 @@ async function fetchSeq(conn, path80, params) {
   });
   if (!response.ok) {
     const body = await response.text();
-    console.error(chalk204.red(`Seq returned ${response.status}: ${body}`));
+    console.error(chalk206.red(`Seq returned ${response.status}: ${body}`));
     process.exit(1);
   }
   return response;
@@ -29246,23 +29562,23 @@ async function fetchSeqEvents(conn, params) {
 }
 
 // src/commands/seq/formatEvent.ts
-import chalk205 from "chalk";
+import chalk207 from "chalk";
 function levelColor(level) {
   switch (level) {
     case "Fatal":
-      return chalk205.bgRed.white;
+      return chalk207.bgRed.white;
     case "Error":
-      return chalk205.red;
+      return chalk207.red;
     case "Warning":
-      return chalk205.yellow;
+      return chalk207.yellow;
     case "Information":
-      return chalk205.cyan;
+      return chalk207.cyan;
     case "Debug":
-      return chalk205.gray;
+      return chalk207.gray;
     case "Verbose":
-      return chalk205.dim;
+      return chalk207.dim;
     default:
-      return chalk205.white;
+      return chalk207.white;
   }
 }
 function levelAbbrev(level) {
@@ -29303,12 +29619,12 @@ function formatTimestamp(iso) {
 function formatEvent(event) {
   const color = levelColor(event.Level);
   const abbrev = levelAbbrev(event.Level);
-  const ts8 = chalk205.dim(formatTimestamp(event.Timestamp));
+  const ts8 = chalk207.dim(formatTimestamp(event.Timestamp));
   const msg = renderMessage(event);
   const lines2 = [`${ts8} ${color(`[${abbrev}]`)} ${msg}`];
   if (event.Exception) {
     for (const line of event.Exception.split("\n")) {
-      lines2.push(chalk205.red(`  ${line}`));
+      lines2.push(chalk207.red(`  ${line}`));
     }
   }
   return lines2.join("\n");
@@ -29341,11 +29657,11 @@ function rejectTimestampFilter(filter) {
 }
 
 // src/shared/resolveNamedConnection.ts
-import chalk206 from "chalk";
+import chalk208 from "chalk";
 function resolveNamedConnection(connections, requested, defaultName, kind, authCommand) {
   if (connections.length === 0) {
     console.error(
-      chalk206.red(
+      chalk208.red(
         `No ${kind} connections configured. Run '${authCommand}' first.`
       )
     );
@@ -29354,7 +29670,7 @@ function resolveNamedConnection(connections, requested, defaultName, kind, authC
   const target = requested ?? defaultName ?? connections[0].name;
   const connection = connections.find((c) => c.name === target);
   if (!connection) {
-    console.error(chalk206.red(`${kind} connection "${target}" not found.`));
+    console.error(chalk208.red(`${kind} connection "${target}" not found.`));
     process.exit(1);
   }
   return connection;
@@ -29383,7 +29699,7 @@ async function seqQuery(filter, options2) {
     new URLSearchParams({ filter, count: String(count8) })
   );
   if (events.length === 0) {
-    console.log(chalk207.yellow("No events found."));
+    console.log(chalk209.yellow("No events found."));
     return;
   }
   if (options2.json) {
@@ -29394,11 +29710,11 @@ async function seqQuery(filter, options2) {
   for (const event of chronological) {
     console.log(formatEvent(event));
   }
-  console.log(chalk207.dim(`
+  console.log(chalk209.dim(`
 ${events.length} events`));
   if (events.length >= count8) {
     console.log(
-      chalk207.yellow(
+      chalk209.yellow(
         `Results limited to ${count8}. Use --count to retrieve more.`
       )
     );
@@ -29406,10 +29722,10 @@ ${events.length} events`));
 }
 
 // src/shared/setNamedDefaultConnection.ts
-import chalk208 from "chalk";
+import chalk210 from "chalk";
 function setNamedDefaultConnection(connections, name, setDefault, kind) {
   if (!connections.find((c) => c.name === name)) {
-    console.error(chalk208.red(`Connection "${name}" not found.`));
+    console.error(chalk210.red(`Connection "${name}" not found.`));
     process.exit(1);
   }
   setDefault(name);
@@ -29458,7 +29774,7 @@ function registerSignal(program2) {
 }
 
 // src/commands/sql/sqlAuth.ts
-import chalk210 from "chalk";
+import chalk212 from "chalk";
 
 // src/commands/sql/loadConnections.ts
 function loadConnections3() {
@@ -29487,7 +29803,7 @@ function setDefaultConnection2(name) {
 }
 
 // src/commands/sql/promptConnection.ts
-import chalk209 from "chalk";
+import chalk211 from "chalk";
 async function promptConnection3(existingNames) {
   const name = await promptInput("name", "Connection name:", "default");
   assertUniqueName(existingNames, name);
@@ -29495,7 +29811,7 @@ async function promptConnection3(existingNames) {
   const portStr = await promptInput("port", "Port:", "1433");
   const port = Number.parseInt(portStr, 10);
   if (!Number.isFinite(port)) {
-    console.error(chalk209.red(`Invalid port "${portStr}".`));
+    console.error(chalk211.red(`Invalid port "${portStr}".`));
     process.exit(1);
   }
   const user = await promptInput("user", "User:");
@@ -29508,13 +29824,13 @@ async function promptConnection3(existingNames) {
 var sqlAuth = createConnectionAuth({
   load: loadConnections3,
   save: saveConnections3,
-  format: (c) => `${chalk210.bold(c.name)}  ${c.server}:${c.port}/${c.database} (${c.user})`,
+  format: (c) => `${chalk212.bold(c.name)}  ${c.server}:${c.port}/${c.database} (${c.user})`,
   promptNew: promptConnection3,
   onFirst: (c) => setDefaultConnection2(c.name)
 });
 
 // src/commands/sql/printTable.ts
-import chalk211 from "chalk";
+import chalk213 from "chalk";
 function formatCell(value) {
   if (value === null || value === void 0) return "";
   if (value instanceof Date) return value.toISOString();
@@ -29523,7 +29839,7 @@ function formatCell(value) {
 }
 function printTable(rows) {
   if (rows.length === 0) {
-    console.log(chalk211.yellow("(no rows)"));
+    console.log(chalk213.yellow("(no rows)"));
     return;
   }
   const columns = Object.keys(rows[0]);
@@ -29531,13 +29847,13 @@ function printTable(rows) {
     (col) => Math.max(col.length, ...rows.map((r) => formatCell(r[col]).length))
   );
   const header = columns.map((c, i) => c.padEnd(widths[i])).join("  ");
-  console.log(chalk211.dim(header));
-  console.log(chalk211.dim("-".repeat(header.length)));
+  console.log(chalk213.dim(header));
+  console.log(chalk213.dim("-".repeat(header.length)));
   for (const row of rows) {
     const line = columns.map((c, i) => formatCell(row[c]).padEnd(widths[i])).join("  ");
     console.log(line);
   }
-  console.log(chalk211.dim(`
+  console.log(chalk213.dim(`
 ${rows.length} row${rows.length === 1 ? "" : "s"}`));
 }
 
@@ -29597,7 +29913,7 @@ async function sqlColumns(table, connectionName) {
 }
 
 // src/commands/sql/sqlMutate.ts
-import chalk212 from "chalk";
+import chalk214 from "chalk";
 
 // src/commands/sql/isMutation.ts
 var MUTATION_KEYWORDS = [
@@ -29631,7 +29947,7 @@ function isMutation(sql25) {
 async function sqlMutate(query, connectionName) {
   if (!isMutation(query)) {
     console.error(
-      chalk212.red(
+      chalk214.red(
         "assist sql mutate refuses non-mutating statements. Use `assist sql query` instead."
       )
     );
@@ -29641,18 +29957,18 @@ async function sqlMutate(query, connectionName) {
   const pool = await sqlConnect(conn);
   try {
     const result = await pool.request().query(query);
-    console.log(chalk212.dim(`${result.rowsAffected.join(", ")} row(s) affected`));
+    console.log(chalk214.dim(`${result.rowsAffected.join(", ")} row(s) affected`));
   } finally {
     await pool.close();
   }
 }
 
 // src/commands/sql/sqlQuery.ts
-import chalk213 from "chalk";
+import chalk215 from "chalk";
 async function sqlQuery(query, connectionName) {
   if (isMutation(query)) {
     console.error(
-      chalk213.red(
+      chalk215.red(
         "assist sql query refuses mutating statements. Use `assist sql mutate` instead."
       )
     );
@@ -29667,7 +29983,7 @@ async function sqlQuery(query, connectionName) {
       printTable(rows);
     } else {
       console.log(
-        chalk213.dim(`${result.rowsAffected.join(", ")} row(s) affected`)
+        chalk215.dim(`${result.rowsAffected.join(", ")} row(s) affected`)
       );
     }
   } finally {
@@ -29812,7 +30128,7 @@ function reportPrune(label2, result, force) {
 // src/commands/sync/syncClaudeMd.ts
 import * as fs41 from "fs";
 import * as path66 from "path";
-import chalk214 from "chalk";
+import chalk216 from "chalk";
 async function syncClaudeMd(claudeDir, targetBase, options2) {
   const source = path66.join(claudeDir, "CLAUDE.md");
   const target = path66.join(targetBase, "CLAUDE.md");
@@ -29821,14 +30137,14 @@ async function syncClaudeMd(claudeDir, targetBase, options2) {
     const targetContent = fs41.readFileSync(target, "utf8");
     if (sourceContent !== targetContent) {
       console.log(
-        chalk214.yellow("\n\u26A0\uFE0F  Warning: CLAUDE.md differs from existing file")
+        chalk216.yellow("\n\u26A0\uFE0F  Warning: CLAUDE.md differs from existing file")
       );
       console.log();
       printDiff(targetContent, sourceContent);
       if (!options2?.yes) {
         printAutoConfirmHint();
         const confirm = await promptConfirm(
-          chalk214.red("Overwrite existing CLAUDE.md?"),
+          chalk216.red("Overwrite existing CLAUDE.md?"),
           false
         );
         if (!confirm) {
@@ -30061,7 +30377,7 @@ function syncPi(claudeDir, options2) {
 // src/commands/sync/syncSettings.ts
 import * as fs47 from "fs";
 import * as path73 from "path";
-import chalk215 from "chalk";
+import chalk217 from "chalk";
 async function syncSettings(claudeDir, targetBase, options2) {
   const source = path73.join(claudeDir, "settings.json");
   const target = path73.join(targetBase, "settings.json");
@@ -30080,7 +30396,7 @@ async function syncSettings(claudeDir, targetBase, options2) {
     if (mergedContent !== normalizedTarget) {
       if (!options2?.yes) {
         console.log(
-          chalk215.yellow(
+          chalk217.yellow(
             "\n\u26A0\uFE0F  Warning: settings.json differs from existing file"
           )
         );
@@ -30088,7 +30404,7 @@ async function syncSettings(claudeDir, targetBase, options2) {
         printDiff(targetContent, mergedContent);
         printAutoConfirmHint();
         const confirm = await promptConfirm(
-          chalk215.red("Overwrite existing settings.json?"),
+          chalk217.red("Overwrite existing settings.json?"),
           false
         );
         if (!confirm) {
@@ -30246,7 +30562,7 @@ function list4() {
 import {
   existsSync as existsSync63,
   mkdirSync as mkdirSync26,
-  readFileSync as readFileSync48,
+  readFileSync as readFileSync49,
   renameSync as renameSync2,
   writeFileSync as writeFileSync42
 } from "fs";
@@ -30458,7 +30774,7 @@ function formatChatLog(messages) {
 // src/commands/transcript/move.ts
 var DATE_REGEX = /^\d{4}-\d{2}-\d{2}$/;
 function convertVttToMarkdown(inputPath) {
-  const cues = parseVtt(readFileSync48(inputPath, "utf8"));
+  const cues = parseVtt(readFileSync49(inputPath, "utf8"));
   const messages = cuesToChatMessages(deduplicateCues(cues));
   return formatChatLog(messages);
 }
@@ -30605,14 +30921,14 @@ function devices() {
 }
 
 // src/commands/voice/logs.ts
-import { existsSync as existsSync64, readFileSync as readFileSync49 } from "fs";
+import { existsSync as existsSync64, readFileSync as readFileSync50 } from "fs";
 function logs(options2) {
   if (!existsSync64(voicePaths.log)) {
     console.log("No voice log file found");
     return;
   }
   const count8 = Number.parseInt(options2.lines ?? "150", 10);
-  const content = readFileSync49(voicePaths.log, "utf8").trim();
+  const content = readFileSync50(voicePaths.log, "utf8").trim();
   if (!content) {
     console.log("Voice log is empty");
     return;
@@ -30639,7 +30955,7 @@ import { join as join82 } from "path";
 
 // src/commands/voice/checkLockFile.ts
 import { execSync as execSync58 } from "child_process";
-import { existsSync as existsSync65, mkdirSync as mkdirSync27, readFileSync as readFileSync50, writeFileSync as writeFileSync43 } from "fs";
+import { existsSync as existsSync65, mkdirSync as mkdirSync27, readFileSync as readFileSync51, writeFileSync as writeFileSync43 } from "fs";
 import { join as join81 } from "path";
 function isProcessAlive2(pid) {
   try {
@@ -30653,7 +30969,7 @@ function checkLockFile() {
   const lockFile = getLockFile();
   if (!existsSync65(lockFile)) return;
   try {
-    const lock2 = JSON.parse(readFileSync50(lockFile, "utf8"));
+    const lock2 = JSON.parse(readFileSync51(lockFile, "utf8"));
     if (lock2.pid && isProcessAlive2(lock2.pid)) {
       console.error(
         `Voice daemon already running (PID ${lock2.pid}, env: ${lock2.env}). Stop it first with: assist voice stop`
@@ -30755,7 +31071,7 @@ function start2(options2) {
 }
 
 // src/commands/voice/status.ts
-import { existsSync as existsSync66, readFileSync as readFileSync51 } from "fs";
+import { existsSync as existsSync66, readFileSync as readFileSync52 } from "fs";
 function isProcessAlive3(pid) {
   try {
     process.kill(pid, 0);
@@ -30766,7 +31082,7 @@ function isProcessAlive3(pid) {
 }
 function readRecentLogs(count8) {
   if (!existsSync66(voicePaths.log)) return [];
-  const lines2 = readFileSync51(voicePaths.log, "utf8").trim().split("\n");
+  const lines2 = readFileSync52(voicePaths.log, "utf8").trim().split("\n");
   return lines2.slice(-count8);
 }
 function status2() {
@@ -30774,7 +31090,7 @@ function status2() {
     console.log("Voice daemon: not running (no PID file)");
     return;
   }
-  const pid = Number.parseInt(readFileSync51(voicePaths.pid, "utf8").trim(), 10);
+  const pid = Number.parseInt(readFileSync52(voicePaths.pid, "utf8").trim(), 10);
   const alive = isProcessAlive3(pid);
   console.log(`Voice daemon: ${alive ? "running" : "dead"} (PID ${pid})`);
   const recent = readRecentLogs(5);
@@ -30793,13 +31109,13 @@ function status2() {
 }
 
 // src/commands/voice/stop.ts
-import { existsSync as existsSync67, readFileSync as readFileSync52, unlinkSync as unlinkSync20 } from "fs";
+import { existsSync as existsSync67, readFileSync as readFileSync53, unlinkSync as unlinkSync20 } from "fs";
 function stop2() {
   if (!existsSync67(voicePaths.pid)) {
     console.log("Voice daemon is not running (no PID file)");
     return;
   }
-  const pid = Number.parseInt(readFileSync52(voicePaths.pid, "utf8").trim(), 10);
+  const pid = Number.parseInt(readFileSync53(voicePaths.pid, "utf8").trim(), 10);
   try {
     process.kill(pid, "SIGTERM");
     console.log(`Sent SIGTERM to voice daemon (PID ${pid})`);
@@ -31515,7 +31831,7 @@ function registerWatch(program2) {
 
 // src/commands/roam/auth.ts
 import { randomBytes } from "crypto";
-import chalk216 from "chalk";
+import chalk218 from "chalk";
 
 // src/commands/roam/waitForCallback.ts
 import { createServer as createServer3 } from "http";
@@ -31646,13 +31962,13 @@ async function auth() {
   saveGlobalConfig(config);
   const state = randomBytes(16).toString("hex");
   console.log(
-    chalk216.yellow("\nEnsure this Redirect URI is set in your Roam OAuth app:")
+    chalk218.yellow("\nEnsure this Redirect URI is set in your Roam OAuth app:")
   );
-  console.log(chalk216.white("http://localhost:14523/callback\n"));
-  console.log(chalk216.blue("Opening browser for authorization..."));
-  console.log(chalk216.dim("Waiting for authorization callback..."));
+  console.log(chalk218.white("http://localhost:14523/callback\n"));
+  console.log(chalk218.blue("Opening browser for authorization..."));
+  console.log(chalk218.dim("Waiting for authorization callback..."));
   const { code, redirectUri } = await authorizeInBrowser(clientId, state);
-  console.log(chalk216.dim("Exchanging code for tokens..."));
+  console.log(chalk218.dim("Exchanging code for tokens..."));
   const tokens = await exchangeToken({
     code,
     clientId,
@@ -31668,13 +31984,13 @@ async function auth() {
   };
   saveGlobalConfig(config);
   console.log(
-    chalk216.green("Roam credentials and tokens saved to ~/.assist.yml")
+    chalk218.green("Roam credentials and tokens saved to ~/.assist.yml")
   );
 }
 
 // src/commands/roam/postRoamActivity.ts
 import { execFileSync as execFileSync18 } from "child_process";
-import { readdirSync as readdirSync20, readFileSync as readFileSync53, statSync as statSync11 } from "fs";
+import { readdirSync as readdirSync20, readFileSync as readFileSync54, statSync as statSync11 } from "fs";
 import { join as join86 } from "path";
 function findPortFile(roamDir) {
   let entries;
@@ -31700,7 +32016,7 @@ function postRoamActivity(app, event) {
   if (!portFile) return;
   let port;
   try {
-    port = readFileSync53(portFile, "utf8").trim();
+    port = readFileSync54(portFile, "utf8").trim();
   } catch {
     return;
   }
@@ -32019,7 +32335,7 @@ import { execSync as execSync60 } from "child_process";
 import { existsSync as existsSync72, mkdirSync as mkdirSync31, unlinkSync as unlinkSync22, writeFileSync as writeFileSync46 } from "fs";
 import { tmpdir as tmpdir8 } from "os";
 import { join as join89, resolve as resolve20 } from "path";
-import chalk217 from "chalk";
+import chalk219 from "chalk";
 
 // src/commands/screenshot/captureWindowPs1.ts
 var captureWindowPs1 = `
@@ -32170,13 +32486,13 @@ function screenshot(processName) {
   const config = loadConfig();
   const outputDir = resolve20(config.screenshot.outputDir);
   const outputPath = buildOutputPath(outputDir, processName);
-  console.log(chalk217.gray(`Capturing window for process "${processName}" ...`));
+  console.log(chalk219.gray(`Capturing window for process "${processName}" ...`));
   try {
     runPowerShellScript(processName, outputPath);
-    console.log(chalk217.green(`Screenshot saved: ${outputPath}`));
+    console.log(chalk219.green(`Screenshot saved: ${outputPath}`));
   } catch (error) {
     const msg = error instanceof Error ? error.message : String(error);
-    console.error(chalk217.red(`Failed to capture screenshot: ${msg}`));
+    console.error(chalk219.red(`Failed to capture screenshot: ${msg}`));
     process.exit(1);
   }
 }
@@ -32232,11 +32548,11 @@ function applyLine(result, pending, line) {
 }
 
 // src/commands/sessions/daemon/readDaemonPidFile.ts
-import { readFileSync as readFileSync54 } from "fs";
+import { readFileSync as readFileSync55 } from "fs";
 function readDaemonPidFile() {
   try {
     const pid = Number.parseInt(
-      readFileSync54(daemonPaths.pid, "utf8").trim(),
+      readFileSync55(daemonPaths.pid, "utf8").trim(),
       10
     );
     return Number.isInteger(pid) ? pid : void 0;
@@ -36267,14 +36583,14 @@ async function defaultConnect() {
 }
 
 // src/commands/sessions/daemon/hasPersistedWindowsSessions.ts
-import { existsSync as existsSync84, readFileSync as readFileSync56 } from "fs";
+import { existsSync as existsSync84, readFileSync as readFileSync57 } from "fs";
 import { posix as posix3 } from "path";
 function hasPersistedWindowsSessions() {
   const sessionsFile = windowsSessionsFileFromWsl();
   if (!sessionsFile) return false;
   try {
     if (!existsSync84(sessionsFile)) return false;
-    const data = JSON.parse(readFileSync56(sessionsFile, "utf8"));
+    const data = JSON.parse(readFileSync57(sessionsFile, "utf8"));
     return Array.isArray(data) && data.length > 0;
   } catch (error) {
     const message3 = error instanceof Error ? error.message : String(error);
@@ -37692,7 +38008,7 @@ function handleConnection(socket, manager) {
 import { unlinkSync as unlinkSync23, writeFileSync as writeFileSync47 } from "fs";
 
 // src/commands/sessions/daemon/startPidFileWatchdog.ts
-import { readFileSync as readFileSync57 } from "fs";
+import { readFileSync as readFileSync58 } from "fs";
 var WATCHDOG_INTERVAL_MS = 5e3;
 function startPidFileWatchdog(onLost, intervalMs = WATCHDOG_INTERVAL_MS) {
   const timer = setInterval(() => {
@@ -37703,7 +38019,7 @@ function startPidFileWatchdog(onLost, intervalMs = WATCHDOG_INTERVAL_MS) {
 }
 function ownsPidFile() {
   try {
-    return readFileSync57(daemonPaths.pid, "utf8").trim() === String(process.pid);
+    return readFileSync58(daemonPaths.pid, "utf8").trim() === String(process.pid);
   } catch {
     return false;
   }
@@ -37953,7 +38269,7 @@ function registerSetStatusCommand(cmd) {
 
 // src/commands/sessions/summarise/index.ts
 import * as fs56 from "fs";
-import chalk218 from "chalk";
+import chalk220 from "chalk";
 
 // src/commands/sessions/summarise/shared.ts
 import * as fs55 from "fs";
@@ -38012,22 +38328,22 @@ ${firstMessage}`);
 async function summarise2(options2) {
   const files = await discoverSessionFiles();
   if (files.length === 0) {
-    console.log(chalk218.yellow("No sessions found."));
+    console.log(chalk220.yellow("No sessions found."));
     return;
   }
   const toProcess = selectCandidates(files, options2);
   if (toProcess.length === 0) {
-    console.log(chalk218.green("All sessions already summarised."));
+    console.log(chalk220.green("All sessions already summarised."));
     return;
   }
   console.log(
-    chalk218.cyan(
+    chalk220.cyan(
       `Summarising ${toProcess.length} session(s) (${files.length} total)\u2026`
     )
   );
   const { succeeded, failed: failed2 } = processSessions(toProcess);
   console.log(
-    chalk218.green(`Done: ${succeeded} summarised`) + (failed2 > 0 ? chalk218.yellow(`, ${failed2} skipped`) : "")
+    chalk220.green(`Done: ${succeeded} summarised`) + (failed2 > 0 ? chalk220.yellow(`, ${failed2} skipped`) : "")
   );
 }
 function selectCandidates(files, options2) {
@@ -38047,16 +38363,16 @@ function processSessions(files) {
   let failed2 = 0;
   for (let i = 0; i < files.length; i++) {
     const file = files[i];
-    process.stdout.write(chalk218.dim(`  [${i + 1}/${files.length}] `));
+    process.stdout.write(chalk220.dim(`  [${i + 1}/${files.length}] `));
     const summary = summariseSession(file);
     if (summary) {
       writeSummary(file, summary);
       succeeded++;
-      process.stdout.write(`${chalk218.green("\u2713")} ${summary}
+      process.stdout.write(`${chalk220.green("\u2713")} ${summary}
 `);
     } else {
       failed2++;
-      process.stdout.write(` ${chalk218.yellow("skip")}
+      process.stdout.write(` ${chalk220.yellow("skip")}
 `);
     }
   }
@@ -38077,7 +38393,7 @@ function registerSessions(program2) {
 }
 
 // src/commands/statusLine.ts
-import chalk220 from "chalk";
+import chalk222 from "chalk";
 
 // src/shared/contextLevel.ts
 function contextLevel(pct) {
@@ -38087,7 +38403,7 @@ function contextLevel(pct) {
 }
 
 // src/commands/buildLimitsSegment.ts
-import chalk219 from "chalk";
+import chalk221 from "chalk";
 
 // src/shared/rateLimitLevel.ts
 var FIVE_HOUR_SECONDS = 5 * 3600;
@@ -38125,9 +38441,9 @@ function rateLimitLevel(pct, resetsAt, windowSeconds, now) {
 
 // src/commands/buildLimitsSegment.ts
 var LEVEL_COLOR = {
-  ok: chalk219.green,
-  warn: chalk219.yellow,
-  over: chalk219.red
+  ok: chalk221.green,
+  warn: chalk221.yellow,
+  over: chalk221.red
 };
 function formatLimit(pct, resetsAt, windowSeconds, fallbackLabel, now) {
   const level = rateLimitLevel(pct, resetsAt, windowSeconds, now);
@@ -38158,7 +38474,7 @@ function buildLimitsSegment(rateLimits) {
 }
 
 // src/commands/readGitBranch.ts
-import { readFileSync as readFileSync59, statSync as statSync15 } from "fs";
+import { readFileSync as readFileSync60, statSync as statSync15 } from "fs";
 import { isAbsolute as isAbsolute4, join as join95, resolve as resolve22 } from "path";
 function resolveGitDir(cwd) {
   const dotGit = join95(cwd, ".git");
@@ -38173,7 +38489,7 @@ function resolveGitDir(cwd) {
   }
   let contents;
   try {
-    contents = readFileSync59(dotGit, "utf8");
+    contents = readFileSync60(dotGit, "utf8");
   } catch {
     return null;
   }
@@ -38191,7 +38507,7 @@ function readGitBranch(cwd) {
   }
   let head;
   try {
-    head = readFileSync59(join95(gitDir, "HEAD"), "utf8");
+    head = readFileSync60(join95(gitDir, "HEAD"), "utf8");
   } catch {
     return null;
   }
@@ -38223,7 +38539,7 @@ async function relayUsage(claudeSessionId, transcriptPath2, usedPct) {
 }
 
 // src/commands/statusLine.ts
-chalk220.level = 3;
+chalk222.level = 3;
 function formatNumber(num) {
   return num.toLocaleString("en-US");
 }
@@ -38231,9 +38547,9 @@ function colorizePercent(pct) {
   const label2 = `${Math.round(pct)}%`;
   switch (contextLevel(pct)) {
     case "red":
-      return chalk220.red(label2);
+      return chalk222.red(label2);
     case "yellow":
-      return chalk220.yellow(label2);
+      return chalk222.yellow(label2);
     default:
       return label2;
   }
@@ -38246,7 +38562,7 @@ async function statusLine() {
   const usedPct = data.context_window.used_percentage ?? 0;
   const dir = data.workspace?.current_dir ?? data.cwd;
   const branch2 = dir ? readGitBranch(toGitCwd(dir)) : null;
-  const branchSegment = branch2 ? `\u{1F33F}\uFE0F ${chalk220.cyan(branch2)} | ` : "";
+  const branchSegment = branch2 ? `\u{1F33F}\uFE0F ${chalk222.cyan(branch2)} | ` : "";
   console.log(
     `${branchSegment}${model} | Tokens - ${formatNumber(totalIn)} \u2191 : ${formatNumber(totalOut)} \u2193 | Context - ${colorizePercent(usedPct)}${buildLimitsSegment(data.rate_limits)}`
   );
@@ -38316,10 +38632,10 @@ async function update2() {
 }
 
 // src/reportCliError.ts
-import chalk221 from "chalk";
+import chalk223 from "chalk";
 function reportCliError(error) {
-  if (error instanceof InvalidItemIdError || error instanceof AmbiguousRepoConfigError || error instanceof UnknownRepoConfigError || error instanceof MissingRunCwdError) {
-    console.error(chalk221.red(error.message));
+  if (error instanceof InvalidItemIdError || error instanceof AmbiguousRepoConfigError || error instanceof UnknownRepoConfigError || error instanceof MissingRunCwdError || error instanceof MiroExtractError) {
+    console.error(chalk223.red(error.message));
   } else {
     console.error(error);
   }
@@ -38362,6 +38678,7 @@ registerGithub(program);
 registerHandover(program);
 registerJira(program);
 registerMermaid(program);
+registerMiro(program);
 registerPrs(program);
 registerRoam(program);
 registerBacklog(program);