@miroshnik/elves 0.0.0 → 2026.1018.0

package/dist/github/scripts/github.js

@@ -0,0 +1,3428 @@
+#!/usr/bin/env bun
+import {
+  locale_default
+} from "../../spec/scripts/harness-qzb932c8.js";
+
+// skills/github/scripts/github.ts
+import { spawnSync } from "node:child_process";
+import { appendFileSync, existsSync, lstatSync, mkdirSync, mkdtempSync, readdirSync, readFileSync, realpathSync, rmSync, statSync, writeFileSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { parseArgs } from "node:util";
+var N = locale_default.names(locale_default.projectLanguage());
+var canonViews = () => [
+  { name: N.views.board, layout: "BOARD_LAYOUT" },
+  { name: N.views.table, layout: "TABLE_LAYOUT" },
+  { name: N.views.roadmap, layout: "ROADMAP_LAYOUT" }
+];
+var STATUS = "Status";
+var statusOptions = () => [N.status.backlog, N.status.inProgress, N.status.done];
+var numberFields = () => [N.fields.estimate, N.fields.actual, N.fields.tokens, N.fields.cost];
+var issueTypes = () => [N.issueTypes.task, N.issueTypes.bug, N.issueTypes.epic];
+var PRIORITY = "Priority";
+var PRIORITIES = ["Urgent", "High", "Medium", "Low"];
+var DEFAULT_PRIORITY = "Medium";
+var EPIC_LABEL = "epic";
+var epicLabel = () => ({ name: EPIC_LABEL, color: "8250DF", description: N.labels.epicDescription });
+var questionsLabel = () => ({ name: N.labels.questions, color: "FBCA04", description: N.labels.questionsDescription });
+var DECISIONS = {
+  capability: { dir: "capabilities", color: "0E8A16" },
+  standard: { dir: "standards", color: "1D76DB" },
+  architecture: { dir: "architecture", color: "D93F0B" }
+};
+var DECISION_KINDS = Object.keys(DECISIONS);
+var MODEL_PATH = "tests/architecture/model.ts";
+var ISSUE_LABEL_LIMIT = 100;
+var WORKFLOW_ADDED = "Item added to project";
+var WORKFLOW_CLOSED = "Item closed";
+var WORKFLOW_AUTO_ADD = "Auto-add to project";
+var DEFAULT_TEMPLATE = "miroshnik/6";
+var RULESET = "elves";
+var FORMER_RULESET = "ai-dev";
+var STABLE_PRS = 10;
+var ADMIN_ROLE = 5;
+function statusAliases() {
+  const out = { todo: N.status.backlog, "to do": N.status.backlog, doing: N.status.inProgress };
+  for (const n of locale_default.everyNames()) {
+    out[n.status.backlog.toLowerCase()] = N.status.backlog;
+    out[n.status.inProgress.toLowerCase()] = N.status.inProgress;
+    out[n.status.done.toLowerCase()] = N.status.done;
+  }
+  return out;
+}
+function typeAliases() {
+  const out = {};
+  for (const n of locale_default.everyNames()) {
+    out[n.issueTypes.task.toLowerCase()] = N.issueTypes.task;
+    out[n.issueTypes.bug.toLowerCase()] = N.issueTypes.bug;
+    out[n.issueTypes.epic.toLowerCase()] = N.issueTypes.epic;
+  }
+  return out;
+}
+function fieldAliases() {
+  const out = {};
+  for (const n of locale_default.everyNames()) {
+    out[n.fields.estimate] = N.fields.estimate;
+    out[n.fields.actual] = N.fields.actual;
+    out[n.fields.tokens] = N.fields.tokens;
+    out[n.fields.cost] = N.fields.cost;
+  }
+  return out;
+}
+var BUILTIN_FIELDS = new Set(["TITLE", "ASSIGNEES", "LABELS", "LINKED_PULL_REQUESTS", "MILESTONE", "REPOSITORY", "REVIEWERS", "PARENT_ISSUE", "SUB_ISSUES_PROGRESS", "CREATED", "UPDATED", "CLOSED", "TRACKS", "TRACKED_BY", "ISSUE_TYPE"]);
+var NOT_DONE_REASONS = new Set(["NOT_PLANNED", "DUPLICATE"]);
+function realRun(cmd, args, cwd) {
+  const r = spawnSync(cmd, args, { cwd, encoding: "utf8", maxBuffer: 64 * 1024 * 1024 });
+  return { status: r.error ? null : r.status, stdout: r.stdout ?? "", stderr: r.error ? String(r.error.message) : r.stderr ?? "" };
+}
+var pause = (ms) => void Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+
+class GhError extends Error {
+}
+var REF = "id number title url closed";
+var OPEN_SHOWN = 10;
+var RECENT_PRS = 50;
+var HEAD_CHECKS = `commits(last: 1) { nodes { commit { statusCheckRollup { contexts(first: 100) { nodes { __typename ... on CheckRun { name status conclusion databaseId checkSuite { app { databaseId } } } ... on StatusContext { context state } } } } } } }`;
+var PR_SHOW = `number state merged isDraft headRefName
+        ${HEAD_CHECKS}`;
+var Q = {
+  RepoName: `query RepoName($owner: String!, $name: String!) {
+  repository(owner: $owner, name: $name) { nameWithOwner }
+}`,
+  RepoState: `query RepoState($owner: String!, $name: String!) {
+  repository(owner: $owner, name: $name) {
+    id name nameWithOwner
+    owner {
+      __typename id login
+      ... on Organization {
+        issueTypes(first: 50) { nodes { id name isEnabled } }
+        issueFields(first: 50) { nodes { __typename ... on IssueFieldSingleSelect { id name options { id name } } } }
+      }
+    }
+    projectsV2(first: 20) { nodes { ${REF} } }
+  }
+}`,
+  RepoIssues: `query RepoIssues($owner: String!, $name: String!, $after: String) {
+  repository(owner: $owner, name: $name) {
+    issues(states: OPEN, first: 100, after: $after) { pageInfo { hasNextPage endCursor } nodes { id number } }
+  }
+}`,
+  OwnerProjects: `query OwnerProjects($login: String!, $query: String!) {
+  repositoryOwner(login: $login) { ... on ProjectV2Owner { projectsV2(first: 20, query: $query) { nodes { ${REF} } } } }
+}`,
+  TemplateProject: `query TemplateProject($login: String!, $number: Int!) {
+  repositoryOwner(login: $login) { ... on ProjectV2Owner { projectV2(number: $number) { ${REF} } } }
+}`,
+  ProjectState: `query ProjectState($id: ID!) {
+  node(id: $id) {
+    ... on ProjectV2 {
+      ${REF}
+      views(first: 50) {
+        nodes {
+          id number name layout filter
+          sortByFields(first: 5) { nodes { direction field { ... on ProjectV2FieldCommon { name } } } }
+          verticalGroupByFields(first: 5) { nodes { ... on ProjectV2FieldCommon { name } } }
+        }
+      }
+      fields(first: 100) {
+        nodes {
+          __typename
+          ... on ProjectV2FieldCommon { id name dataType }
+          ... on ProjectV2Field { isIssueField }
+          ... on ProjectV2SingleSelectField { isIssueField options { id name color description } }
+        }
+      }
+      workflows(first: 50) { nodes { id number fullDatabaseId name enabled } }
+    }
+  }
+}`,
+  IssueRef: `query IssueRef($owner: String!, $name: String!, $number: Int!) {
+  repository(owner: $owner, name: $name) {
+    issue(number: $number) {
+      id number title state stateReason url
+      issueType { name }
+      labels(first: ${ISSUE_LABEL_LIMIT}) { nodes { name } }
+      parent { id number }
+      subIssues(first: 100) { nodes { number state title } }
+      blockedBy(first: 50) { nodes { number state repository { nameWithOwner } } }
+      milestone { id number title issues(states: OPEN) { totalCount } }
+      closedByPullRequestsReferences(first: 20, includeClosedPrs: true) { nodes { number state merged headRefName baseRefName } }
+      projectItems(first: 20) { nodes { id project { id } status: fieldValueByName(name: "${STATUS}") { ... on ProjectV2ItemFieldSingleSelectValue { name } } } }
+      issueFieldValues(first: 20) { nodes { __typename ... on IssueFieldSingleSelectValue { name field { ... on IssueFieldSingleSelect { name } } } } }
+    }
+  }
+}`,
+  TaskText: `query TaskText($owner: String!, $name: String!, $number: Int!) {
+  repository(owner: $owner, name: $name) {
+    issue(number: $number) {
+      id number title state body
+      labels(first: 20) { nodes { id name } }
+      milestone { number title state issues(states: OPEN) { totalCount } }
+      blockedBy(first: 50) { nodes { id number state repository { nameWithOwner } } }
+      comments(last: 50) { nodes { body url } }
+      subIssues(first: 100) { nodes { number title state milestone { number title state issues(states: OPEN) { totalCount } } } }
+    }
+  }
+}`,
+  TaskContext: `query TaskContext($owner: String!, $name: String!) {
+  repository(owner: $owner, name: $name) {
+    label(name: "${EPIC_LABEL}") { id }
+    milestones(first: 100, states: OPEN) { nodes { id title } }
+  }
+}`,
+  SpecDecisions: `query SpecDecisions($owner: String!, $name: String!) {
+  repository(owner: $owner, name: $name) {
+    capabilities: object(expression: "HEAD:tests/capabilities") { ... on Tree { entries { name type } } }
+    standards: object(expression: "HEAD:tests/standards") { ... on Tree { entries { name type } } }
+    architecture: object(expression: "HEAD:tests/architecture") { ... on Tree { entries { name type } } }
+    model: object(expression: "HEAD:${MODEL_PATH}") { ... on Blob { text } }
+  }
+}`,
+  LabelIssues: `query LabelIssues($owner: String!, $name: String!, $label: String!, $after: String) {
+  repository(owner: $owner, name: $name) {
+    label(name: $label) { issues(first: 100, after: $after) { pageInfo { hasNextPage endCursor } nodes { id number } } }
+  }
+}`,
+  RepoLabels: `query RepoLabels($owner: String!, $name: String!, $after: String) {
+  repository(owner: $owner, name: $name) {
+    labels(first: 100, after: $after) { pageInfo { hasNextPage endCursor } nodes { id name color description issues(states: OPEN, first: ${OPEN_SHOWN}) { totalCount nodes { number } } } }
+  }
+}`,
+  PrChange: `query PrChange($owner: String!, $name: String!, $number: Int!, $after: String) {
+  repository(owner: $owner, name: $name) {
+    pullRequest(number: $number) {
+      number headRefOid body
+      closingIssuesReferences(first: 20) { nodes { number } }
+      files(first: 100, after: $after) { pageInfo { hasNextPage endCursor } nodes { path changeType additions deletions } }
+    }
+  }
+}`,
+  ModelAt: `query ModelAt($owner: String!, $name: String!, $expression: String!) {
+  repository(owner: $owner, name: $name) { object(expression: $expression) { ... on Blob { text } } }
+}`,
+  MergeRules: `query MergeRules($owner: String!, $name: String!) {
+  repository(owner: $owner, name: $name) {
+    isPrivate mergeCommitAllowed squashMergeAllowed rebaseMergeAllowed
+    defaultBranchRef {
+      name
+      branchProtectionRule { requiredStatusCheckContexts }
+      rules(first: 100) { nodes { type repositoryRuleset { name } parameters { ...StatusChecks } } }
+    }
+    rulesets(first: 100) {
+      nodes {
+        id name enforcement
+        conditions { refName { include } }
+        bypassActors(first: 50) { nodes { bypassMode repositoryRoleDatabaseId } }
+        rules(first: 100) { nodes { type parameters { ...StatusChecks } } }
+      }
+    }
+    merged: pullRequests(states: MERGED, last: 30) { nodes { ...Head } }
+    open: pullRequests(states: OPEN, last: 30) { nodes { ...Head } }
+  }
+}
+fragment StatusChecks on RuleParameters { ... on RequiredStatusChecksParameters { strictRequiredStatusChecksPolicy requiredStatusChecks { context } } }
+fragment Head on PullRequest {
+  number baseRefName
+  ${HEAD_CHECKS}
+}`,
+  RecentPrs: `query RecentPrs($owner: String!, $name: String!) {
+  repository(owner: $owner, name: $name) {
+    defaultBranchRef { name }
+    pullRequests(states: [OPEN, MERGED], first: ${RECENT_PRS}, orderBy: { field: UPDATED_AT, direction: DESC }) { nodes { number state merged headRefName baseRefName body } }
+  }
+}`,
+  IssueShow: `query IssueShow($owner: String!, $name: String!, $number: Int!) {
+  repository(owner: $owner, name: $name) {
+    issue(number: $number) {
+      id number title state stateReason url body
+      issueType { name }
+      labels(first: 20) { nodes { id name } }
+      milestone { title }
+      parent { number title body subIssues(first: 100) { nodes { number state title } } }
+      subIssues(first: 100) { nodes { number state title } }
+      blockedBy(first: 20) { nodes { number state title repository { nameWithOwner } } }
+      closedByPullRequestsReferences(first: 20, includeClosedPrs: true) { nodes { ${PR_SHOW} } }
+      projectItems(first: 20) {
+        nodes {
+          project { title }
+          fieldValues(first: 50) {
+            nodes {
+              __typename
+              ... on ProjectV2ItemFieldSingleSelectValue { name field { ... on ProjectV2FieldCommon { name } } }
+              ... on ProjectV2ItemFieldNumberValue { number field { ... on ProjectV2FieldCommon { name } } }
+            }
+          }
+        }
+      }
+      issueFieldValues(first: 20) { nodes { __typename ... on IssueFieldSingleSelectValue { name field { ... on IssueFieldSingleSelect { name } } } } }
+    }
+  }
+}`,
+  PrShow: `query PrShow($owner: String!, $name: String!, $number: Int!) {
+  repository(owner: $owner, name: $name) { pullRequest(number: $number) { ${PR_SHOW} } }
+}`,
+  IssueSearch: `query IssueSearch($q: String!) {
+  search(query: $q, type: ISSUE, first: 100) { nodes { ... on Issue { number title state } } }
+}`,
+  ProjectItems: `query ProjectItems($id: ID!, $after: String) {
+  node(id: $id) {
+    ... on ProjectV2 {
+      items(first: 100, after: $after) {
+        pageInfo { hasNextPage endCursor }
+        nodes {
+          id
+          content { __typename ... on Issue { id number state stateReason } }
+          status: fieldValueByName(name: "${STATUS}") { ... on ProjectV2ItemFieldSingleSelectValue { name } }
+        }
+      }
+    }
+  }
+}`
+};
+var M = {
+  LinkProject: ["linkProjectV2ToRepository", "LinkProjectV2ToRepositoryInput", "repository { id }"],
+  UnlinkProject: ["unlinkProjectV2FromRepository", "UnlinkProjectV2FromRepositoryInput", "repository { id }"],
+  CopyProject: ["copyProjectV2", "CopyProjectV2Input", `projectV2 { ${REF} }`],
+  CreateProject: ["createProjectV2", "CreateProjectV2Input", `projectV2 { ${REF} }`],
+  RenameProject: ["updateProjectV2", "UpdateProjectV2Input", "projectV2 { id }"],
+  CreateView: ["createProjectV2View", "CreateProjectV2ViewInput", "projectV2View { id }"],
+  UpdateView: ["updateProjectV2View", "UpdateProjectV2ViewInput", "projectV2View { id }"],
+  DeleteView: ["deleteProjectV2View", "DeleteProjectV2ViewInput", "clientMutationId"],
+  CreateField: ["createProjectV2Field", "CreateProjectV2FieldInput", "clientMutationId"],
+  UpdateField: ["updateProjectV2Field", "UpdateProjectV2FieldInput", "clientMutationId"],
+  DeleteField: ["deleteProjectV2Field", "DeleteProjectV2FieldInput", "clientMutationId"],
+  AddIssueField: ["createProjectV2IssueField", "CreateProjectV2IssueFieldInput", "clientMutationId"],
+  SetItemStatus: ["updateProjectV2ItemFieldValue", "UpdateProjectV2ItemFieldValueInput", "projectV2Item { id }"],
+  AddItem: ["addProjectV2ItemById", "AddProjectV2ItemByIdInput", "item { id }"],
+  DeleteItem: ["deleteProjectV2Item", "DeleteProjectV2ItemInput", "deletedItemId"],
+  CreateIssueType: ["createIssueType", "CreateIssueTypeInput", "issueType { id }"],
+  UpdateIssueType: ["updateIssueType", "UpdateIssueTypeInput", "issueType { id }"],
+  CreateIssue: ["createIssue", "CreateIssueInput", "issue { id number title url projectItems(first: 10) { nodes { id project { id } } } }"],
+  CreateLabel: ["createLabel", "CreateLabelInput", "label { id }"],
+  UpdateLabel: ["updateLabel", "UpdateLabelInput", "label { id }"],
+  DeleteLabel: ["deleteLabel", "DeleteLabelInput", "clientMutationId"],
+  AddLabels: ["addLabelsToLabelable", "AddLabelsToLabelableInput", "clientMutationId"],
+  RemoveLabels: ["removeLabelsFromLabelable", "RemoveLabelsFromLabelableInput", "clientMutationId"],
+  AddBlockedBy: ["addBlockedBy", "AddBlockedByInput", "issue { id }"],
+  RemoveBlockedBy: ["removeBlockedBy", "RemoveBlockedByInput", "issue { id }"],
+  SetIssueField: ["setIssueFieldValue", "SetIssueFieldValueInput", "issue { id }"],
+  CloseIssue: ["closeIssue", "CloseIssueInput", "issue { id state }"],
+  UpdateIssue: ["updateIssue", "UpdateIssueInput", "issue { id }"],
+  AddComment: ["addComment", "AddCommentInput", "subject { id }"],
+  CreateRuleset: ["createRepositoryRuleset", "CreateRepositoryRulesetInput", "ruleset { id }"],
+  UpdateRuleset: ["updateRepositoryRuleset", "UpdateRepositoryRulesetInput", "ruleset { id }"]
+};
+var REST = {
+  UpdateRepository: ({ repo, ...fields }) => ["api", "-X", "PATCH", `repos/${repo}`, ...Object.entries(fields).flatMap(([k, v]) => ["-F", `${k}=${v}`])]
+};
+function mutationQuery(op) {
+  const spec = M[op];
+  if (!spec)
+    throw new GhError(`unknown mutation ${op}`);
+  const [field, inputType, select] = spec;
+  return `mutation ${op}($input: ${inputType}!) { ${field}(input: $input) { ${select} } }`;
+}
+function graphql(io, query, variables, strict = false) {
+  const out = io.gh(["api", "graphql", "--input", "-"], JSON.stringify({ query, variables }));
+  let res;
+  try {
+    res = JSON.parse(out);
+  } catch {
+    throw new GhError(`gh api graphql: the response is not JSON: ${out.slice(0, 200)}`);
+  }
+  const errors = (res.errors ?? []).map((e) => e.message ?? String(e));
+  if (errors.length && (!res.data || strict))
+    throw new GhError(`GraphQL: ${errors.join("; ")}`);
+  if (errors.length)
+    io.err(`GraphQL warning: ${errors.join("; ")}`);
+  return res.data;
+}
+function mutate(io, m) {
+  const rest = REST[m.op];
+  return rest ? restCall(io, rest(m.input)) : graphql(io, mutationQuery(m.op), { input: m.input }, true);
+}
+function restCall(io, args) {
+  const what = args.slice(1).filter((a) => !a.startsWith("-")).slice(0, 2).join(" ");
+  const out = io.gh(args);
+  let res;
+  try {
+    res = JSON.parse(out);
+  } catch {
+    throw new GhError(`${what}: the response is not JSON: ${out.slice(0, 200)}`);
+  }
+  if (res?.message && res.id === undefined)
+    throw new GhError(`${what}: ${res.message}`);
+  return res;
+}
+var inCloud = (io) => io.env.CLAUDE_CODE_REMOTE === "true";
+var CLOUD_COMMANDS = ["task show", "task answer", "task new"];
+function rest(io, route, o = {}) {
+  const what = `${o.method ?? "GET"} ${route}`;
+  const out = io.gh(["api", ...o.method ? ["-X", o.method] : [], route, ...o.payload === undefined ? [] : ["--input", "-"]], o.payload === undefined ? undefined : JSON.stringify(o.payload));
+  let res;
+  try {
+    res = out.trim() ? JSON.parse(out) : null;
+  } catch {
+    throw new GhError(`${what}: the response is not JSON: ${out.slice(0, 200)}`);
+  }
+  if (res && !Array.isArray(res) && typeof res.message === "string" && res.id === undefined) {
+    if (o.missing && String(res.status) === "404")
+      return null;
+    throw new GhError(`${what}: ${res.message}`);
+  }
+  return res;
+}
+function restList(io, route) {
+  const out = [];
+  for (let page = 1;page <= 100; page++) {
+    const rows = rest(io, `${route}${route.includes("?") ? "&" : "?"}per_page=100&page=${page}`) ?? [];
+    out.push(...rows);
+    if (rows.length < 100)
+      break;
+  }
+  return out;
+}
+var repoOfUrl = (url, slug) => /\/repos\/([^/]+\/[^/]+)$/.exec(url ?? "")?.[1] ?? slug;
+function restIssueNode(i) {
+  return {
+    id: i.node_id,
+    databaseId: i.id,
+    number: i.number,
+    title: i.title,
+    state: String(i.state).toUpperCase(),
+    stateReason: i.state_reason ? String(i.state_reason).toUpperCase() : null,
+    url: i.html_url,
+    body: i.body ?? "",
+    issueType: i.type?.name ? { name: i.type.name } : null,
+    labels: { nodes: (i.labels ?? []).map((l) => ({ id: l.node_id, name: l.name })) },
+    milestone: i.milestone ? { id: i.milestone.node_id, number: i.milestone.number, title: i.milestone.title, open: i.milestone.open_issues ?? 0 } : null
+  };
+}
+function restIssue(io, slug, number) {
+  const i = rest(io, `repos/${slug}/issues/${number}`, { missing: true });
+  return i && !i.pull_request ? restIssueNode(i) : null;
+}
+var restBrief = (x, slug) => ({ id: x.node_id, databaseId: x.id, number: x.number, state: String(x.state).toUpperCase(), title: x.title, repository: { nameWithOwner: repoOfUrl(x.repository_url, slug) } });
+var restSubIssues = (io, slug, number) => ({ nodes: restList(io, `repos/${slug}/issues/${number}/sub_issues`).map((x) => restBrief(x, slug)) });
+function restLinks(io, slug, number) {
+  const parent = rest(io, `repos/${slug}/issues/${number}/parent`, { missing: true });
+  return {
+    subIssues: restSubIssues(io, slug, number),
+    blockedBy: { nodes: restList(io, `repos/${slug}/issues/${number}/dependencies/blocked_by`).map((x) => restBrief(x, slug)) },
+    parent: parent && restIssueNode(parent)
+  };
+}
+function realGh(args, stdin) {
+  const r = spawnSync("gh", args, { input: stdin, encoding: "utf8", maxBuffer: 64 * 1024 * 1024 });
+  if (r.error) {
+    if (r.error.code === "ENOENT")
+      throw new GhError("gh command not found; the gh CLI must be installed");
+    throw new GhError(`gh ${args.slice(0, 2).join(" ")}: ${r.error.message}`);
+  }
+  if (r.status !== 0 && !r.stdout.trim().startsWith("{"))
+    throw new GhError(`gh ${args.slice(0, 2).join(" ")}: ${(r.stderr || "").trim().slice(0, 500)}`);
+  return r.stdout;
+}
+function pages(fetch) {
+  const out = [];
+  let after = null;
+  for (let i = 0;i < 100; i++) {
+    const page = fetch(after);
+    out.push(...page.nodes);
+    if (!page.pageInfo.hasNextPage)
+      break;
+    after = page.pageInfo.endCursor;
+  }
+  return out;
+}
+var ref = (p) => ({ id: p.id, number: p.number, title: p.title, url: p.url, closed: !!p.closed });
+function loadRepo(io, slug) {
+  const [owner, name] = slug.split("/");
+  const data = graphql(io, Q.RepoState, { owner, name });
+  const r = data?.repository;
+  if (!r)
+    throw new GhError(`repository ${slug} not found or no access`);
+  const o = r.owner;
+  return {
+    id: r.id,
+    name: r.name,
+    nameWithOwner: r.nameWithOwner,
+    owner: {
+      org: o.__typename === "Organization",
+      id: o.id,
+      login: o.login,
+      issueTypes: (o.issueTypes?.nodes ?? []).filter(Boolean),
+      issueFields: (o.issueFields?.nodes ?? []).filter((f) => f && f.name).map((f) => ({ id: f.id, name: f.name, options: f.options ?? [] }))
+    },
+    linked: (r.projectsV2?.nodes ?? []).filter(Boolean).map(ref)
+  };
+}
+var mainProject = (repo) => repo.linked.find((p) => p.title === repo.name && !p.closed) ?? repo.linked.find((p) => !p.closed) ?? null;
+function loadState(io, slug) {
+  const [owner, name] = slug.split("/");
+  const repo = loadRepo(io, slug);
+  const openIssues = pages((after) => graphql(io, Q.RepoIssues, { owner, name, after }).repository.issues);
+  const main = mainProject(repo);
+  const labels = loadLabels(io, slug);
+  return { repo, project: main ? loadProject(io, main.id) : null, openIssues, labels, labelIssues: mergedIssues(io, slug, labels), decisions: loadDecisions(io, slug), merge: loadMerge(io, slug) };
+}
+var statusChecks = (rule) => rule?.type === "REQUIRED_STATUS_CHECKS" ? { strict: !!rule.parameters?.strictRequiredStatusChecksPolicy, contexts: (rule.parameters?.requiredStatusChecks ?? []).map((c) => c.context) } : null;
+var WORST = ["fail", "cancel", "pending", "skipping", "pass"];
+function checkStates(nodes) {
+  const app = (c) => JSON.stringify([c.name, c.checkSuite?.app?.databaseId ?? null]);
+  const last = new Map;
+  for (const c of nodes) {
+    if (c?.__typename === "CheckRun" && (!last.has(app(c)) || (last.get(app(c)).databaseId ?? 0) <= (c.databaseId ?? 0)))
+      last.set(app(c), c);
+  }
+  const out = new Map;
+  const put = (name, state) => {
+    const was = out.get(name);
+    if (!was || WORST.indexOf(state) < WORST.indexOf(was))
+      out.set(name, state);
+  };
+  for (const c of nodes) {
+    if (c?.__typename === "StatusContext")
+      put(c.context, c.state === "SUCCESS" ? "pass" : c.state === "PENDING" || c.state === "EXPECTED" ? "pending" : "fail");
+    if (c?.__typename !== "CheckRun" || last.get(app(c)) !== c)
+      continue;
+    const s = c.status !== "COMPLETED" ? "pending" : c.conclusion === "SUCCESS" ? "pass" : c.conclusion === "NEUTRAL" || c.conclusion === "SKIPPED" ? "skipping" : c.conclusion === "CANCELLED" ? "cancel" : "fail";
+    put(c.name, s);
+  }
+  return out;
+}
+var rollupOf = (pr) => pr.commits?.nodes?.[0]?.commit?.statusCheckRollup?.contexts?.nodes ?? [];
+function rulesetsUnavailable(io, slug) {
+  const out = io.gh(["api", `repos/${slug}/rulesets`]);
+  let res;
+  try {
+    res = JSON.parse(out);
+  } catch {
+    throw new GhError(`gh api repos/${slug}/rulesets: the response is not JSON: ${out.slice(0, 200)}`);
+  }
+  return !Array.isArray(res) && /upgrade/i.test(res?.message ?? "") ? String(res.message) : null;
+}
+function loadMerge(io, slug) {
+  const [owner, name] = slug.split("/");
+  const r = graphql(io, Q.MergeRules, { owner, name })?.repository;
+  const b = r?.defaultBranchRef;
+  if (!b)
+    return null;
+  const heads = (nodes) => (nodes ?? []).filter((p) => p && p.baseRefName === b.name).map((p) => ({ number: p.number, checks: Object.fromEntries(checkStates(rollupOf(p))) })).filter((h) => Object.keys(h.checks).length);
+  const bp = b.branchProtectionRule;
+  const rules = (b.rules?.nodes ?? []).flatMap((x) => {
+    const sc = statusChecks(x);
+    return sc ? [{ source: `ruleset ${q(x.repositoryRuleset?.name ?? "?")}`, contexts: sc.contexts }] : [];
+  });
+  if (bp?.requiredStatusCheckContexts?.length)
+    rules.push({ source: "branch protection", contexts: bp.requiredStatusCheckContexts });
+  const sets = r.rulesets?.nodes ?? [];
+  const o = sets.find((x) => x?.name === RULESET) ?? sets.find((x) => x?.name === FORMER_RULESET);
+  const osc = o ? (o.rules?.nodes ?? []).map(statusChecks).find(Boolean) ?? { strict: false, contexts: [] } : null;
+  return {
+    branch: b.name,
+    unavailable: r.isPrivate ? rulesetsUnavailable(io, slug) : null,
+    rules,
+    own: o ? {
+      id: o.id,
+      name: o.name,
+      enforcement: o.enforcement,
+      include: o.conditions?.refName?.include ?? [],
+      ...osc,
+      bypassAdmin: (o.bypassActors?.nodes ?? []).some((a) => a?.repositoryRoleDatabaseId === ADMIN_ROLE && a.bypassMode === "ALWAYS")
+    } : null,
+    merged: heads(r.merged?.nodes).slice(-STABLE_PRS),
+    open: heads(r.open?.nodes).filter((h) => Object.values(h.checks).every((c) => c !== "pending")),
+    methods: { merge: !!r.mergeCommitAllowed, squash: !!r.squashMergeAllowed, rebase: !!r.rebaseMergeAllowed }
+  };
+}
+function mergedIssues(io, slug, labels) {
+  const [owner, name] = slug.split("/");
+  const seen = new Set(labels.filter((l) => !legacyDecision(l.name)).map((l) => l.name));
+  const out = {};
+  for (const l of labels) {
+    const old = legacyDecision(l.name);
+    if (!old)
+      continue;
+    if (seen.has(old.name))
+      out[l.id] = pages((after) => graphql(io, Q.LabelIssues, { owner, name, label: l.name, after }).repository.label.issues);
+    seen.add(old.name);
+  }
+  return out;
+}
+function loadLabels(io, slug) {
+  if (inCloud(io))
+    return restList(io, `repos/${slug}/labels`).map((l) => ({ id: l.node_id, name: l.name, color: l.color, description: l.description ?? null, open: { total: 0, numbers: [] } }));
+  const [owner, name] = slug.split("/");
+  return pages((after) => graphql(io, Q.RepoLabels, { owner, name, after }).repository.labels).map(({ issues, ...l }) => ({
+    ...l,
+    open: { total: issues?.totalCount ?? 0, numbers: (issues?.nodes ?? []).map((i) => i.number) }
+  }));
+}
+function modelModules(text) {
+  const dir = mkdtempSync(path.join(os.tmpdir(), "github-model-"));
+  try {
+    writeFileSync(path.join(dir, "model.ts"), text);
+    writeFileSync(path.join(dir, "modules.mjs"), `const m = await import("./model.ts");
+` + `const paths = (p) => (Array.isArray(p) ? p : [p]).map((x) => String(x).replace(/\\/+$/, ""));
+` + `console.log(JSON.stringify(Object.fromEntries(Object.entries(m.default?.modules ?? {}).map(([k, v]) => [k, paths(v?.path ?? [])]))));
+`);
+    const r = spawnSync(process.execPath, ["--no-env-file", path.join(dir, "modules.mjs")], { encoding: "utf8", timeout: 30000 });
+    if (r.status !== 0)
+      return ((r.stderr || r.error?.message || "").trim().split(`
+`).find((l) => /error/i.test(l)) ?? "the process exited with an error").trim().slice(0, 200);
+    return JSON.parse(r.stdout);
+  } catch (e) {
+    return e.message;
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+}
+function loadDecisions(io, slug) {
+  const [owner, name] = slug.split("/");
+  const r = inCloud(io) ? restSpecTree(io, slug) : graphql(io, Q.SpecDecisions, { owner, name })?.repository ?? {};
+  const dirs = (t) => (t?.entries ?? []).filter((e) => e.type === "tree").map((e) => e.name);
+  const names = { capability: dirs(r.capabilities), standard: dirs(r.standards), architecture: dirs(r.architecture) };
+  let modelError = null;
+  if (r.model) {
+    const mods = modelModules(r.model.text ?? "");
+    if (typeof mods === "string")
+      modelError = mods;
+    else
+      names.architecture.push(...Object.keys(mods));
+  }
+  for (const k of DECISION_KINDS)
+    names[k] = [...new Set(names[k])].sort();
+  return { names, modelError };
+}
+function restSpecTree(io, slug) {
+  const dir = (kind) => {
+    const entries = rest(io, `repos/${slug}/contents/tests/${DECISIONS[kind].dir}`, { missing: true });
+    return Array.isArray(entries) ? { entries: entries.map((e) => ({ name: e.name, type: e.type === "dir" ? "tree" : "blob" })) } : null;
+  };
+  const model = rest(io, `repos/${slug}/contents/${MODEL_PATH}`, { missing: true });
+  return { capabilities: dir("capability"), standards: dir("standard"), architecture: dir("architecture"), model: model?.content ? { text: Buffer.from(model.content, "base64").toString("utf8") } : null };
+}
+function legacyDecision(label) {
+  const i = label.indexOf(":");
+  const kind = label.slice(0, i);
+  return i > 0 && DECISION_KINDS.includes(kind) && label.length > i + 1 ? { kind, name: label.slice(i + 1) } : null;
+}
+var decisionMark = () => `${N.labelMarkers.decision} `;
+var decisionPath = (kind, name) => kind === "architecture" ? locale_default.fill(N.labelMarkers.architecturePath, { name }) : `tests/${DECISIONS[kind].dir}/${name}`;
+var markOf = (description, marks) => marks.map((m) => `${m} `).find((m) => description?.startsWith(m)) ?? null;
+function decisionLabel(name, kinds) {
+  const ks = DECISION_KINDS.filter((k) => kinds.includes(k));
+  const full = decisionMark() + ks.map((k) => decisionPath(k, name)).join("; ");
+  return { name, color: DECISIONS[ks[0]].color, description: full.length <= 100 ? full : decisionMark() + ks.join(", ") };
+}
+function labelKinds(description) {
+  const mark = markOf(description, locale_default.every((n) => n.labelMarkers.decision));
+  if (!mark)
+    return null;
+  const parts = description.slice(mark.length).split(/; |, /);
+  return DECISION_KINDS.filter((k) => parts.some((p) => p === k || p.startsWith(`tests/${DECISIONS[k].dir}`)));
+}
+function labelDimension(description) {
+  const mark = markOf(description, locale_default.every((n) => n.labelMarkers.slice));
+  if (!mark)
+    return null;
+  return description.slice(mark.length).split(" — ")[0].trim() || null;
+}
+function decisionsByName(d) {
+  const out = new Map;
+  for (const k of DECISION_KINDS)
+    for (const n of d.names[k])
+      out.set(n, [...out.get(n) ?? [], k]);
+  return out;
+}
+function loadProject(io, id, withItems = true) {
+  const p = graphql(io, Q.ProjectState, { id }).node;
+  if (!p)
+    throw new GhError(`project ${id} not found or no access (needs the project scope: gh auth refresh -s project)`);
+  const items = withItems ? pages((after) => graphql(io, Q.ProjectItems, { id, after }).node.items) : [];
+  return {
+    ...ref(p),
+    views: p.views.nodes.map((v) => ({
+      id: v.id,
+      number: v.number,
+      name: v.name,
+      layout: v.layout,
+      filter: v.filter ?? null,
+      sortBy: (v.sortByFields?.nodes ?? []).map((s) => s.field?.name).filter(Boolean),
+      columnsBy: (v.verticalGroupByFields?.nodes ?? []).map((f) => f?.name).filter(Boolean)
+    })),
+    fields: p.fields.nodes.filter((f) => f && f.id).map((f) => ({ id: f.id, name: f.name, dataType: f.dataType, isIssueField: !!f.isIssueField, options: f.options ?? null })),
+    workflows: p.workflows.nodes.filter(Boolean),
+    items: items.map((it) => ({
+      id: it.id,
+      issue: it.content?.__typename === "Issue" ? { id: it.content.id, number: it.content.number, state: it.content.state, stateReason: it.content.stateReason ?? null } : null,
+      status: it.status?.name ?? null
+    }))
+  };
+}
+var nums = (xs) => xs.map((x) => `#${x.number}`).join(", ");
+var q = (s) => `«${s}»`;
+function analyze(s) {
+  const p = s.project;
+  const checks = [];
+  const add = (key, title) => {
+    const c = { key, title, problems: [], notes: [] };
+    checks.push(c);
+    return Object.assign((text, ...steps) => c.problems.push({ text, steps }), { note: (text) => c.notes.push(text), skip: (why) => void (c.skip = why) });
+  };
+  const link = add("link", `Project linked to the repository and named ${q(s.repo.name)}`);
+  const merge = () => {
+    if (!s.merge)
+      return;
+    analyzeMerge(s.merge, s.repo.id, add("merge", `Merge into ${s.merge.branch} — only with green required checks`));
+    analyzeMethod(s.merge, s.repo.nameWithOwner, add("method", `PR merge method — rebase only`));
+  };
+  if (!p) {
+    link("no open project is linked to the repository", { kind: "api", text: `find, copy from the template or create project ${q(s.repo.name)} and link it to ${s.repo.nameWithOwner}` });
+    merge();
+    return checks;
+  }
+  const used = p.items.length > 0;
+  const guarded = (text, ...mutations) => ({ kind: used ? "confirm" : "api", text, mutations });
+  const api = (text, ...mutations) => ({ kind: "api", text, mutations });
+  const ui = (text, url) => ({ kind: "ui", text, url });
+  if (p.title !== s.repo.name)
+    link(`title ${q(p.title)}`, guarded(`rename project ${q(p.title)} → ${q(s.repo.name)}`, { op: "RenameProject", input: { projectId: p.id, title: s.repo.name } }));
+  for (const other of s.repo.linked.filter((x) => x.id !== p.id)) {
+    link(`another project is linked: ${q(other.title)} (${other.url})`, { kind: "confirm", text: `unlink project ${q(other.title)} from the repository`, mutations: [{ op: "UnlinkProject", input: { projectId: other.id, repositoryId: s.repo.id } }] });
+  }
+  const views = add("views", `Views ${canonViews().map((v) => q(v.name)).join(", ")} — the right layout, no filter, no others`);
+  const canonNames = new Set(canonViews().map((v) => v.name));
+  const spare = p.views.filter((v) => !canonNames.has(v.name));
+  for (const c of canonViews()) {
+    const v = p.views.find((x) => x.name === c.name);
+    if (!v) {
+      const cand = spare.find((x) => x.layout === c.layout);
+      if (cand) {
+        spare.splice(spare.indexOf(cand), 1);
+        views(`missing ${q(c.name)}`, guarded(`rename view ${q(cand.name)} → ${q(c.name)}`, { op: "UpdateView", input: { viewId: cand.id, name: c.name } }));
+      } else {
+        views(`missing ${q(c.name)}`, api(`create view ${q(c.name)} (${c.layout})`, { op: "CreateView", input: { projectId: p.id, name: c.name, layout: c.layout } }));
+      }
+      continue;
+    }
+    if (v.layout !== c.layout)
+      views(`${q(c.name)} — ${v.layout}`, api(`${q(c.name)}: layout ${c.layout}`, { op: "UpdateView", input: { viewId: v.id, layout: c.layout } }));
+    if (v.filter)
+      views(`${q(c.name)} has filter ${q(v.filter)}`, api(`${q(c.name)}: remove filter ${q(v.filter)}`, { op: "UpdateView", input: { viewId: v.id, filter: "" } }));
+    if (c.layout === "BOARD_LAYOUT" && v.layout === c.layout && v.columnsBy[0] !== STATUS) {
+      views(`${q(c.name)} columns not by Status`, ui(`${q(c.name)}: View options → Column by → Status → Save`, `${p.url}/views/${v.number}`));
+    }
+  }
+  for (const v of spare)
+    views(`extra ${q(v.name)}`, guarded(`delete view ${q(v.name)}`, { op: "DeleteView", input: { viewId: v.id } }));
+  const status = add("status", `${STATUS}: ${statusOptions().join(" → ")}`);
+  const sf = p.fields.find((f) => f.name === STATUS && f.options);
+  if (!sf) {
+    status(`no ${STATUS} field`, api(`create field ${STATUS}`, { op: "CreateField", input: { projectId: p.id, dataType: "SINGLE_SELECT", name: STATUS, singleSelectOptions: statusOptions().map((name) => ({ name, color: "GRAY", description: "" })) } }));
+  } else if (sf.options.map((o) => o.name).join(`
+`) !== statusOptions().join(`
+`)) {
+    const left = [...sf.options];
+    const take = (pred) => {
+      const i = left.findIndex(pred);
+      return i < 0 ? null : left.splice(i, 1)[0];
+    };
+    const aliases = statusAliases();
+    const next = statusOptions().map((name) => {
+      const o = take((x) => x.name === name) ?? take((x) => aliases[x.name.toLowerCase()] === name);
+      return o ? { id: o.id, name, color: o.color, description: o.description ?? "" } : { name, color: "GRAY", description: "" };
+    });
+    const drop = left.length ? `; delete ${left.map((o) => q(o.name)).join(", ")}` : "";
+    status(`options: ${sf.options.map((o) => o.name).join(", ") || "none"}`, guarded(`${STATUS}: ${statusOptions().join(", ")} (rename the existing ones keeping the id${drop})`, { op: "UpdateField", input: { fieldId: sf.id, singleSelectOptions: next } }));
+  }
+  const fields = add("fields", `Fields ${numberFields().map(q).join(", ")} (Number), no other custom ones`);
+  const fieldAlias = fieldAliases();
+  const renamed = new Set;
+  for (const name of numberFields()) {
+    const f = p.fields.find((x) => x.name === name);
+    const create = { op: "CreateField", input: { projectId: p.id, dataType: "NUMBER", name } };
+    const other = f ? undefined : p.fields.find((x) => x.dataType === "NUMBER" && !renamed.has(x) && fieldAlias[x.name] === name);
+    if (other) {
+      renamed.add(other);
+      fields(`missing ${q(name)}`, guarded(`rename field ${q(other.name)} → ${q(name)} (task values are kept)`, { op: "UpdateField", input: { fieldId: other.id, name } }));
+    } else if (!f)
+      fields(`missing ${q(name)}`, api(`create field ${q(name)} (Number)`, create));
+    else if (f.dataType !== "NUMBER")
+      fields(`${q(name)} — ${f.dataType}`, { kind: "confirm", text: `recreate field ${q(name)} as Number (the field's values will be lost)`, mutations: [{ op: "DeleteField", input: { fieldId: f.id } }, create] });
+  }
+  const orgPriority = s.repo.owner.org ? s.repo.owner.issueFields.find((f) => f.name === PRIORITY) : undefined;
+  const isCanon = (f) => BUILTIN_FIELDS.has(f.dataType) || f.name === STATUS || numberFields().includes(f.name) || s.repo.owner.org && f.isIssueField && f.name === PRIORITY;
+  const ownPriority = p.fields.find((f) => f.name === PRIORITY && !f.isIssueField);
+  for (const f of p.fields.filter((x) => !isCanon(x) && x !== ownPriority && !renamed.has(x))) {
+    fields(`extra ${q(f.name)} (${f.dataType}${f.isIssueField ? ", issue field" : ""})`, guarded(`delete field ${q(f.name)}`, { op: "DeleteField", input: { fieldId: f.id } }));
+  }
+  if (ownPriority && !s.repo.owner.org)
+    fields(`extra ${q(PRIORITY)} — a personal account keeps no priority`, guarded(`delete field ${q(PRIORITY)}`, { op: "DeleteField", input: { fieldId: ownPriority.id } }));
+  if (s.repo.owner.org) {
+    const org = s.repo.owner.login;
+    const prio = add("priority", `${PRIORITY} — the organization's issue field in the project, ${q(N.views.table)} and ${q(N.views.board)} are sorted by it`);
+    const connected = p.fields.some((f) => f.isIssueField && f.name === PRIORITY);
+    if (!connected) {
+      const connect = orgPriority ? [{ op: "AddIssueField", input: { projectId: p.id, issueFieldId: orgPriority.id } }] : [];
+      if (ownPriority) {
+        prio(`own project field ${q(PRIORITY)} instead of the issue field`, { kind: "confirm", text: `delete the own field ${q(PRIORITY)} and connect the issue field ${PRIORITY}`, mutations: [{ op: "DeleteField", input: { fieldId: ownPriority.id } }, ...connect] });
+      } else if (orgPriority) {
+        prio(`issue field ${PRIORITY} not connected`, api(`connect the issue field ${PRIORITY}`, ...connect));
+      }
+      if (!orgPriority)
+        prio(`the organization has no issue field ${PRIORITY}`, ui(`create the issue field ${PRIORITY} (single select: Urgent, High, Medium, Low), then fix again`, `https://github.com/organizations/${org}/settings/issue-fields`));
+    }
+    for (const name of [N.views.table, N.views.board]) {
+      const v = p.views.find((x) => x.name === name);
+      if (v && v.sortBy[0] !== PRIORITY)
+        prio(`${q(name)} not sorted by ${PRIORITY}`, ui(`${q(name)}: View options → Sort by → ${PRIORITY} → Save`, `${p.url}/views/${v.number}`));
+    }
+    const types = add("types", `Issue types of the organization: ${issueTypes().join(", ")} — and only these`);
+    const t = s.repo.owner.issueTypes;
+    const url = `https://github.com/organizations/${org}/settings/issue-types`;
+    const claimed = new Set;
+    const aliases = typeAliases();
+    for (const name of issueTypes()) {
+      const exact = t.find((x) => x.name === name);
+      if (exact) {
+        claimed.add(exact.id);
+        if (!exact.isEnabled)
+          types(`${q(name)} disabled`, { kind: "confirm", text: `enable type ${q(name)}`, url, mutations: [{ op: "UpdateIssueType", input: { issueTypeId: exact.id, isEnabled: true } }] });
+        continue;
+      }
+      const alias = t.find((x) => !claimed.has(x.id) && aliases[x.name.toLowerCase()] === name);
+      if (alias) {
+        claimed.add(alias.id);
+        types(`missing ${q(name)}`, { kind: "confirm", text: `rename type ${q(alias.name)} → ${q(name)}`, url, mutations: [{ op: "UpdateIssueType", input: { issueTypeId: alias.id, name, isEnabled: true } }] });
+      } else {
+        types(`missing ${q(name)}`, { kind: "confirm", text: `create type ${q(name)}`, url, mutations: [{ op: "CreateIssueType", input: { ownerId: s.repo.owner.id, name, isEnabled: true, color: name === N.issueTypes.epic ? "PURPLE" : name === N.issueTypes.bug ? "RED" : "GRAY" } }] });
+      }
+    }
+    for (const x of t.filter((x) => x.isEnabled && !claimed.has(x.id))) {
+      types(`extra ${q(x.name)}`, { kind: "confirm", text: `disable type ${q(x.name)}`, url, mutations: [{ op: "UpdateIssueType", input: { issueTypeId: x.id, isEnabled: false } }] });
+    }
+  }
+  const wf = add("workflows", `Workflows ${[WORKFLOW_ADDED, WORKFLOW_CLOSED, WORKFLOW_AUTO_ADD].map(q).join(", ")} are on`);
+  const how = {
+    [WORKFLOW_ADDED]: `Edit → Set value → ${STATUS}: ${N.status.backlog}`,
+    [WORKFLOW_CLOSED]: `Edit → Set value → ${STATUS}: ${N.status.done}`,
+    [WORKFLOW_AUTO_ADD]: `Edit → repository ${s.repo.name}, filter is:issue is:open (Enter)`
+  };
+  for (const name of [WORKFLOW_ADDED, WORKFLOW_CLOSED, WORKFLOW_AUTO_ADD]) {
+    const w = p.workflows.find((x) => x.name === name);
+    if (w?.enabled)
+      continue;
+    wf(`${q(name)} ${w ? "disabled" : "not configured"}`, ui(`${q(name)}: ${how[name]} → Save and turn on workflow`, `${p.url}/workflows${w ? `/${w.fullDatabaseId}` : ""}`));
+  }
+  const opt = (name) => sf?.options?.find((o) => o.name === name)?.id;
+  const setStatus = (it, name) => ({ op: "SetItemStatus", input: { projectId: p.id, itemId: it.id, fieldId: sf.id, value: { singleSelectOptionId: opt(name) } } });
+  const statusReady = !!(opt(N.status.backlog) && opt(N.status.done));
+  const closedAdd = add("closed", `Closed tasks — in ${q(N.status.done)}, closed without being done — outside the project`);
+  const issues = p.items.filter((it) => it.issue);
+  const doneAlias = statusAliases();
+  const notDone = issues.filter((it) => it.issue.state === "CLOSED" && !NOT_DONE_REASONS.has(it.issue.stateReason ?? "") && doneAlias[(it.status ?? "").toLowerCase()] !== N.status.done);
+  if (notDone.length) {
+    const steps = [];
+    if (statusReady)
+      steps.push(api(`${STATUS} ${q(N.status.done)}: ${nums(notDone.map((it) => it.issue))}`, ...notDone.map((it) => setStatus(it, N.status.done))));
+    const closed = p.workflows.find((x) => x.name === WORKFLOW_CLOSED);
+    if (closed?.enabled)
+      steps.push({ ...ui(`${q(WORKFLOW_CLOSED)}: check Set value → ${STATUS}: ${N.status.done}, otherwise Edit → ${N.status.done} → Save`, `${p.url}/workflows/${closed.fullDatabaseId}`), sticky: true });
+    closedAdd(`not in ${q(N.status.done)}: ${nums(notDone.map((it) => it.issue))}`, ...steps);
+  }
+  const dropped = issues.filter((it) => it.issue.state === "CLOSED" && NOT_DONE_REASONS.has(it.issue.stateReason ?? ""));
+  if (dropped.length)
+    closedAdd(`closed without being done, but in the project: ${nums(dropped.map((it) => it.issue))}`, api(`remove from the project ${nums(dropped.map((it) => it.issue))}`, ...dropped.map((it) => ({ op: "DeleteItem", input: { projectId: p.id, itemId: it.id } }))));
+  const open = add("open", `Open tasks of the repository — in the project, with ${STATUS}`);
+  const inProject = new Set(issues.map((it) => it.issue.id));
+  const missing = s.openIssues.filter((i) => !inProject.has(i.id));
+  if (missing.length)
+    open(`not in the project: ${nums(missing)}`, api(`add to the project ${nums(missing)}`, ...missing.map((i) => ({ op: "AddItem", input: { projectId: p.id, contentId: i.id } }))));
+  const noStatus = issues.filter((it) => it.issue.state === "OPEN" && !it.status);
+  if (noStatus.length)
+    open(`without ${STATUS}: ${nums(noStatus.map((it) => it.issue))}`, ...statusReady ? [api(`${STATUS} ${q(N.status.backlog)}: ${nums(noStatus.map((it) => it.issue))}`, ...noStatus.map((it) => setStatus(it, N.status.backlog)))] : []);
+  const labels = add("labels", "Decision labels — the decision's name, the kind by color; by the spec tree and the model of the default branch");
+  const d = s.decisions;
+  if (d.modelError)
+    labels(`model ${MODEL_PATH} doesn't load — module labels aren't checked: ${d.modelError}`);
+  const want = decisionsByName(d);
+  const unsure = (kinds) => !!d.modelError && kinds.includes("architecture");
+  const taken = new Map(s.labels.filter((l) => !legacyDecision(l.name)).map((l) => [l.name, l]));
+  const orphans = [];
+  const dimensions = new Map;
+  for (const l of s.labels) {
+    const old = legacyDecision(l.name);
+    if (!old)
+      continue;
+    const to = decisionLabel(old.name, want.get(old.name) ?? [old.kind]);
+    const into = taken.get(old.name);
+    if (!into) {
+      taken.set(old.name, { ...l, ...to });
+      labels(`label ${q(l.name)} of the old form \`kind:name\``, api(`rename label ${q(l.name)} → ${q(old.name)} (tasks keep it)`, { op: "UpdateLabel", input: { id: l.id, ...to } }));
+      continue;
+    }
+    const issues = s.labelIssues[l.id] ?? [];
+    labels(`label ${q(l.name)} of the old form, label ${q(old.name)} already exists`, {
+      kind: "confirm",
+      text: `merge label ${q(l.name)} into ${q(old.name)}: ${issues.length ? `${nums(issues)} get ${q(old.name)}, ` : ""}the old one is deleted`,
+      mutations: [...issues.map((i) => ({ op: "AddLabels", input: { labelableId: i.id, labelIds: [into.id] } })), { op: "DeleteLabel", input: { id: l.id } }]
+    });
+  }
+  for (const l of s.labels) {
+    if (legacyDecision(l.name))
+      continue;
+    const kinds = labelKinds(l.description);
+    const w = want.get(l.name);
+    if (!w) {
+      if (kinds)
+        orphans.push({ label: l, kinds });
+      continue;
+    }
+    const dim = labelDimension(l.description);
+    if (dim) {
+      dimensions.set(dim, [...dimensions.get(dim) ?? [], l.name]);
+      continue;
+    }
+    const to = decisionLabel(l.name, w);
+    if (!kinds) {
+      labels(`label ${q(l.name)} isn't a decision label, but decision ${l.name} is in the default branch`, { kind: "confirm", text: `make ${q(l.name)} a decision label: color ${to.color}, description ${q(to.description)}`, mutations: [{ op: "UpdateLabel", input: { id: l.id, color: to.color, description: to.description } }] });
+      continue;
+    }
+    const recolor = l.color.toLowerCase() !== to.color.toLowerCase();
+    if (!recolor && (l.description === to.description || unsure(kinds)))
+      continue;
+    const text = recolor ? `label ${q(l.name)} is colored ${l.color}, not ${to.color}` : `label ${q(l.name)}: wrong decision kinds in the description`;
+    labels(text, api(`${recolor ? "recolor" : "rewrite the description of"} label ${q(l.name)}: ${to.color}, ${q(to.description)}`, { op: "UpdateLabel", input: { id: l.id, color: to.color, description: to.description } }));
+  }
+  for (const [dim, names] of dimensions) {
+    labels.note(`slice ${q(dim)}: labels ${names.map(q).join(", ")} aren't decision labels, decisions of the same name aren't labeled`);
+  }
+  const unlabeled = [...want.keys()].filter((n) => !taken.has(n));
+  const sure = orphans.filter((o) => !unsure(o.kinds));
+  for (const { label: l } of sure.filter((o) => o.label.open.total)) {
+    const more = l.open.total - l.open.numbers.length;
+    labels.note(`new decision ${q(l.name)}: not in the default branch yet, the label is on open tasks ${l.open.numbers.map((n) => `#${n}`).join(", ")}${more > 0 ? ` and ${more} more` : ""}`);
+  }
+  const live = sure.filter((o) => !o.label.open.total);
+  const paired = new Set;
+  for (const kind of DECISION_KINDS) {
+    const os2 = live.filter((o) => o.kinds.includes(kind) && !paired.has(o.label.id));
+    const ms = unlabeled.filter((n) => want.get(n).includes(kind) && !paired.has(n));
+    if (os2.length !== 1 || ms.length !== 1)
+      continue;
+    const o = os2[0].label;
+    const to = decisionLabel(ms[0], want.get(ms[0]));
+    paired.add(o.id).add(to.name);
+    labels(`label ${q(o.name)} without a decision, decision ${to.name} without a label`, { kind: "confirm", text: `rename label ${q(o.name)} → ${q(to.name)} (tasks keep it)`, mutations: [{ op: "UpdateLabel", input: { id: o.id, ...to } }] });
+  }
+  for (const { label: o } of live.filter((x) => !paired.has(x.label.id))) {
+    labels(`label ${q(o.name)} without a decision in the default branch, no open tasks have it`, { kind: "confirm", text: `delete label ${q(o.name)}`, mutations: [{ op: "DeleteLabel", input: { id: o.id } }] });
+  }
+  const fresh = unlabeled.filter((n) => !paired.has(n)).map((n) => decisionLabel(n, want.get(n)));
+  if (fresh.length) {
+    labels(`decisions without a label: ${fresh.map((x) => x.name).join(", ")}`, api(`create labels ${fresh.map((x) => q(x.name)).join(", ")}`, ...fresh.map((x) => ({ op: "CreateLabel", input: { repositoryId: s.repo.id, ...x } }))));
+  }
+  merge();
+  return checks;
+}
+function rulesetInput(contexts) {
+  return {
+    name: RULESET,
+    target: "BRANCH",
+    enforcement: "ACTIVE",
+    conditions: { refName: { include: ["~DEFAULT_BRANCH"], exclude: [] } },
+    rules: [{ type: "REQUIRED_STATUS_CHECKS", parameters: { requiredStatusChecks: { requiredStatusChecks: contexts.map((context) => ({ context })), strictRequiredStatusChecksPolicy: false } } }],
+    bypassActors: [{ repositoryRoleDatabaseId: ADMIN_ROLE, bypassMode: "ALWAYS" }]
+  };
+}
+function analyzeMerge(m, repositoryId, merge) {
+  if (m.unavailable)
+    return merge.skip(`branch rules are unavailable: ${m.unavailable}`);
+  const fresh = [...m.merged.slice(-1), ...m.open];
+  const gone = (c) => fresh.find((h) => !(c in h.checks));
+  const stable = Object.keys(m.merged[0]?.checks ?? {}).filter((c) => m.merged.every((h) => h.checks[c] === "pass") && !gone(c)).sort();
+  const enforced = m.rules.some((r) => r.contexts.length);
+  const list = (cs) => cs.map(q).join(", ");
+  const none = `the last merged PRs have no common green check — nothing to make required`;
+  const own = m.own;
+  if (!own) {
+    if (enforced)
+      return;
+    if (!stable.length)
+      return merge.skip(none);
+    const text = `create ruleset ${q(RULESET)} on ${m.branch}: required ${list(stable)}, bypass — admin`;
+    const step = { kind: "api", text, mutations: [{ op: "CreateRuleset", input: { sourceId: repositoryId, ...rulesetInput(stable) } }] };
+    return merge(`no rule with required checks: a branch with a red check can be merged`, step);
+  }
+  const want = [...new Set([...own.contexts.filter((c) => !gone(c)), ...stable])].sort();
+  const named = own.name === RULESET ? q(RULESET) : `${q(own.name)} → ${q(RULESET)}`;
+  const step = { kind: "api", text: `ruleset ${named}: default branch, required ${list(want) || "—"}, bypass — admin`, mutations: [{ op: "UpdateRuleset", input: { repositoryRulesetId: own.id, ...rulesetInput(want) } }] };
+  const why = [];
+  if (own.name !== RULESET)
+    why.push(`ruleset ${q(own.name)} — the flow's former name: fix renames it to ${q(RULESET)}`);
+  if (own.enforcement !== "ACTIVE")
+    why.push(`ruleset ${q(own.name)} — ${own.enforcement}, not in effect`);
+  if (!own.include.includes("~DEFAULT_BRANCH"))
+    why.push(`ruleset ${q(own.name)} is not on the default branch: ${own.include.join(", ") || "—"}`);
+  if (own.strict)
+    why.push(`ruleset ${q(own.name)}: strict is on — GitHub won't merge a branch that fell behind`);
+  if (!own.bypassAdmin)
+    why.push(`ruleset ${q(own.name)}: admin can't bypass — no direct push to ${m.branch}`);
+  for (const c of own.contexts.filter((x) => gone(x)))
+    why.push(`required ${q(c)} didn't come to PR #${gone(c).number} — the PR would wait for it forever`);
+  const add = stable.filter((c) => !own.contexts.includes(c));
+  if (add.length)
+    why.push(`green on the last ${m.merged.length} merged PRs, but not required: ${list(add)}`);
+  for (const w of why)
+    merge(w, step);
+  if (!why.length && !enforced && !want.length)
+    merge.skip(none);
+}
+function analyzeMethod(m, slug, method) {
+  const step = {
+    kind: "api",
+    text: "keep only rebase: turn off merge commit and squash, turn on rebase",
+    url: `https://github.com/${slug}/settings`,
+    mutations: [{ op: "UpdateRepository", input: { repo: slug, allow_merge_commit: false, allow_squash_merge: false, allow_rebase_merge: true } }]
+  };
+  if (!m.methods.rebase)
+    method("rebase is off — GitHub will refuse gh pr merge --rebase", step);
+  if (m.methods.merge)
+    method("merge commit is allowed", step);
+  if (m.methods.squash)
+    method("squash is allowed", step);
+}
+function header(io, s) {
+  io.out(`Project ${s.repo.nameWithOwner}: ${s.project ? s.project.url : "none"}`);
+}
+function report(io, s, checks) {
+  for (const c of checks) {
+    if (c.skip) {
+      io.out(`➖ ${c.title} — ${c.skip}`);
+      continue;
+    }
+    io.out(`${c.problems.length ? "❌" : "✅"} ${c.title}`);
+    for (const pr of c.problems)
+      io.out(`   · ${pr.text}`);
+    for (const n of c.notes)
+      io.out(`   ○ ${n}`);
+  }
+  if (s.project && !s.repo.owner.org)
+    io.out(`➖ ${PRIORITY} and issue types — a personal account has none`);
+  return checks.every((c) => !c.problems.length);
+}
+function cmdCheck(io, slug) {
+  const s = loadState(io, slug);
+  header(io, s);
+  return report(io, s, analyze(s)) ? 0 : 1;
+}
+function ensureProject(io, s, template) {
+  const found = graphql(io, Q.OwnerProjects, { login: s.repo.owner.login, query: s.repo.name })?.repositoryOwner?.projectsV2?.nodes ?? [];
+  const same = found.find((p) => p && p.title === s.repo.name && !p.closed);
+  const link = (p) => mutate(io, { op: "LinkProject", input: { projectId: p.id, repositoryId: s.repo.id } });
+  if (same) {
+    link(same);
+    return `linked project ${q(same.title)} (${same.url})`;
+  }
+  if (template) {
+    const [login, number] = template.split("/");
+    let tpl = null;
+    try {
+      tpl = graphql(io, Q.TemplateProject, { login, number: Number(number) })?.repositoryOwner?.projectV2 ?? null;
+    } catch (e) {
+      io.err(`template ${template} is unavailable: ${e.message}`);
+    }
+    if (tpl) {
+      const copy = mutate(io, { op: "CopyProject", input: { projectId: tpl.id, ownerId: s.repo.owner.id, title: s.repo.name, includeDraftIssues: false } }).copyProjectV2.projectV2;
+      link(copy);
+      return `project ${q(s.repo.name)} — a copy of template ${template} (${copy.url}), linked`;
+    }
+    io.err(`template ${template} not found — the project is created from scratch`);
+  }
+  const created = mutate(io, { op: "CreateProject", input: { ownerId: s.repo.owner.id, title: s.repo.name, repositoryId: s.repo.id } }).createProjectV2.projectV2;
+  return `created project ${q(s.repo.name)} (${created.url}), linked`;
+}
+function cmdFix(io, slug, opts) {
+  const done = [];
+  const failed = [];
+  const tried = new Set;
+  const sticky = [];
+  let s = loadState(io, slug);
+  for (let round = 0;round < 5; round++) {
+    if (!s.project) {
+      try {
+        done.push(ensureProject(io, s, opts.template));
+      } catch (e) {
+        failed.push(`project: ${e.message}`);
+        break;
+      }
+      s = loadState(io, slug);
+      if (!s.project)
+        break;
+      continue;
+    }
+    const all = analyze(s).flatMap((c) => c.problems.flatMap((pr) => pr.steps));
+    sticky.push(...all.filter((st) => st.sticky));
+    const steps = all.filter((st) => st.mutations?.length && (st.kind === "api" || st.kind === "confirm" && opts.confirm) && !tried.has(st.text));
+    if (!steps.length)
+      break;
+    for (const st of steps) {
+      if (tried.has(st.text))
+        continue;
+      tried.add(st.text);
+      try {
+        for (const m of st.mutations)
+          mutate(io, m);
+        done.push(st.text);
+      } catch (e) {
+        failed.push(`${st.text}: ${e.message}${st.url ? ` — in the UI: ${st.url}` : ""}`);
+      }
+    }
+    s = loadState(io, slug);
+  }
+  header(io, s);
+  for (const d of done)
+    io.out(`+ ${d}`);
+  for (const f of failed)
+    io.out(`! ${f}`);
+  const checks = analyze(s);
+  const left = [...sticky, ...checks.flatMap((c) => c.problems.flatMap((pr) => pr.steps))];
+  const uniq = (xs) => xs.filter((x, i) => xs.findIndex((y) => y.text === x.text) === i);
+  const ui = uniq(left.filter((st) => st.kind === "ui"));
+  const confirm = uniq(left.filter((st) => st.kind === "confirm" && !opts.confirm));
+  if (ui.length) {
+    io.out("UI steps — in the session's browser, without a browser — for the user; then check again:");
+    ui.forEach((st, i) => io.out(`${i + 1}. ${st.text} — ${st.url}`));
+  }
+  if (confirm.length) {
+    io.out("Confirmation needed from the user — then fix --confirm:");
+    confirm.forEach((st, i) => io.out(`${i + 1}. ${st.text}${st.url ? ` (or in the UI: ${st.url})` : ""}`));
+  }
+  io.out("Summary:");
+  const ok = report(io, s, checks);
+  return ok && !failed.length && !ui.length && !confirm.length ? 0 : 1;
+}
+var blockerRef = (slug, b) => b.repo.toLowerCase() === slug.toLowerCase() ? `#${b.number}` : `${b.repo}#${b.number}`;
+function loadIssue(io, slug, number) {
+  if (inCloud(io))
+    return restLoadIssue(io, slug, number);
+  const [owner, name] = slug.split("/");
+  const i = graphql(io, Q.IssueRef, { owner, name, number })?.repository?.issue;
+  if (!i)
+    throw new GhError(`no issue #${number} in ${slug}`);
+  return {
+    id: i.id,
+    number: i.number,
+    title: i.title,
+    state: i.state,
+    stateReason: i.stateReason ?? null,
+    url: i.url,
+    type: i.issueType?.name ?? null,
+    labels: (i.labels?.nodes ?? []).map((l) => l.name),
+    parent: i.parent ? { id: i.parent.id, number: i.parent.number } : null,
+    subIssues: i.subIssues?.nodes ?? [],
+    blockers: (i.blockedBy?.nodes ?? []).map((b) => ({ number: b.number, state: b.state, repo: b.repository?.nameWithOwner ?? slug })),
+    milestone: i.milestone ? { id: i.milestone.id, number: i.milestone.number, title: i.milestone.title, open: i.milestone.issues?.totalCount ?? 0 } : null,
+    prs: (i.closedByPullRequestsReferences?.nodes ?? []).map((p) => ({ number: p.number, state: p.state ?? "", merged: Boolean(p.merged), head: p.headRefName ?? "", base: p.baseRefName ?? "main" })),
+    items: (i.projectItems?.nodes ?? []).map((it) => ({ id: it.id, projectId: it.project.id, status: it.status?.name ?? null })),
+    priority: (i.issueFieldValues?.nodes ?? []).find((v) => v?.field?.name === PRIORITY)?.name ?? null
+  };
+}
+function restLoadIssue(io, slug, number) {
+  const i = restIssue(io, slug, number);
+  if (!i)
+    throw new GhError(`no issue #${number} in ${slug}`);
+  const l = restLinks(io, slug, number);
+  return {
+    id: i.id,
+    databaseId: i.databaseId,
+    rest: `repos/${slug}/issues/${number}`,
+    number: i.number,
+    title: i.title,
+    state: i.state,
+    stateReason: i.stateReason,
+    url: i.url,
+    type: i.issueType?.name ?? null,
+    labels: i.labels.nodes.map((x) => x.name),
+    parent: l.parent ? { id: l.parent.id, number: l.parent.number } : null,
+    subIssues: l.subIssues.nodes.map((x) => ({ number: x.number, state: x.state, title: x.title })),
+    blockers: l.blockedBy.nodes.map((b) => ({ number: b.number, state: b.state, repo: b.repository.nameWithOwner })),
+    milestone: i.milestone,
+    prs: [],
+    items: [],
+    priority: null
+  };
+}
+function taskContext(io, slug) {
+  const repo = loadRepo(io, slug);
+  const main = mainProject(repo);
+  if (!main)
+    throw new GhError(`no project is linked to ${slug} — github project fix first`);
+  const project = loadProject(io, main.id, false);
+  const status = project.fields.find((f) => f.name === STATUS && f.options);
+  const onBoard = (n) => !!status && [n.status.backlog, n.status.inProgress, n.status.done].every((name) => status.options.some((o) => o.name === name));
+  const board = onBoard(N) ? N : locale_default.everyNames().find(onBoard);
+  if (!status || !board)
+    throw new GhError(`the project's ${STATUS} is not per the canon — github project fix first`);
+  N = board;
+  return { slug, repo, project, status };
+}
+var isEpic = (i, org) => org ? locale_default.every((n) => n.issueTypes.epic).includes(i.type ?? "") : i.labels.includes(EPIC_LABEL);
+var itemIn = (ctx, i) => i.items.find((it) => it.projectId === ctx.project.id) ?? null;
+function setStatus(io, ctx, itemId, name) {
+  const optionId = ctx.status.options.find((o) => o.name === name).id;
+  mutate(io, { op: "SetItemStatus", input: { projectId: ctx.project.id, itemId, fieldId: ctx.status.id, value: { singleSelectOptionId: optionId } } });
+}
+function ensureItem(io, ctx, i) {
+  const it = itemIn(ctx, i);
+  if (it)
+    return { id: it.id, added: false };
+  try {
+    return { id: mutate(io, { op: "AddItem", input: { projectId: ctx.project.id, contentId: i.id } }).addProjectV2ItemById.item.id, added: true };
+  } catch (e) {
+    if (!/already exists/i.test(e.message))
+      throw e;
+  }
+  for (let k = 0;k < 5; k++) {
+    (io.sleep ?? pause)(1000);
+    const again = itemIn(ctx, loadIssue(io, ctx.slug, i.number));
+    if (again)
+      return { id: again.id, added: false };
+  }
+  throw new GhError(`#${i.number} is already in the project, but its item isn't visible — retry: github task status ${i.number} <status>`);
+}
+function configDir(env) {
+  const home = env.HOME || os.homedir();
+  const dir = env.ELVES_CONFIG_DIR || env.AI_DEV_CONFIG_DIR || [path.join(home, ".config", "elves"), path.join(home, ".config", "ai-dev")].find((d) => existsSync(d)) || path.join(home, ".config", "elves");
+  if (existsSync(dir))
+    return dir;
+  const legacy = path.join(home, ".claude", "est");
+  return lstatSync(legacy, { throwIfNoEntry: false })?.isDirectory() ? legacy : dir;
+}
+function pinFile(io) {
+  const id = io.env.CLAUDE_CODE_SESSION_ID;
+  return id ? path.join(configDir(io.env), "sessions", id) : null;
+}
+function sessionPin(text) {
+  const m = /^([\w.-]+\/[\w.-]+)#(\d+)$/.exec(text.trim());
+  return m ? { slug: m[1], number: Number(m[2]) } : null;
+}
+function pinLine(slug, number) {
+  return `${slug}#${number}
+`;
+}
+function pinnedTask(io) {
+  const file = pinFile(io);
+  if (!file || !existsSync(file))
+    return null;
+  const line = readFileSync(file, "utf8").trim();
+  return { file, line, task: sessionPin(line) };
+}
+function queueQuestion(slug, number, epic) {
+  return `the question to the owner «queue #${number}?» — yes: a background subagent in its own worktree, its prompt: ${executorPrompt(slug, number, epic)}`;
+}
+function anotherTask(runs, file, slug, number, epic) {
+  return new GhError(`the session runs ${runs}; #${number} isn't taken here — ${queueQuestion(slug, number, epic)} (pin: ${file} — a mistaken one is removed by a human)`);
+}
+function pinTask(io, slug, number, epic) {
+  const file = pinFile(io);
+  if (!file)
+    return io.out("○ session not recognized (no CLAUDE_CODE_SESSION_ID) — the task isn't pinned");
+  const task = `${slug}#${number}`;
+  const held = pinnedTask(io)?.task;
+  const runs = held ? `${held.slug}#${held.number}` : null;
+  if (runs === task)
+    return;
+  if (handedOut(io, slug).some((h) => h.number === number)) {
+    return io.out(`○ #${number} is handed out to an executor of this session — not pinned: the executor is a subagent with the session's id, est links the work by «${N.subagentPrompt.task} #${number}» in the assignment`);
+  }
+  if (runs)
+    throw anotherTask(runs, file, slug, number, epic);
+  if (isDispatcher(io)) {
+    return io.out(`○ dispatcher session: #${number} isn't pinned — its executor is a subagent with the session's id, est links the work by «${N.subagentPrompt.task} #${number}» in the assignment`);
+  }
+  const created = (f, text) => {
+    try {
+      writeFileSync(f, text, { flag: "wx" });
+      return true;
+    } catch (e) {
+      if (e?.code !== "EEXIST")
+        throw e;
+      return false;
+    }
+  };
+  mkdirSync(path.dirname(file), { recursive: true });
+  created(path.join(path.dirname(file), ".gitignore"), `*
+`);
+  if (created(file, pinLine(slug, number)))
+    return;
+  const now = pinnedTask(io);
+  if (!now.task) {
+    writeFileSync(file, pinLine(slug, number));
+    return io.out(`○ the session pin ${file} held «${now.line}», not owner/repo#N — replaced with ${task}`);
+  }
+  const pinnedNow = `${now.task.slug}#${now.task.number}`;
+  if (pinnedNow !== task)
+    throw anotherTask(pinnedNow, file, slug, number, epic);
+}
+function dispatcherFile(io) {
+  const id = io.env.CLAUDE_CODE_SESSION_ID;
+  return id ? path.join(configDir(io.env), "dispatchers", id) : null;
+}
+var isDispatcher = (io) => {
+  const file = dispatcherFile(io);
+  return !!file && existsSync(file);
+};
+var handedOutFile = (io) => {
+  const file = dispatcherFile(io);
+  return file && `${file}.tasks`;
+};
+var CLOUD_HANDOUT = "@cloud";
+function handedOut(io, slug) {
+  const file = handedOutFile(io);
+  return file ? handOutsIn(file, slug) : [];
+}
+function handOutsIn(file, slug) {
+  if (!existsSync(file))
+    return [];
+  const lines = readFileSync(file, "utf8").split(`
+`).map((l) => l.trim());
+  return lines.filter((l) => l.startsWith(`${slug}#`)).map((l) => {
+    const [number, ...rest] = l.slice(slug.length + 1).split(" ");
+    const worktree = rest.join(" ").trim();
+    return { number: Number(number), worktree: worktree === CLOUD_HANDOUT ? null : worktree || null, cloud: worktree === CLOUD_HANDOUT };
+  }).filter((h) => Number.isInteger(h.number) && h.number > 0);
+}
+function realPath(p) {
+  try {
+    return realpathSync(p);
+  } catch {
+    return path.resolve(p);
+  }
+}
+function epicPrefix(title) {
+  const i = title.indexOf(" · ");
+  return i > 0 ? title.slice(0, i) : null;
+}
+var taskTemplate = (type) => type === N.issueTypes.epic ? `${N.sections.questions}
+` : `${N.sections.scenarios}
+
+${N.sections.questions}
+`;
+var sameTitles = (title) => [title, ...locale_default.everyNames().filter((n) => n.updateTask === title).map((n) => n.formerly.updateTask)];
+function cmdTaskNew(io, slug, task) {
+  const [owner, name] = slug.split("/");
+  const cloud = inCloud(io);
+  const ctx = cloud ? null : taskContext(io, slug);
+  const org = ctx ? ctx.repo.owner.org : rest(io, `repos/${slug}`).owner?.type === "Organization";
+  const type = typeAliases()[task.type.toLowerCase()];
+  if (!type)
+    throw new GhError(`--type: ${issueTypes().join(", ")}`);
+  const branchType = task.branchType?.trim().toLowerCase() || (type === N.issueTypes.bug ? "fix" : "");
+  if (type === N.issueTypes.epic) {
+    if (branchType)
+      throw new GhError("an epic has no branch and isn't estimated — --branch-type is for a task or a bug");
+  } else if (!branchType)
+    throw new GhError(`--branch-type is required for a task: ${TASK_TYPES.join(", ")} — the type of its branch and of its estimate`);
+  else if (!TASK_TYPES.includes(branchType))
+    throw new GhError(`--branch-type: ${TASK_TYPES.join(", ")}`);
+  const o = { ...task, type, body: task.body.trim() ? task.body : taskTemplate(type) };
+  const issueType = org && ctx ? ctx.repo.owner.issueTypes.find((t) => t.name === o.type && t.isEnabled) : undefined;
+  if (org && ctx && !issueType)
+    throw new GhError(`the organization has no enabled type ${q(o.type)} — github project fix`);
+  if (!org && o.priority)
+    throw new GhError("a personal account has no issue fields — no priority is kept, --priority isn't needed");
+  if (org && !ctx && o.priority && !PRIORITIES.includes(o.priority))
+    throw new GhError(`--priority: ${PRIORITIES.join(", ")}`);
+  let priority = null;
+  if (org && ctx) {
+    const f = ctx.repo.owner.issueFields.find((x) => x.name === PRIORITY);
+    if (!f)
+      throw new GhError(`the organization has no issue field ${PRIORITY} — github project fix`);
+    const want = o.priority ?? DEFAULT_PRIORITY;
+    const opt = f.options.find((x) => x.name === want);
+    if (!opt)
+      throw new GhError(`--priority: ${f.options.map((x) => x.name).join(", ")}`);
+    priority = { fieldId: f.id, optionId: opt.id, name: want };
+  }
+  let title = o.title.trim();
+  const epic = o.epic === undefined ? null : loadIssue(io, slug, o.epic);
+  if (epic) {
+    if (!isEpic(epic, org))
+      throw new GhError(`#${epic.number} is not an epic (${org ? `the type is not ${q(N.issueTypes.epic)}` : `no ${EPIC_LABEL} label`})`);
+    if (epic.state !== "OPEN")
+      throw new GhError(`epic #${epic.number} is closed`);
+    const prefix = epicPrefix(epic.title);
+    if (prefix && !title.startsWith(`${prefix} · `))
+      title = `${prefix} · ${title}`;
+  }
+  const blockers = o.blockedBy.map((n) => loadIssue(io, slug, n));
+  const needCtx = !!o.milestone || !org && o.type === N.issueTypes.epic;
+  const restCtx = () => {
+    const label = rest(io, `repos/${slug}/labels/${EPIC_LABEL}`, { missing: true });
+    return { label: label && { id: label.node_id }, milestones: { nodes: restList(io, `repos/${slug}/milestones?state=open`).map((m) => ({ id: m.node_id, number: m.number, title: m.title })) } };
+  };
+  const repoCtx = !needCtx ? null : cloud ? restCtx() : graphql(io, Q.TaskContext, { owner, name }).repository;
+  const milestone = o.milestone ? repoCtx.milestones.nodes.find((m) => m.title === o.milestone) : undefined;
+  if (o.milestone && !milestone)
+    throw new GhError(`no open milestone ${q(o.milestone)}`);
+  const openIssues = cloud ? restList(io, `repos/${slug}/issues?state=open`).filter((i) => !i.pull_request) : null;
+  for (const same of sameTitles(title)) {
+    const found = openIssues ?? graphql(io, Q.IssueSearch, { q: `repo:${slug} is:issue is:open in:title "${same.replaceAll('"', "")}"` }).search.nodes;
+    const dup = found.find((x) => x?.title === same);
+    if (dup)
+      throw new GhError(`an open task with this title already exists: #${dup.number}${same === title ? "" : ` (${q(same)} — its title before the flow's rename)`}`);
+  }
+  const wanted = [...new Set(o.labels ?? [])];
+  const open = questionItems(o.body).filter((x) => !x.answered).map((x) => x.k);
+  const repoLabels = wanted.length || open.length ? loadLabels(io, slug) : [];
+  const has = (n) => repoLabels.find((x) => x.name === n);
+  const decisions = wanted.some((l) => legacyDecision(l) || !has(l)) ? loadDecisions(io, slug) : null;
+  const inMain = decisions ? decisionsByName(decisions) : new Map;
+  const plan = wanted.map((l) => {
+    const dec = legacyDecision(l);
+    const name = dec?.name ?? l;
+    const label = has(name);
+    const main = inMain.get(name) ?? [];
+    const kinds = dec && !main.includes(dec.kind) ? [...main, dec.kind] : main;
+    const dim = dec && label ? labelDimension(label.description) : null;
+    if (dim)
+      throw new GhError(`label ${q(name)} is slice ${q(dim)}, not a decision label: decision ${name} isn't labeled; the slice label — --labels ${name}`);
+    if (!label && !kinds.length) {
+      throw new GhError(`no label ${q(l)} in the repository and no decision ${l} in the default branch; a new decision — kind:name (${DECISION_KINDS.map((k) => `${k}:${l}`).join(", ")})`);
+    }
+    return { name, label, kinds, decision: dec !== null || (label ? labelKinds(label.description) !== null : true), fresh: dec && !main.includes(dec.kind) ? `${name} — new decision: ${decisionPath(dec.kind, name)} is not in the default branch yet` : null };
+  });
+  const done = [];
+  const createLabel = (label) => ctx ? mutate(io, { op: "CreateLabel", input: { repositoryId: ctx.repo.id, ...label } }).createLabel.label.id : rest(io, `repos/${slug}/labels`, { method: "POST", payload: label }).node_id;
+  const labels = [];
+  if (issueType || org && !ctx)
+    done.push(`type ${q(o.type)}`);
+  if (!org && o.type === N.issueTypes.epic) {
+    let labelId = repoCtx.label?.id;
+    if (!labelId) {
+      labelId = createLabel(epicLabel());
+      done.push(`created label ${q(EPIC_LABEL)}`);
+    }
+    labels.push({ id: labelId, name: EPIC_LABEL });
+    done.push(`label ${q(EPIC_LABEL)} — the type in a personal account`);
+  }
+  if (plan.length) {
+    for (const x of plan) {
+      let id = x.label?.id;
+      if (!id) {
+        id = createLabel(decisionLabel(x.name, x.kinds));
+        done.push(`created label ${q(x.name)}`);
+      }
+      labels.push({ id, name: x.name });
+    }
+    done.push(`labels: ${plan.map((x) => x.name).join(", ")}`, ...plan.flatMap((x) => x.fresh ? [x.fresh] : []));
+  }
+  if (open.length) {
+    let id = has(N.labels.questions)?.id;
+    if (!id) {
+      id = createLabel(questionsLabel());
+      done.push(`created label ${q(N.labels.questions)}`);
+    }
+    if (!labels.some((l) => l.id === id))
+      labels.push({ id, name: N.labels.questions });
+    done.push(`label ${q(N.labels.questions)} — open questions in the description: ${open.join(", ")}`);
+  }
+  let created;
+  if (ctx) {
+    const input = { repositoryId: ctx.repo.id, title, body: o.body, projectV2Ids: [ctx.project.id] };
+    if (issueType)
+      input.issueTypeId = issueType.id;
+    if (labels.length)
+      input.labelIds = labels.map((l) => l.id);
+    if (milestone)
+      input.milestoneId = milestone.id;
+    if (epic)
+      input.parentIssueId = epic.id;
+    if (priority)
+      input.issueFields = [{ fieldId: priority.fieldId, singleSelectOptionId: priority.optionId }];
+    created = mutate(io, { op: "CreateIssue", input }).createIssue.issue;
+    const listed = (created.projectItems?.nodes ?? []).map((it) => ({ id: it.id, projectId: it.project.id, status: null }));
+    const item = ensureItem(io, ctx, { id: created.id, number: created.number, items: listed }).id;
+    setStatus(io, ctx, item, N.status.backlog);
+    done.push(`project ${q(ctx.project.title)}: ${STATUS} ${q(N.status.backlog)}`);
+  } else {
+    const payload = { title, body: o.body };
+    if (org)
+      payload.type = o.type;
+    if (labels.length)
+      payload.labels = labels.map((l) => l.name);
+    if (milestone)
+      payload.milestone = milestone.number;
+    const i = rest(io, `repos/${slug}/issues`, { method: "POST", payload });
+    created = { id: i.node_id, databaseId: i.id, number: i.number, title: i.title, url: i.html_url };
+    if (epic)
+      rest(io, `repos/${slug}/issues/${epic.number}/sub_issues`, { method: "POST", payload: { sub_issue_id: created.databaseId } });
+  }
+  if (priority)
+    done.push(`${PRIORITY} ${q(priority.name)}`);
+  if (epic)
+    done.push(`subtask of epic #${epic.number}`);
+  for (const b of blockers) {
+    if (b.state !== "OPEN") {
+      done.push(`#${b.number} is closed — doesn't block, skipped`);
+      continue;
+    }
+    if (ctx)
+      mutate(io, { op: "AddBlockedBy", input: { issueId: created.id, blockingIssueId: b.id } });
+    else
+      rest(io, `repos/${slug}/issues/${created.number}/dependencies/blocked_by`, { method: "POST", payload: { issue_id: b.databaseId } });
+    done.push(`blocked by #${b.number}`);
+  }
+  if (milestone)
+    done.push(`milestone ${q(milestone.title)}`);
+  const decided = plan.filter((x) => x.decision).map((x) => x.name);
+  const epicLabels = epic && decided.length ? putLabels(io, epic, `epic #${epic.number}`, decided, null, loadLabels(io, slug)) : [];
+  if (epic && priority) {
+    const rank = (p) => p === null ? PRIORITIES.length : PRIORITIES.indexOf(p);
+    if (rank(priority.name) < rank(epic.priority)) {
+      mutate(io, { op: "SetIssueField", input: { issueId: epic.id, issueFields: [{ fieldId: priority.fieldId, singleSelectOptionId: priority.optionId }] } });
+      done.push(`${PRIORITY} of epic #${epic.number}: ${epic.priority ?? "—"} → ${priority.name}`);
+    }
+  }
+  io.out(`Created #${created.number} ${created.title} — ${created.url}`);
+  for (const d of done)
+    io.out(`+ ${d}`);
+  for (const l of epicLabels)
+    io.out(l);
+  const isEpicType = o.type === N.issueTypes.epic;
+  if (!ctx) {
+    const n = created.number;
+    const local = [`github task status ${n} "${N.status.backlog}" (the project, ${STATUS})`, ...isEpicType ? [] : [`est estimate ${n} --type ${branchType} --write (${q(N.fields.estimate)})`]];
+    const want = org ? o.priority ?? DEFAULT_PRIORITY : null;
+    if (want)
+      local.push(`${PRIORITY} ${q(want)}${epic ? ` and no lower at epic #${epic.number}` : ""} — on the issue page`);
+    io.out(`Next: the cloud has no GitHub Projects (docs/cloud-sessions.md) — a local session: ${local.join("; ")}.`);
+  }
+  if (isEpicType) {
+    io.out(`Next: an epic isn't estimated — its ${q(N.fields.estimate)} is the sum of its subtasks' estimates.`);
+    io.out(`Next: once its subtasks are created — the question to the owner «run the dispatcher on epic #${created.number}?»; ` + `yes — bun --no-env-file ${import.meta.path} task queue --epic ${created.number} --repo ${slug} in this session, its executors — background subagents.`);
+    return 0;
+  }
+  if (ctx)
+    runEstimate(io, slug, created.number, branchType);
+  if (epic)
+    io.out(`Next: ${q(N.fields.estimate)} of epic #${epic.number} — recompute as the sum of its subtasks' estimates.`);
+  const held = pinnedTask(io)?.task;
+  if (held)
+    io.out(`Next: the session runs ${held.slug}#${held.number}; #${created.number} isn't taken here — ${queueQuestion(slug, created.number, epic?.number ?? null)}`);
+  return 0;
+}
+function cmdTaskStatus(io, slug, number, name, branch) {
+  if (!statusAliases()[name.toLowerCase()])
+    throw new GhError(`status: ${statusOptions().join(", ")}`);
+  if (branch !== undefined && statusAliases()[name.toLowerCase()] !== N.status.inProgress)
+    throw new GhError(`--branch — only with ${q(N.status.inProgress)}: the branch is renamed when the task is taken into work`);
+  if (branch !== undefined && (taskBranch(branch)?.issue !== number || !TASK_SLUG_RE.test(branch))) {
+    throw new GhError(`--branch ${q(branch)}: expected a branch of #${number} by the canon — [<area>/]<type>/${number}-<slug>, type ${TASK_TYPES.join("|")}, slug — Latin kebab-case`);
+  }
+  const ctx = taskContext(io, slug);
+  const status = statusAliases()[name.toLowerCase()];
+  const issue = loadIssue(io, slug, number);
+  const epicTask = isEpic(issue, ctx.repo.owner.org);
+  if (branch !== undefined && epicTask)
+    throw new GhError(`--branch: #${number} is an epic — an epic has no branch`);
+  if (status === N.status.inProgress && !epicTask)
+    pinTask(io, slug, number, issue.parent?.number ?? null);
+  const item = ensureItem(io, ctx, issue);
+  setStatus(io, ctx, item.id, status);
+  io.out(`+ #${issue.number}: ${STATUS} ${q(status)}${item.added ? " (added to the project)" : ""}`);
+  const code = branch === undefined || renameBranch(io, slug, branch) ? 0 : 1;
+  if (!issue.parent)
+    return code;
+  const epic = loadIssue(io, slug, issue.parent.number);
+  const epicStatus = itemIn(ctx, epic)?.status ?? null;
+  if (status === N.status.inProgress && epic.state === "OPEN" && (epicStatus === null || epicStatus === N.status.backlog)) {
+    setStatus(io, ctx, ensureItem(io, ctx, epic).id, N.status.inProgress);
+    io.out(`+ epic #${epic.number}: ${STATUS} ${q(N.status.inProgress)} — the first subtask is taken`);
+  }
+  if (status === N.status.inProgress && epic.state === "CLOSED")
+    io.out(`Next: epic #${epic.number} is closed, but a subtask is in work again — reopen it (and its milestone, if closed).`);
+  if (status === N.status.done && epic.state === "OPEN" && epic.subIssues.length && epic.subIssues.every((x) => x.state === "CLOSED")) {
+    io.out(`Next: all subtasks of epic #${epic.number} are closed — close the epic and set it to ${q(N.status.done)}.`);
+  }
+  return code;
+}
+function cmdTaskDrop(io, slug, number, duplicateOf) {
+  const ctx = taskContext(io, slug);
+  const issue = loadIssue(io, slug, number);
+  if (issue.state === "CLOSED" && issue.stateReason === "COMPLETED")
+    throw new GhError(`#${number} is closed as completed — drop is only for tasks not done`);
+  const dup = duplicateOf === undefined ? null : loadIssue(io, slug, duplicateOf);
+  if (issue.state === "OPEN") {
+    mutate(io, { op: "CloseIssue", input: { issueId: issue.id, stateReason: dup ? "DUPLICATE" : "NOT_PLANNED", ...dup ? { duplicateIssueId: dup.id } : {} } });
+    io.out(`+ #${number} closed: ${dup ? `duplicate of #${dup.number}` : "not planned"}`);
+  }
+  const item = itemIn(ctx, issue);
+  if (item) {
+    mutate(io, { op: "DeleteItem", input: { projectId: ctx.project.id, itemId: item.id } });
+    io.out(`+ #${number} removed from project ${q(ctx.project.title)}`);
+  }
+  if (issue.parent)
+    io.out(`Next: ${q(N.fields.estimate)} of epic #${issue.parent.number} — recompute as the sum of the remaining subtasks.`);
+  return 0;
+}
+function shownPr(p, why) {
+  const by = [...checkStates(rollupOf(p))];
+  const of = (...states) => by.filter(([, v]) => states.includes(v)).map(([k]) => k);
+  return { number: p.number, state: p.state ?? "", merged: Boolean(p.merged), draft: Boolean(p.isDraft), checks: by.length ? { green: of("pass", "skipping").length, pending: of("pending"), red: of("cancel", "fail") } : null, why };
+}
+function prLine(p) {
+  const done = p.merged || p.state === "CLOSED";
+  const state = p.merged ? "merged" : p.state === "CLOSED" ? "closed without a merge" : p.draft ? "open (draft)" : "open";
+  const c = p.checks;
+  const checks = done ? "" : !c ? " — no checks yet" : ` — checks: ${[c.green ? `${c.green} ✅` : "", c.pending.length ? `${c.pending.length} ⏳ (${c.pending.join(", ")})` : "", c.red.length ? `${c.red.length} ❌ (${c.red.join(", ")})` : ""].filter(Boolean).join(", ")}`;
+  return `PR #${p.number} ${state}${checks}${p.why ? ` (not linked: ${p.why})` : ""}`;
+}
+function restIssueShow(io, slug, number) {
+  const i = restIssue(io, slug, number);
+  if (!i)
+    return null;
+  const l = restLinks(io, slug, number);
+  return { ...i, ...l, parent: l.parent && { ...l.parent, subIssues: restSubIssues(io, slug, l.parent.number) } };
+}
+function restPrs(io, slug, number) {
+  const prs = rest(io, `repos/${slug}/pulls?state=all&sort=updated&direction=desc&per_page=${RECENT_PRS}`) ?? [];
+  const mine = prs.filter((p) => p.base?.ref === p.base?.repo?.default_branch && (p.state === "open" || p.merged_at) && (isTaskBranch(p.head?.ref ?? "", number) || closingInBody(p.body ?? "").includes(number)));
+  return mine.map((p) => {
+    const open = p.state === "open";
+    const runs = open ? rest(io, `repos/${slug}/commits/${p.head.sha}/check-runs?per_page=100`)?.check_runs ?? [] : [];
+    const statuses = open ? rest(io, `repos/${slug}/commits/${p.head.sha}/status`)?.statuses ?? [] : [];
+    const up = (v) => v ? String(v).toUpperCase() : null;
+    const nodes = [
+      ...runs.map((c) => ({ __typename: "CheckRun", name: c.name, status: up(c.status), conclusion: up(c.conclusion), databaseId: c.id, checkSuite: { app: { databaseId: c.app?.id ?? null } } })),
+      ...statuses.map((c) => ({ __typename: "StatusContext", context: c.context, state: up(c.state) }))
+    ];
+    return { number: p.number, state: open ? "OPEN" : "MERGED", merged: !open, isDraft: Boolean(p.draft), headRefName: p.head?.ref ?? "", commits: { nodes: [{ commit: { statusCheckRollup: nodes.length ? { contexts: { nodes } } : null } }] } };
+  });
+}
+function cmdTaskShow(io, slug, number) {
+  const [owner, name] = slug.split("/");
+  const cloud = inCloud(io);
+  const i = cloud ? restIssueShow(io, slug, number) : graphql(io, Q.IssueShow, { owner, name, number })?.repository?.issue;
+  if (!i)
+    throw new GhError(`no issue #${number} in ${slug}`);
+  const labels = (i.labels?.nodes ?? []).map((l) => l.name);
+  const type = i.issueType?.name ?? (labels.includes(EPIC_LABEL) ? N.issueTypes.epic : null);
+  const epic = type !== null && locale_default.every((n) => n.issueTypes.epic).includes(type);
+  const items = i.projectItems?.nodes ?? [];
+  const values = (items.find((it) => it.project?.title === name) ?? items[0])?.fieldValues?.nodes ?? [];
+  const num = (field) => values.find((v) => v?.__typename === "ProjectV2ItemFieldNumberValue" && locale_default.every(field).includes(v.field?.name));
+  const status = values.find((v) => v?.field?.name === STATUS && v.name)?.name ?? null;
+  const estimate = num((n) => n.fields.estimate);
+  const actual = num((n) => n.fields.actual);
+  const priority = (i.issueFieldValues?.nodes ?? []).find((v) => v?.field?.name === PRIORITY)?.name ?? null;
+  const reason = { NOT_PLANNED: ": not planned", DUPLICATE: ": duplicate" };
+  const shownLabels = labels.filter((l) => !(l === EPIC_LABEL && !i.issueType));
+  const facts = [
+    type,
+    i.state === "CLOSED" ? `closed${reason[i.stateReason] ?? ""}` : null,
+    cloud ? "no project in the cloud (docs/cloud-sessions.md)" : !items.length ? "not in the project" : status ? `${STATUS} ${q(status)}` : `no ${STATUS}`,
+    cloud ? null : estimate ? `${q(estimate.field.name)} ${estimate.number}` : `no ${q(N.fields.estimate)}`,
+    actual ? `${q(actual.field.name)} ${actual.number}` : null,
+    priority ? `${PRIORITY} ${priority}` : null,
+    i.milestone ? `milestone ${q(i.milestone.title)}` : null,
+    shownLabels.length ? `labels: ${shownLabels.join(", ")}` : null
+  ];
+  const out = [`#${i.number} ${i.title} — ${i.url}`, facts.filter(Boolean).join(" · ")];
+  if (i.parent) {
+    const p = i.parent;
+    const open = questionItems(p.body ?? "").filter((x) => !x.answered);
+    const tasks = (p.subIssues?.nodes ?? []).filter((x) => x.state === "OPEN" && x.number !== number);
+    out.push(`Epic #${p.number} ${q(p.title)} — open questions: ${open.length}, other open tasks: ${tasks.length}`);
+    out.push(...open.map((x) => `- question ${x.text}`), ...tasks.map((x) => `- task #${x.number} ${q(x.title)}`));
+  }
+  const subs = i.subIssues?.nodes ?? [];
+  if (subs.length) {
+    const open = subs.filter((x) => x.state === "OPEN");
+    out.push(`Subtasks: open ${open.length} of ${subs.length}`, ...open.map((x) => `- task #${x.number} ${q(x.title)}`));
+  }
+  const blockers = (i.blockedBy?.nodes ?? []).filter((x) => x.state === "OPEN");
+  if (blockers.length)
+    out.push(`Blocked by: ${blockers.map((x) => `${blockerRef(slug, { number: x.number, repo: x.repository?.nameWithOwner ?? slug })} ${q(x.title)}`).join(", ")}`);
+  if (!epic) {
+    let prs = (cloud ? restPrs(io, slug, number) : (i.closedByPullRequestsReferences?.nodes ?? []).filter(Boolean)).map((p) => shownPr(p));
+    if (!cloud && !prs.length && i.state === "OPEN") {
+      for (const p of unlinkedPrs(io, slug, number).prs) {
+        const pr = graphql(io, Q.PrShow, { owner, name, number: p.number })?.repository?.pullRequest;
+        if (pr)
+          prs.push(shownPr(pr, p.why));
+      }
+    }
+    out.push(...prs.length ? prs.map(prLine) : ["PR: none"]);
+  }
+  const lines = (i.body ?? "").trimEnd().split(/\r?\n/);
+  const questions = questionItems(i.body ?? "");
+  const open = questions.filter((x) => !x.answered).map((x) => x.k);
+  const answered = questions.filter((x) => x.answered).map((x) => x.k);
+  out.push(!questions.length ? "Questions: none" : !open.length ? `Questions: all answered (${answered.join(", ")})` : `Questions: open ${open.join(", ")}${answered.length ? `; answered ${answered.join(", ")}` : ""} — task answer ${number} <k> "<answer>" [--auto]`);
+  if (lines.join("").trim())
+    out.push("", ...lines);
+  for (const line of out)
+    io.out(line);
+  return 0;
+}
+function cmdTaskAnswer(io, slug, number, k, answer, auto) {
+  const text = answer.trim().replace(/\s*\r?\n\s*/g, " ");
+  if (!text)
+    throw new GhError("task answer: expected the answer text after the question number");
+  const [owner, name] = slug.split("/");
+  const cloud = inCloud(io);
+  const i = cloud ? restIssue(io, slug, number) : graphql(io, Q.IssueShow, { owner, name, number })?.repository?.issue;
+  if (!i)
+    throw new GhError(`no issue #${number} in ${slug}`);
+  const body = i.body ?? "";
+  const lines = body.split(/\r?\n/);
+  const questions = questionItems(body);
+  if (!questions.length)
+    throw new GhError(`#${number}: no ${q(N.sections.questions)} section with numbered questions`);
+  const question = questions.find((x) => x.k === k);
+  if (!question)
+    throw new GhError(`#${number}: no question ${k} in ${q(N.sections.questions)}; questions: ${questions.map((x) => x.k).join(", ")}`);
+  if (question.answered)
+    throw new GhError(`#${number}: question ${k} is already answered (✅) — a changed answer is edited by hand`);
+  const reply = `**${N.est.answer}:** ${text}`;
+  lines[question.first] = lines[question.first].replace(/^(\d+\.\s+)/, `$1${auto ? N.autoAnswer : "✅"} `);
+  if (question.first === question.last)
+    lines[question.first] += ` ${reply}`;
+  else
+    lines.splice(question.last + 1, 0, `${" ".repeat(`${k}. `.length)}${reply}`);
+  const next = lines.join(body.includes(`\r
+`) ? `\r
+` : `
+`);
+  if (cloud)
+    rest(io, `repos/${slug}/issues/${number}`, { method: "PATCH", payload: { body: next } });
+  else
+    mutate(io, { op: "UpdateIssue", input: { id: i.id, body: next } });
+  io.out(`+ #${number}: question ${k} — ✅ and the answer in the description`);
+  const open = questions.filter((x) => !x.answered && x !== question).map((x) => x.k);
+  if (open.length)
+    return io.out(`○ #${number}: open questions left: ${open.join(", ")}`), 0;
+  const label = (i.labels?.nodes ?? []).filter((l) => locale_default.every((n) => n.labels.questions).includes(l.name));
+  if (label.length) {
+    if (cloud)
+      for (const l of label)
+        rest(io, `repos/${slug}/issues/${number}/labels/${encodeURIComponent(l.name)}`, { method: "DELETE" });
+    else
+      mutate(io, { op: "RemoveLabels", input: { labelableId: i.id, labelIds: label.map((l) => l.id) } });
+    io.out(`+ #${number}: label ${label.map((l) => q(l.name)).join(", ")} removed — no open questions left`);
+  }
+  return 0;
+}
+var QUEUE_EXECUTORS = 3;
+var priorityRank = (p) => PRIORITIES.indexOf(p ?? DEFAULT_PRIORITY);
+function externalBlocker(io, slug, number, label) {
+  const marks = locale_default.every((n) => n.comments.externalBlocker);
+  const comment = loadTaskText(io, slug, number).comments.map((c) => c.body.trim()).filter((b) => marks.some((m) => b.startsWith(m))).at(-1);
+  if (comment === undefined)
+    return `label ${q(label)}, no comment ${q(`${N.comments.externalBlocker} <reason>`)}`;
+  const mark = marks.find((m) => comment.startsWith(m));
+  return `label ${q(label)}: ${clip(comment.slice(mark.length).split(/\r?\n/)[0].trim())}`;
+}
+function executorPrompt(slug, number, epic) {
+  return locale_default.fill(N.queue.prompt, {
+    task: N.subagentPrompt.task,
+    number,
+    repo: slug,
+    epic: epic === null ? "" : locale_default.fill(N.queue.epic, { epicWord: N.subagentPrompt.epic, epic }),
+    command: `bun --no-env-file ${import.meta.path} task queue --assignment ${number} --repo ${slug}`
+  });
+}
+function cloudBrief(io, slug, issue) {
+  const number = issue.number;
+  const vars = {
+    task: N.subagentPrompt.task,
+    number,
+    title: issue.title.replace(/#(\d)/g, "$1"),
+    repo: slug,
+    epic: issue.parent ? locale_default.fill(N.queue.cloudEpic, { epicWord: N.subagentPrompt.epic, epic: issue.parent.number }) : "",
+    actual: N.est.cloud.actual.replace(/:$/, ""),
+    state: N.comments.state,
+    questions: N.sections.questions
+  };
+  for (const line of [N.queue.cloud, N.queue.cloudDoc, N.queue.cloudClose, N.queue.cloudDispatcher, N.queue.cloudQuestion])
+    io.out(locale_default.fill(line, vars));
+  io.out(`Next: the lines above — the cloud session's first prompt as is, the session started from the project folder (the cloud starts from main); ` + `then as a background command: bash ${waitCi()} issue ${number} — a cloud session can't message a local one (docs/cloud-sessions.md), the task's closing is the signal: ` + `PASS — bun --no-env-file ${import.meta.path} task close ${number} (the actual with --write, ${STATUS}, the merged branch), then archive the executor's session where the agent has the tool; ` + `TIMEOUT — the task's ${q(N.sections.questions)} and its ${q(N.comments.state)} comment, the executor's session, then the same wait again`);
+}
+function cmdTaskQueue(io, slug, o) {
+  const want = o.type === undefined ? undefined : typeAliases()[o.type.toLowerCase()];
+  if (o.type !== undefined && (!want || want === N.issueTypes.epic))
+    throw new GhError(`--type: ${N.issueTypes.task} or ${N.issueTypes.bug}`);
+  const bad = (o.priority ?? []).filter((p) => !PRIORITIES.includes(p));
+  if (bad.length)
+    throw new GhError(`--priority: ${PRIORITIES.join(", ")}, not ${bad.join(", ")}`);
+  const ctx = taskContext(io, slug);
+  const org = ctx.repo.owner.org;
+  if (!org && (o.type !== undefined || o.priority?.length))
+    throw new GhError("--type and --priority — only in an organization: a personal account has no issue types and no Priority");
+  let numbers;
+  if (o.epic !== undefined) {
+    const epic = loadIssue(io, slug, o.epic);
+    if (!isEpic(epic, org))
+      throw new GhError(`#${o.epic} is not an epic — --epic takes an epic`);
+    if (epic.state !== "OPEN")
+      throw new GhError(`epic #${o.epic} is closed`);
+    numbers = epic.subIssues.filter((x) => x.state === "OPEN").map((x) => x.number);
+  } else {
+    const found = graphql(io, Q.IssueSearch, { q: `repo:${slug} is:issue is:open` }).search.nodes;
+    if (found.length >= 100)
+      io.out("○ the search gave 100 open tasks — the queue sees only them: narrow it with --epic");
+    numbers = found.filter((x) => x?.state === "OPEN").map((x) => x.number);
+  }
+  const [owner, name] = slug.split("/");
+  const recent = (graphql(io, Q.RecentPrs, { owner, name })?.repository?.pullRequests?.nodes ?? []).filter((p) => p.state === "OPEN");
+  const openPr = (i) => i.prs.find((p) => p.state === "OPEN")?.number ?? recent.find((p) => isTaskBranch(p.headRefName ?? "", i.number) || closingInBody(p.body ?? "").includes(i.number))?.number;
+  const handed = handedOut(io, slug);
+  const states = new Map;
+  const isOpen = (n) => {
+    if (!states.has(n))
+      states.set(n, loadIssue(io, slug, n).state);
+    return states.get(n) === "OPEN";
+  };
+  const ready = [];
+  const running = [];
+  const waiting = [];
+  for (const n of numbers.sort((a, b) => a - b)) {
+    const i = loadIssue(io, slug, n);
+    states.set(i.number, i.state);
+    if (i.state !== "OPEN")
+      continue;
+    const label = `#${i.number} ${q(i.title)}`;
+    if (isEpic(i, org)) {
+      waiting.push(`○ ${label} — an epic: its tasks — task queue --epic ${i.number}`);
+      continue;
+    }
+    if (want && typeAliases()[(i.type ?? "").toLowerCase()] !== want)
+      continue;
+    if (o.priority?.length && !o.priority.includes(i.priority ?? DEFAULT_PRIORITY))
+      continue;
+    const status = itemIn(ctx, i)?.status ?? null;
+    const pr = openPr(i);
+    const work = [status === N.status.inProgress ? q(N.status.inProgress) : "", pr === undefined ? "" : `open PR #${pr} https://github.com/${slug}/pull/${pr}`].filter(Boolean);
+    const hand = handed.find((h) => h.number === i.number);
+    if (!work.length && hand?.cloud)
+      work.push(`handed out to a cloud executor of this session, its wait — a background command: bash ${waitCi()} issue ${i.number}`);
+    else if (!work.length && hand)
+      work.push("handed out to an executor of this session");
+    if (work.length) {
+      running.push(`= ${label} — ${work.join(", ")}`);
+      continue;
+    }
+    const blockers = i.blockers.filter((b) => b.state === "OPEN").map((b) => blockerRef(slug, b));
+    const external = i.labels.find((l) => locale_default.every((n) => n.labels.externalBlocker).includes(l));
+    if (status === N.status.done)
+      waiting.push(`○ ${label} — ${STATUS} ${q(status)}, but the task is open`);
+    else if (blockers.length)
+      waiting.push(`○ ${label} — blocked by ${blockers.join(", ")}`);
+    else if (external)
+      waiting.push(`○ ${label} — ${externalBlocker(io, slug, i.number, external)}`);
+    else
+      ready.push(i);
+  }
+  ready.sort((a, b) => priorityRank(a.priority) - priorityRank(b.priority) || a.number - b.number);
+  const args = [o.epic !== undefined && `--epic ${o.epic}`, o.type !== undefined && `--type ${o.type}`, o.priority?.length && `--priority ${o.priority.join(",")}`].filter(Boolean).join(" ");
+  const file = dispatcherFile(io);
+  if (file) {
+    mkdirSync(path.dirname(file), { recursive: true });
+    writeFileSync(path.join(path.dirname(file), ".gitignore"), `*
+`);
+    writeFileSync(file, `bun --no-env-file ${import.meta.path} task queue ${args ? `${args} ` : ""}--repo ${slug}
+`);
+  } else
+    io.out("○ session not recognized (no CLAUDE_CODE_SESSION_ID) — not marked as a dispatcher: task status in the executors would pin their tasks");
+  appWorktreeWarning(io);
+  const executors = handed.flatMap((h) => h.worktree === null ? [] : [{ number: h.number, worktree: realPath(h.worktree) }]);
+  pruneAgentWorktrees(io, slug, (dir) => executors.some((h) => h.worktree === realPath(dir) && isOpen(h.number)));
+  const scope = [o.epic !== undefined ? `epic #${o.epic}` : "open tasks", want && `type ${q(want)}`, o.priority?.length && `Priority ${o.priority.join("|")}`].filter(Boolean).join(", ");
+  io.out(`Queue ${slug} (${scope}): ready ${ready.length}, ${q(N.status.inProgress)} ${running.length}, not ready ${waiting.length}`);
+  for (const i of ready) {
+    io.out(`+ #${i.number} ${q(i.title)}${org ? ` (${i.priority ?? DEFAULT_PRIORITY})` : ""}`);
+    io.out(`  ${executorPrompt(slug, i.number, i.parent?.number ?? null)}`);
+  }
+  for (const line of running)
+    io.out(line);
+  for (const line of waiting)
+    io.out(line);
+  if (ready.length) {
+    io.out(`Next: each ready task above — a background subagent in its own worktree while fewer than ${QUEUE_EXECUTORS} run (a number from the request replaces it); ` + "the indented line is its whole prompt. After each executor's answer — task queue again: new tasks get in.");
+  } else if (running.length)
+    io.out("Next: no ready tasks — wait for the executors' answers; after each — task queue again.");
+  else
+    io.out(`Queue is empty: nothing ready, nothing ${q(N.status.inProgress)} — the dispatcher's summary (merged, questions, the not ready ones above) and the last line; a session with its own task — after it.`);
+  return 0;
+}
+var AGENT_WORKTREE = /[\\/]\.claude[\\/]worktrees[\\/]agent-[^\\/]+$/;
+var AGENT_BRANCH = /^worktree-agent-/;
+var APP_WORKTREE = /[\\/]\.claude[\\/]worktrees[\\/](?!agent-)[^\\/]+$/;
+function appWorktreeWarning(io) {
+  const top = (io.run ?? realRun)("git", ["rev-parse", "--show-toplevel"], io.cwd).stdout.trim();
+  if (!APP_WORKTREE.test(top))
+    return;
+  const project = top.replace(/[\\/]\.claude[\\/]worktrees[\\/][^\\/]+$/, "");
+  io.out(`! session in an app worktree ${top}: the app starts its cloud sessions from the branch in the session's record, not from main — ` + `cloud executors from it fail with «The requested branch or commit was not found»; a dispatcher with cloud executors — ` + `a session in the project folder ${project} without a worktree; subagent executors aren't affected`);
+}
+function worktreeList(text) {
+  return text.split(/\n\s*\n/).map((block) => {
+    const lines = block.split(`
+`);
+    const attr = (key) => {
+      const line = lines.find((l) => l === key || l.startsWith(`${key} `));
+      return line === undefined ? null : line.slice(key.length + 1);
+    };
+    return { path: attr("worktree") ?? "", head: attr("HEAD") ?? "", branch: attr("branch")?.replace(/^refs\/heads\//, "") ?? null, locked: attr("locked"), prunable: attr("prunable") !== null };
+  }).filter((w) => w.path);
+}
+function lockHolds(reason) {
+  const pid = /\bpid (\d+)\b/.exec(reason)?.[1];
+  if (!pid)
+    return true;
+  try {
+    process.kill(Number(pid), 0);
+    return true;
+  } catch (e) {
+    return e.code !== "ESRCH";
+  }
+}
+var plural = (n, one, many) => `${n} ${n === 1 ? one : many}`;
+function pruneAgentWorktrees(io, slug, kept) {
+  if (!checkoutOfRepo(io, originUrl(io), slug))
+    return;
+  const git = (cwd, ...args) => (io.run ?? realRun)("git", args, cwd);
+  const listed = git(io.cwd, "worktree", "list", "--porcelain");
+  if (listed.status !== 0)
+    return;
+  const all = worktreeList(listed.stdout);
+  const here = git(io.cwd, "rev-parse", "--show-toplevel").stdout.trim();
+  const base = git(io.cwd, "symbolic-ref", "--quiet", "--short", "refs/remotes/origin/HEAD").stdout.trim().replace(/^origin\//, "") || "main";
+  const upstream = `origin/${base}`;
+  const why = (r) => r.stderr.trim().split(`
+`).filter(Boolean).pop() ?? `code ${r.status}`;
+  const unmerged = (ref) => {
+    const r = git(io.cwd, "cherry", upstream, ref);
+    if (r.status !== 0)
+      return `git cherry ${upstream}: ${why(r)}`;
+    const n = r.stdout.split(`
+`).filter((l) => l.startsWith("+")).length;
+    return n ? `${plural(n, "commit", "commits")} not in ${upstream}` : null;
+  };
+  const deleteBranch = (branch) => {
+    const d = git(io.cwd, "branch", "-D", branch);
+    if (d.status !== 0)
+      io.out(`! git branch -D ${branch}: ${why(d)}`);
+    return d.status === 0;
+  };
+  const candidates = all.filter((w) => AGENT_WORKTREE.test(w.path) && w.path !== here && !w.prunable && (w.branch === null || AGENT_BRANCH.test(w.branch))).filter((w) => (w.locked === null || !lockHolds(w.locked)) && !kept(w.path)).sort((a, b) => a.path.localeCompare(b.path));
+  const agents = candidates.length ? subagentsOf(io, [io.env.CLAUDE_CODE_SESSION_ID ?? "", ...handOutFiles(io).map((h) => h.session)].filter(Boolean)) : new Map;
+  for (const w of candidates) {
+    const guest = guestWhy(agents, agentIdOf(w.path));
+    if (guest) {
+      io.out(`○ worktree ${w.path} left: ${guest}`);
+      continue;
+    }
+    const status = git(w.path, "status", "--porcelain");
+    if (status.status !== 0) {
+      io.out(`! worktree ${w.path}: git status: ${why(status)}`);
+      continue;
+    }
+    const dirty = status.stdout.split(`
+`).filter((l) => l.trim()).length;
+    const reasons = [dirty ? `${plural(dirty, "uncommitted file", "uncommitted files")}` : null, unmerged(w.head)].filter((r) => r !== null);
+    if (reasons.length) {
+      io.out(`○ worktree ${w.path} left: ${reasons.join(", ")}`);
+      continue;
+    }
+    if (w.locked !== null)
+      git(io.cwd, "worktree", "unlock", w.path);
+    const removed = git(io.cwd, "worktree", "remove", w.path);
+    if (removed.status !== 0) {
+      io.out(`! git worktree remove ${w.path}: ${why(removed)}`);
+      continue;
+    }
+    const withBranch = w.branch !== null && deleteBranch(w.branch) ? ` with branch ${w.branch}` : "";
+    io.out(`+ worktree ${w.path} removed${withBranch}: clean, nothing outside ${upstream}`);
+  }
+  const checkedOut = new Set(all.map((w) => w.branch).filter(Boolean));
+  const loose = git(io.cwd, "for-each-ref", "--format=%(refname:short)", "refs/heads/worktree-agent-*").stdout.split(`
+`).map((b) => b.trim()).filter((b) => b && !checkedOut.has(b)).sort();
+  for (const branch of loose) {
+    const reason = unmerged(branch);
+    if (reason)
+      io.out(`○ branch ${branch} left: ${reason}`);
+    else if (deleteBranch(branch))
+      io.out(`+ branch ${branch} deleted: nothing outside ${upstream}`);
+  }
+}
+var QUIET_MINUTES = 15;
+var agentIdOf = (dir) => AGENT_WORKTREE.test(dir) ? path.basename(dir).slice("agent-".length) : null;
+function subagentsOf(io, sessions) {
+  const agents = new Map;
+  const projects = path.join(io.env.CLAUDE_CONFIG_DIR || path.join(io.env.HOME || os.homedir(), ".claude"), "projects");
+  let dirs;
+  try {
+    dirs = readdirSync(projects);
+  } catch {
+    return agents;
+  }
+  for (const dir of dirs) {
+    for (const session of new Set(sessions)) {
+      const sub = path.join(projects, dir, session, "subagents");
+      let names;
+      try {
+        names = readdirSync(sub);
+      } catch {
+        continue;
+      }
+      for (const name of names) {
+        const id = /^agent-(.+)\.meta\.json$/.exec(name)?.[1];
+        if (!id)
+          continue;
+        try {
+          const meta = JSON.parse(readFileSync(path.join(sub, name), "utf8"));
+          const parent = meta?.parentAgentId;
+          const worktree = meta?.worktreePath;
+          agents.set(id, {
+            parent: typeof parent === "string" && parent ? parent : null,
+            own: typeof worktree === "string" && path.basename(worktree) === `agent-${id}`,
+            written: statSync(path.join(sub, `agent-${id}.jsonl`), { throwIfNoEntry: false })?.mtimeMs ?? 0
+          });
+        } catch {}
+      }
+    }
+  }
+  return agents;
+}
+function guestWhy(agents, host) {
+  const inside = new Set([host]);
+  let fresh = null;
+  for (let grew = true;grew; ) {
+    grew = false;
+    for (const [id, a] of agents) {
+      if (a.own || a.parent === null || !inside.has(a.parent) || inside.has(id))
+        continue;
+      inside.add(id);
+      grew = true;
+      const minutes = Math.max(0, Math.floor((Date.now() - a.written) / 60000));
+      if (a.written > 0 && minutes < QUIET_MINUTES && (!fresh || minutes < fresh.minutes))
+        fresh = { id, minutes };
+    }
+  }
+  return fresh && `subagent agent-${fresh.id} works in it without a worktree of its own — its transcript written ${fresh.minutes} min ago, quiet after ${QUIET_MINUTES}`;
+}
+function aliveWhy(io, w, agents) {
+  if (w.locked !== null && lockHolds(w.locked))
+    return `locked by a live process — ${w.locked || "no reason"}`;
+  const id = agentIdOf(w.path);
+  const guest = id === null ? null : guestWhy(agents, id);
+  if (guest)
+    return guest;
+  const r = (io.run ?? realRun)("git", ["reflog", "-1", "--date=unix", "--format=%gd"], w.path);
+  const at = Number(/@\{(\d+)\}/.exec(r.stdout)?.[1]);
+  const minutes = Math.floor((Date.now() / 1000 - at) / 60);
+  return r.status === 0 && at > 0 && minutes < QUIET_MINUTES ? `HEAD moved ${Math.max(0, minutes)} min ago (a commit or a switch), quiet after ${QUIET_MINUTES}` : null;
+}
+function handOutFiles(io) {
+  const dir = path.join(configDir(io.env), "dispatchers");
+  try {
+    return readdirSync(dir).filter((f) => f.endsWith(".tasks")).map((f) => ({ session: f.slice(0, -".tasks".length), file: path.join(dir, f) }));
+  } catch {
+    return [];
+  }
+}
+function livePredecessors(io, slug, number, own) {
+  if (!checkoutOfRepo(io, originUrl(io), slug))
+    return [];
+  const listed = (io.run ?? realRun)("git", ["worktree", "list", "--porcelain"], io.cwd);
+  if (listed.status !== 0)
+    return [];
+  const mine = realPath(own);
+  const all = worktreeList(listed.stdout).filter((w) => !w.prunable && realPath(w.path) !== mine);
+  const handOuts = handOutFiles(io).flatMap(({ session, file }) => handOutsIn(file, slug).filter((h) => h.number === number && h.worktree !== null).map((h) => ({ session, worktree: realPath(h.worktree) })));
+  const executors = all.filter((w) => handOuts.some((h) => h.worktree === realPath(w.path)) || w.branch !== null && isTaskBranch(w.branch, number));
+  if (!executors.length)
+    return [];
+  const agents = subagentsOf(io, [...handOuts.map((h) => h.session), io.env.CLAUDE_CODE_SESSION_ID ?? ""].filter(Boolean));
+  const family = new Set(executors.map((w) => agentIdOf(w.path)).filter((id) => id !== null));
+  for (let grew = true;grew; ) {
+    grew = false;
+    for (const [id, { parent }] of agents) {
+      if (parent !== null && family.has(parent) && !family.has(id)) {
+        family.add(id);
+        grew = true;
+      }
+    }
+  }
+  const lines = [];
+  for (const w of all) {
+    const parent = agents.get(agentIdOf(w.path) ?? "")?.parent;
+    const role = executors.includes(w) ? "the previous executor" : parent && family.has(parent) ? `a subagent of agent-${parent}` : null;
+    const why = role && aliveWhy(io, w, agents);
+    if (why)
+      lines.push(`! worktree ${w.path} (${role}): ${why}`);
+  }
+  return lines;
+}
+function taskBranchesHere(io, slug, number) {
+  if (!checkoutOfRepo(io, originUrl(io), slug))
+    return [];
+  const git = (...args) => (io.run ?? realRun)("git", args, io.cwd).stdout.split(`
+`);
+  const refs = [...git("for-each-ref", "--format=%(refname)", "refs/heads/"), ...git("ls-remote", "--heads", "origin").map((l) => l.split("\t")[1] ?? "")];
+  return [...new Set(refs.map((r) => r.trim().replace(/^refs\/heads\//, "")).filter((b) => isTaskBranch(b, number)))].sort();
+}
+function cmdTaskAssignment(io, slug, number, o = { cloud: false }) {
+  const issue = loadIssue(io, slug, number);
+  const file = handedOutFile(io);
+  const own = pinnedTask(io)?.task;
+  const top = (io.run ?? realRun)("git", ["rev-parse", "--show-toplevel"], io.cwd);
+  const worktree = top.status === 0 ? top.stdout.trim() : "";
+  const alive = worktree ? livePredecessors(io, slug, number, worktree) : [];
+  if (alive.length) {
+    for (const line of alive)
+      io.out(line);
+    io.out(locale_default.fill(N.queue.alive, { task: N.subagentPrompt.task, number, repo: slug }));
+    return 1;
+  }
+  if (file && !(own?.slug === slug && own.number === number)) {
+    mkdirSync(path.dirname(file), { recursive: true });
+    writeFileSync(path.join(path.dirname(file), ".gitignore"), `*
+`);
+    const where = o.cloud ? CLOUD_HANDOUT : worktree;
+    appendFileSync(file, `${slug}#${number}${where ? ` ${where}` : ""}
+`);
+  }
+  if (o.cloud)
+    return cloudBrief(io, slug, issue), 0;
+  const restart = itemIn(taskContext(io, slug), issue)?.status === N.status.inProgress ? taskBranchesHere(io, slug, number) : [];
+  const vars = {
+    task: N.subagentPrompt.task,
+    number,
+    title: issue.title,
+    repo: slug,
+    epic: issue.parent ? locale_default.fill(N.queue.epic, { epicWord: N.subagentPrompt.epic, epic: issue.parent.number }) : "",
+    script: `bun --no-env-file ${import.meta.path}`,
+    waitCi: `bash ${waitCi()}`,
+    inProgress: N.status.inProgress,
+    done: N.lastLine.done,
+    questions: N.sections.questions,
+    branches: restart.map((b) => `\`${b}\``).join(", ")
+  };
+  const lines = [N.queue.lead, ...restart.length ? [N.queue.resume] : [], N.queue.subagent, N.queue.session, N.queue.wait, N.queue.git, N.queue.subagents, N.queue.live, N.queue.found, N.queue.question, N.queue.answer];
+  for (const line of lines)
+    io.out(locale_default.fill(line, vars));
+  return 0;
+}
+function actualizeChecks() {
+  const file = path.resolve(import.meta.dir, "../reference.md");
+  const m = existsSync(file) ? /Five checks:\n\n([\s\S]*?)\n\nWhat was fixed/.exec(readFileSync(file, "utf8")) : null;
+  const items = m ? m[1].split(/\n(?=\d\. )/) : [];
+  if (items.length !== 5)
+    throw new GhError(`the five epic-refresh checks not found in ${file}: expected a list of five between «Five checks:» and «What was fixed»`);
+  return items;
+}
+var MEANING_CHECKS = [0, 2, 4];
+var ANSWER_MARK_RE = /(?:^\s*(?:\d+\.\s+)?|[?.!—–][»"'*_)`]*\s+)[*_(]*✅/;
+var THEMATIC_BREAK_RE = /^ {0,3}([-*_])(?:[ \t]*\1){2,}[ \t]*$/;
+function questionItems(body) {
+  const section = new RegExp(`^(?:${locale_default.every((n) => n.sections.questions).map(locale_default.escapeRe).join("|")})\\s*$`);
+  const lines = body.split(/\r?\n/);
+  const from = lines.findIndex((l) => section.test(l));
+  if (from < 0)
+    return [];
+  const items = [];
+  for (let i = from + 1;i < lines.length && !/^##\s/.test(lines[i]) && !THEMATIC_BREAK_RE.test(lines[i]); i++) {
+    if (/^\d+\.\s/.test(lines[i]))
+      items.push({ first: i, last: i });
+    else if (items.length && lines[i].trim())
+      items.at(-1).last = i;
+  }
+  return items.map(({ first, last }) => {
+    const item = lines.slice(first, last + 1).filter((l) => l.trim());
+    return { k: parseInt(lines[first], 10), text: lines[first].trim(), lines: item, answered: item.some((l) => ANSWER_MARK_RE.test(l)), first, last };
+  });
+}
+function loadTaskText(io, slug, number) {
+  const [owner, name] = slug.split("/");
+  const i = graphql(io, Q.TaskText, { owner, name, number })?.repository?.issue;
+  if (!i)
+    throw new GhError(`no issue #${number} in ${slug}`);
+  const milestone = (m) => m ? { number: m.number, title: m.title, state: m.state, open: m.issues?.totalCount ?? 0 } : null;
+  return {
+    id: i.id,
+    number: i.number,
+    title: i.title,
+    state: i.state,
+    body: (i.body ?? "").replace(/\r\n/g, `
+`).trim(),
+    labels: i.labels?.nodes ?? [],
+    milestone: milestone(i.milestone),
+    blockedBy: (i.blockedBy?.nodes ?? []).map((b) => ({ id: b.id, number: b.number, state: b.state, repo: b.repository?.nameWithOwner ?? slug })),
+    comments: i.comments?.nodes ?? [],
+    subIssues: (i.subIssues?.nodes ?? []).map((x) => ({ number: x.number, title: x.title, state: x.state, milestone: milestone(x.milestone) }))
+  };
+}
+function refreshMechanics(io, slug, r) {
+  const fixes = [];
+  const tasks = [r.epic, ...r.open];
+  for (const t of tasks) {
+    const done = t.blockedBy.filter((b) => b.state === "CLOSED" || r.merged && blockerRef(slug, b) === `#${r.number}`);
+    if (!done.length)
+      continue;
+    for (const b of done)
+      mutate(io, { op: "RemoveBlockedBy", input: { issueId: t.id, blockingIssueId: b.id } });
+    io.out(`+ #${t.number}: blocked by ${done.map((b) => `${blockerRef(slug, b)} (${b.state === "CLOSED" ? "closed" : "merged"})`).join(", ")} removed`);
+    fixes.push(locale_default.fill(N.actualize.unblocked, { task: t.number, blockers: done.map((b) => blockerRef(slug, b)).join(", ") }));
+  }
+  const questionLabels = locale_default.every((n) => n.labels.questions);
+  for (const t of tasks) {
+    const labels = t.labels.filter((l) => questionLabels.includes(l.name));
+    if (!labels.length || questionItems(t.body).some((x) => !x.answered))
+      continue;
+    mutate(io, { op: "RemoveLabels", input: { labelableId: t.id, labelIds: labels.map((l) => l.id) } });
+    for (const l of labels) {
+      io.out(`+ #${t.number}: label ${q(l.name)} removed — no open questions`);
+      fixes.push(locale_default.fill(N.actualize.unlabeled, { task: t.number, label: l.name }));
+    }
+  }
+  const own = r.epic.subIssues.find((x) => x.number === r.number)?.milestone?.number;
+  const seen = new Set([own, r.epic.milestone?.number]);
+  for (const { milestone: m } of r.epic.subIssues) {
+    if (!m || seen.has(m.number))
+      continue;
+    seen.add(m.number);
+    if (m.state !== "OPEN" || m.open > 0)
+      continue;
+    io.gh(["api", "-X", "PATCH", `repos/${slug}/milestones/${m.number}`, "-f", "state=closed"]);
+    io.out(`+ milestone ${q(m.title)} closed: no open tasks left`);
+    fixes.push(locale_default.fill(N.actualize.milestone, { title: m.title }));
+  }
+  if (!fixes.length)
+    return;
+  mutate(io, { op: "AddComment", input: { subjectId: r.epic.id, body: locale_default.fill(N.actualize.mechanics, { number: r.number, fixes: fixes.join("; ") }) } });
+  io.out(`+ epic #${r.epic.number}: a comment with the script's fixes`);
+}
+var clip = (line) => line.length > 200 ? `${line.slice(0, 199)}…` : line;
+function linkCopies(epic, open) {
+  const subs = new Set(epic.subIssues.map((x) => x.number));
+  const words = locale_default.every((n) => n.actualize.linkWords).flatMap((w) => w.split("|")).map((w) => w.trim()).filter(Boolean).map(locale_default.escapeRe);
+  const phrase = new RegExp(`(?<![\\p{L}\\p{N}_])(?:${words.join("|")})\\s*:?\\s*#\\d+`, "iu");
+  const item = /^\s*(?:[-*+]|\d+\.)\s+(?:\[[ xX]\]\s+)?#(\d+)(?!\d)/;
+  const out = [];
+  for (const t of [epic, ...open]) {
+    for (const raw of t.body.split(`
+`)) {
+      const listed = t === epic ? item.exec(raw) : null;
+      if (listed && subs.has(Number(listed[1])) || raw.includes("⛔") || phrase.test(raw))
+        out.push({ number: t.number, line: clip(raw.trim()) });
+    }
+  }
+  return out;
+}
+function commentAnswers(tasks) {
+  const out = [];
+  for (const t of tasks) {
+    const open = new Set(questionItems(t.body).filter((x) => !x.answered).map((x) => x.k));
+    if (!open.size)
+      continue;
+    const found = new Map;
+    for (const c of t.comments)
+      for (const m of c.body.matchAll(/^\s*(\d+)\.\s*✅\s*(.+)$/gm))
+        if (open.has(Number(m[1])))
+          found.set(Number(m[1]), { text: clip(m[2].trim()), url: c.url });
+    for (const [k, a] of [...found].sort(([x], [y]) => x - y))
+      out.push({ number: t.number, k, ...a });
+  }
+  return out;
+}
+var fileLine = (f) => `- ${f.path} (${f.changeType === "MODIFIED" ? "" : `${f.changeType.toLowerCase()}, `}+${f.additions} −${f.deletions})`;
+var textBlock = (body) => body ? `~~~~markdown
+${body}
+~~~~` : N.actualize.noBody;
+function cmdTaskActualize(io, slug, number, o = { assignment: false }) {
+  const issue = loadIssue(io, slug, number);
+  const later = `Next: task close ${number} — after the deploy, where the merge deploys.`;
+  if (!issue.parent)
+    return io.out(`○ refresh not needed: #${number} has no epic. ${later}`), 0;
+  const linked = issue.prs.filter((p) => p.merged);
+  const prs = linked.length ? linked : unlinkedPrs(io, slug, number).prs.filter((p) => p.merged);
+  const epic = loadTaskText(io, slug, issue.parent.number);
+  const open = epic.subIssues.filter((x) => x.state === "OPEN" && x.number !== number).map((x) => loadTaskText(io, slug, x.number));
+  if (!o.assignment)
+    refreshMechanics(io, slug, { number, merged: prs.length > 0, epic, open });
+  if (!open.length)
+    return io.out(`○ refresh not needed: epic #${epic.number} has no open tasks besides #${number}. ${later}`), 0;
+  const vars = { task: N.subagentPrompt.task, epicWord: N.subagentPrompt.epic, number, epic: epic.number, repo: slug };
+  const lead = locale_default.fill(N.actualize.lead, vars);
+  if (!o.assignment) {
+    io.out("Next: a subagent in the background — the two lines below are its whole prompt, pass them as is.");
+    io.out(lead);
+    io.out(locale_default.fill(N.actualize.fetch, { command: `bun --no-env-file ${import.meta.path} task actualize ${number} --assignment --repo ${slug}` }));
+    return 0;
+  }
+  const checks = actualizeChecks();
+  const shipped = prs.length ? locale_default.fill(N.actualize.prs, { list: prs.map((p) => `#${p.number} (\`gh pr view ${p.number}\`, \`gh pr diff ${p.number}\`)`).join(", ") }) : locale_default.fill(N.actualize.noPr, { command: `\`git log origin/main --grep '#${number}'\`` });
+  const lines = [lead, locale_default.fill(N.actualize.shipped, { ...vars, title: issue.title, shipped })];
+  for (const p of prs) {
+    const files = loadPrChange(io, slug, p.number).files;
+    if (files.length)
+      lines.push(locale_default.fill(N.actualize.files, { pr: p.number }), ...files.map(fileLine));
+  }
+  lines.push("", locale_default.fill(N.actualize.epic, { ...vars, title: epic.title }), textBlock(epic.body), "", N.actualize.openTasks);
+  for (const t of open)
+    lines.push("", locale_default.fill(N.actualize.openTask, { number: t.number, title: t.title }), textBlock(t.body));
+  const copies = linkCopies(epic, open);
+  if (copies.length)
+    lines.push("", N.actualize.copies, ...copies.map((c) => locale_default.fill(N.actualize.copy, c)));
+  const answers = commentAnswers([epic, ...open]);
+  if (answers.length)
+    lines.push("", locale_default.fill(N.actualize.answers, { questions: N.sections.questions }), ...answers.map((a) => locale_default.fill(N.actualize.commentAnswer, a)));
+  lines.push("", N.actualize.checks, "", MEANING_CHECKS.map((i) => checks[i]).join(`
+`), "", locale_default.fill(N.actualize.scope, { ...vars, questions: N.sections.questions, script: `bun --no-env-file ${import.meta.path}` }), locale_default.fill(N.actualize.comment, { ...vars, report: locale_default.fill(N.actualize.report, { number, text: "…" }) }), N.actualize.answer);
+  for (const line of lines)
+    io.out(line);
+  return 0;
+}
+function refreshReported(epic, number) {
+  const heads = locale_default.every((n) => n.actualize.report).map((t) => locale_default.fill(t, { number, text: "" }).trim().toLowerCase());
+  return epic.comments.some((c) => heads.some((h) => c.body.toLowerCase().includes(h)));
+}
+function cmdTaskClose(io, slug, number, o) {
+  const ctx = taskContext(io, slug);
+  const issue = loadIssue(io, slug, number);
+  const linked = issue.prs.filter((p) => p.merged);
+  const closedNoPr = !issue.prs.length && issue.state === "CLOSED" && issue.stateReason === "COMPLETED";
+  const found = !linked.length && issue.state === "OPEN" ? unlinkedPrs(io, slug, number) : null;
+  const fresh = (found?.prs ?? []).filter((p) => !issue.prs.some((x) => x.number === p.number));
+  const unlinked = fresh.filter((p) => p.merged);
+  const merged = linked.length ? linked : unlinked;
+  if (!merged.length && !closedNoPr) {
+    const prs = [...issue.prs, ...fresh].map((p) => `#${p.number} ${p.state === "OPEN" ? "open" : "closed without a merge"}`).join(", ");
+    const what = prs ? `PR ${prs}` : `the task is ${issue.state === "OPEN" ? "open" : "closed without being done"}, no merged PR`;
+    const checked = found ? `; checked: the PR–task link, the branch <type>/${number}-<slug> and «Closes #${number}» in the body of the last ${RECENT_PRS} PRs into ${found.base}` : "";
+    throw new GhError(`#${number} is too early to close: ${what}${checked} — close after the PR is merged or the task is closed`);
+  }
+  if (issue.parent) {
+    const epic = loadTaskText(io, slug, issue.parent.number);
+    const others = epic.subIssues.filter((x) => x.state === "OPEN" && x.number !== number).length;
+    if (others && !refreshReported(epic, number)) {
+      const head = locale_default.fill(N.actualize.report, { number, text: "…" });
+      throw new GhError(`#${number} is too early to close: the epic refresh hasn't reported — epic #${epic.number} has open tasks besides #${number} (${others}), and no comment «${head}» on it. ` + `The refresh subagent is at work — wait for its answer, then task close ${number} again; it wasn't launched — task actualize ${number} and the subagent with its prompt; ` + `it answered without the comment — post its result: gh issue comment ${epic.number} --repo ${slug} --body "${head}"`);
+    }
+  }
+  const wasOpen = issue.state === "OPEN";
+  if (wasOpen) {
+    if (unlinked.length)
+      mutate(io, { op: "AddComment", input: { subjectId: issue.id, body: locale_default.fill(N.comments.closedByPr, { prs: unlinked.map((p) => `#${p.number}`).join(", ") }) } });
+    mutate(io, { op: "CloseIssue", input: { issueId: issue.id, stateReason: "COMPLETED" } });
+    io.out(unlinked.length ? `+ #${number} closed by PR ${unlinked.map((p) => `#${p.number} (${p.why})`).join(", ")}: GitHub didn't link the PR to the task` : `+ #${number} closed: PR ${merged.map((p) => `#${p.number}`).join(", ")} merged`);
+  }
+  freshClone(io, slug);
+  runFact(io, slug, number);
+  const item = ensureItem(io, ctx, issue);
+  setStatus(io, ctx, item.id, N.status.done);
+  io.out(`+ #${number}: ${STATUS} ${q(N.status.done)}${item.added ? " (added to the project)" : ""}`);
+  closeMilestone(io, slug, issue, wasOpen);
+  if (issue.parent) {
+    const epic = loadIssue(io, slug, issue.parent.number);
+    const open = epic.subIssues.filter((x) => x.state === "OPEN" && x.number !== number).length;
+    if (epic.state === "OPEN" && epic.subIssues.length && !open) {
+      mutate(io, { op: "CloseIssue", input: { issueId: epic.id, stateReason: "COMPLETED" } });
+      setStatus(io, ctx, ensureItem(io, ctx, epic).id, N.status.done);
+      io.out(`+ epic #${epic.number} closed and in ${q(N.status.done)}: all subtasks are closed`);
+      closeMilestone(io, slug, epic, true);
+    } else if (epic.state === "OPEN")
+      io.out(`○ epic #${epic.number}: open subtasks ${open}`);
+  }
+  if (!checkoutOfRepo(io, originUrl(io), slug))
+    io.out(`○ ${o.git ? "branches and task stacks" : "task stacks"} left alone: the current directory is not a checkout of ${slug}`);
+  else {
+    takeDownStacks(io, number);
+    if (o.git) {
+      const more = (found ?? unlinkedPrs(io, slug, number)).prs.filter((p) => p.merged && !merged.some((x) => x.number === p.number));
+      cleanupBranches(io, number, [...merged, ...more]);
+    }
+  }
+  io.out(`Next: the last line of the answer is one of three: ${q(N.lastLine.done)}; ` + `the owner has something to decide — ${q(`${N.lastLine.questions} …`)} with the questions themselves, without ${q(N.lastLine.done)}; ` + `something remains — ${q(`${N.lastLine.remaining} …`)}. ` + `In auto mode after ${q(N.lastLine.done)} — archive the session where the agent has the tool, ` + `first stopping its own background tasks still running (a wait, a watcher over its output, a subagent): a live one blocks archiving; ` + `after the other two lines — don't. ` + `Information without a decision (an observation, a deadline, a warning) isn't a question: the line and archiving are as with ${q(N.lastLine.done)}`);
+  return 0;
+}
+function cmdTaskResume(io) {
+  const dispatcher = dispatcherFile(io);
+  const queued = !!dispatcher && existsSync(dispatcher);
+  if (queued || dispatcher && existsSync(`${dispatcher}.tasks`)) {
+    io.out("Dispatcher session: its executors (background subagents) stopped with the app's process, their transcripts are intact — " + "continue each with SendMessage by its id from the app's notification, not a new executor: it goes on with its context in its own worktree" + (queued ? `; then re-read the queue: ${readFileSync(dispatcher, "utf8").trim()} — their tasks stay = in it` : ""));
+    io.out("Dispatcher session: a new executor — only for one that can't be continued, with the same prompt; " + `a task ${q(N.status.inProgress)} it continues in the worktree of the task's branch (\`git worktree list\`), not in a new one — its assignment says so: ` + "git won't give the branch to a second worktree, and uncommitted work stays in the old one");
+  }
+  const pin = pinnedTask(io);
+  if (!pin)
+    return 0;
+  if (!pin.task)
+    return io.out(`○ the session pin ${pin.file} — «${pin.line}», not owner/repo#N: the session has no task`), 0;
+  const { slug, number } = pin.task;
+  const task = `session task ${slug}#${number}`;
+  const issue = loadIssue(io, slug, number);
+  if (issue.state !== "OPEN")
+    return io.out(`○ ${task} is closed — no wait to restart`), 0;
+  const live = (prs) => prs.filter((p) => p.state === "OPEN" || p.merged);
+  const prs = live(issue.prs).length ? live(issue.prs) : live(unlinkedPrs(io, slug, number).prs);
+  const open = prs.filter((p) => p.state === "OPEN");
+  for (const p of open)
+    io.out(`Session task ${slug}#${number}: PR #${p.number} is open — a background wait dies with the app's process; restart it as a background command: bash ${waitCi()} pr ${p.number}`);
+  const merged = prs.filter((p) => p.merged).sort((a, b) => b.number - a.number)[0];
+  if (!open.length && merged)
+    io.out(`Session task ${slug}#${number}: PR #${merged.number} is merged, the task is open — where the merge deploys, the deploy wait as a background command: bash ${waitCi()} merged ${merged.number}; ` + `then close the task: bun --no-env-file ${import.meta.path} task close ${number}`);
+  if (!prs.length)
+    io.out(`○ ${task}: no PR — no wait to restart`);
+  return 0;
+}
+var TASK_TYPES = ["feat", "fix", "docs", "refactor", "perf", "test", "chore", "ci", "build", "research"];
+var TASK_BRANCH_RE = new RegExp("^(?:[\\p{L}\\p{N}_.-]+/)?(" + TASK_TYPES.join("|") + ")/(\\d{1,6})-", "iu");
+function taskBranch(branch) {
+  const m = TASK_BRANCH_RE.exec(branch);
+  return m ? { type: m[1].toLowerCase(), issue: parseInt(m[2], 10) } : null;
+}
+var isTaskBranch = (branch, number) => taskBranch(branch)?.issue === number;
+var TASK_SLUG_RE = /\/\d{1,6}-[a-z0-9]+(?:-[a-z0-9]+)*$/;
+var CONFIG_LOCK_TRIES = 20;
+var CONFIG_LOCK_PAUSE_MS = 500;
+var CONFIG_LOCKED = /could not lock config file (.+)$/m;
+function renameBranch(io, slug, target) {
+  const git = (...args) => (io.run ?? realRun)("git", args, io.cwd);
+  const has = (ref) => git("rev-parse", "--verify", "--quiet", ref).status === 0;
+  if (!checkoutOfRepo(io, originUrl(io), slug))
+    return io.out(`○ branch left alone: the current directory is not a checkout of ${slug}`), true;
+  const current = git("branch", "--show-current").stdout.trim();
+  if (!current) {
+    const base = git("symbolic-ref", "--quiet", "--short", "refs/remotes/origin/HEAD").stdout.trim() || "origin/main";
+    return io.out(`○ branch left alone: HEAD is detached — a task branch from a fresh ${base}: git fetch origin && git switch -c ${target} ${base} --no-track`), true;
+  }
+  if (current === target)
+    return io.out(`= branch ${target}`), true;
+  if (has(`refs/remotes/origin/${current}`))
+    return io.out(`○ branch ${current} is already on origin — left alone: a pushed branch is renamed together with its PR, by hand`), true;
+  let renamed = false;
+  let lock = "";
+  for (let k = 0;k < CONFIG_LOCK_TRIES; k++) {
+    if (k)
+      (io.sleep ?? pause)(CONFIG_LOCK_PAUSE_MS);
+    const args = renamed ? ["config", "--rename-section", `branch.${current}`, `branch.${target}`] : ["branch", "-m", current, target];
+    const r = git(...args);
+    if (r.status === 0 || renamed && /no such section/.test(r.stderr)) {
+      return io.out(`+ branch ${current} → ${target}${k ? ` (.git/config was locked: ${k} retries)` : ""}`), true;
+    }
+    const locked = CONFIG_LOCKED.exec(r.stderr);
+    if (!locked)
+      return io.out(`! git ${args.join(" ")}: ${r.stderr.trim().split(`
+`).filter(Boolean).pop() ?? `code ${r.status}`}`), false;
+    lock = `${path.resolve(io.cwd ?? process.cwd(), locked[1].trim())}.lock`;
+    renamed ||= !has(`refs/heads/${current}`) && has(`refs/heads/${target}`);
+  }
+  let age = "";
+  try {
+    age = ` (${Math.round((Date.now() - statSync(lock).mtimeMs) / 1000)} s)`;
+  } catch {}
+  const what = renamed ? `renamed to ${target}, its section in .git/config is not` : `${current} is not renamed`;
+  const finish = renamed ? `git config --rename-section branch.${current} branch.${target}` : `git branch -m ${current} ${target}`;
+  io.out(`! branch ${what}: ${lock} is held by another git process${age} — not removed; finish: ${finish}`);
+  return false;
+}
+function unlinkedPrs(io, slug, number) {
+  const [owner, name] = slug.split("/");
+  const r = graphql(io, Q.RecentPrs, { owner, name })?.repository;
+  const base = r?.defaultBranchRef?.name ?? "main";
+  const prs = [];
+  for (const p of r?.pullRequests?.nodes ?? []) {
+    if (p.baseRefName !== base)
+      continue;
+    const head = p.headRefName ?? "";
+    const why = isTaskBranch(head, number) ? `branch ${head}` : closingInBody(p.body ?? "").includes(number) ? `«Closes #${number}» in the body` : null;
+    if (why)
+      prs.push({ number: p.number, state: p.state ?? "", merged: Boolean(p.merged), head, base, why });
+  }
+  return { base, prs };
+}
+var estScript = (io) => io.env.ELVES_EST ?? path.resolve(import.meta.dir, "../../est/scripts/est.ts");
+function originUrl(io) {
+  const remote = (io.run ?? realRun)("git", ["remote", "get-url", "origin"], io.cwd);
+  return remote.status === 0 ? remote.stdout : "";
+}
+var taskEnvScript = (io) => io.env.ELVES_TASK_ENV ?? path.resolve(import.meta.dir, "../../task-env/scripts/task-env.ts");
+function takeDownStacks(io, number) {
+  const script = taskEnvScript(io);
+  if (!existsSync(script))
+    return io.out(`○ task stacks: task-env is not installed (${script})`);
+  const r = (io.run ?? realRun)("bun", ["--no-env-file", script, "down", String(number)], io.cwd);
+  const lines = r.stdout.split(`
+`).filter((l) => l.trim());
+  for (const line of lines)
+    io.out(line);
+  if (r.status !== 0 && !lines.length)
+    io.out(`! task-env down: ${r.stderr.trim().split(`
+`).filter(Boolean).pop() ?? `code ${r.status}`}`);
+}
+function runEst(io, est, args) {
+  const r = (io.run ?? realRun)("bun", ["--no-env-file", est, ...args], io.cwd);
+  for (const line of r.stdout.split(`
+`))
+    if (line.trim() && !line.startsWith("<!--"))
+      io.out(line);
+  if (r.status !== 0)
+    io.out(`! est ${args[0]}: ${r.stderr.trim().split(`
+`).filter(Boolean).pop() ?? `code ${r.status}`}`);
+}
+function freshClone(io, slug) {
+  const est = estScript(io);
+  if (!existsSync(est))
+    return;
+  const run = io.run ?? realRun;
+  const top = run("git", ["rev-parse", "--show-toplevel"], path.dirname(est));
+  if (top.status !== 0)
+    return;
+  const dir = top.stdout.trim();
+  const git = (...args) => run("git", args, dir);
+  const origin = git("remote", "get-url", "origin");
+  if (origin.status !== 0 || !checkoutOfRepo(io, origin.stdout, slug))
+    return;
+  const base = git("symbolic-ref", "--quiet", "--short", "refs/remotes/origin/HEAD").stdout.trim().replace(/^origin\//, "") || "main";
+  const branch = git("branch", "--show-current").stdout.trim();
+  const left = (why) => io.out(`○ clone ${dir} left alone: ${why} — the actual is by its code`);
+  if (branch !== base)
+    return left(branch ? `on branch ${branch}, not ${base}` : `HEAD is detached, not on ${base}`);
+  const status = git("status", "--porcelain", "--untracked-files=no");
+  if (status.status !== 0 || status.stdout.trim())
+    return left("uncommitted changes");
+  const head = () => git("rev-parse", "--short", "HEAD").stdout.trim();
+  const before = head();
+  const pull = git("pull", "--ff-only", "--no-rebase", "--quiet", "origin", base);
+  if (pull.status !== 0) {
+    const why = pull.stderr.trim().split(`
+`).filter(Boolean).pop() ?? `code ${pull.status}`;
+    return io.out(`! clone ${dir}: git pull --ff-only origin ${base}: ${why} — the actual is by its code`);
+  }
+  const after = head();
+  io.out(after === before ? `= clone ${dir} ${after}` : `+ clone ${dir} ${before} → ${after}`);
+}
+function runFact(io, slug, number) {
+  const est = estScript(io);
+  if (!existsSync(est))
+    return io.out(`○ actual unavailable: est is not installed (${est}) — est fact ${number} --write after installing it`);
+  runEst(io, est, ["fact", String(number), "--repo", slug, "--write"]);
+}
+function runEstimate(io, slug, number, type) {
+  const est = estScript(io);
+  if (!existsSync(est))
+    return io.out(`○ no estimate: est is not installed (${est})`);
+  runEst(io, est, ["estimate", String(number), "--repo", slug, "--type", type, "--write"]);
+}
+function closeMilestone(io, slug, issue, wasOpen) {
+  const m = issue.milestone;
+  if (!m)
+    return;
+  const open = m.open - (wasOpen ? 1 : 0);
+  if (open > 0)
+    return io.out(`○ milestone ${q(m.title)}: open tasks ${open}`);
+  io.gh(["api", "-X", "PATCH", `repos/${slug}/milestones/${m.number}`, "-f", "state=closed"]);
+  io.out(`+ milestone ${q(m.title)} closed: no open tasks left`);
+}
+function cleanupBranches(io, number, prs) {
+  const git = (...args) => (io.run ?? realRun)("git", args, io.cwd);
+  const current = git("branch", "--show-current").stdout.trim();
+  const merged = new Map;
+  for (const p of prs)
+    if (p.head && !merged.has(p.head))
+      merged.set(p.head, p.base || "main");
+  const loose = current && !merged.has(current) && isTaskBranch(current, number) ? current : "";
+  if (!merged.size && !loose)
+    return io.out("○ the task branch not found — branches left alone");
+  git("fetch", "--prune", "origin");
+  if (loose) {
+    const base = prs[0]?.base || "main";
+    const cherry = git("cherry", `origin/${base}`, loose);
+    if (cherry.status !== 0 || cherry.stdout.split(`
+`).some((l) => l.startsWith("+")))
+      io.out(`○ branch ${loose} is not merged into origin/${base} — left alone`);
+    else
+      merged.set(loose, base);
+  }
+  if (!merged.size)
+    return;
+  for (const [branch, base] of merged) {
+    if (current === branch) {
+      const sw = git("switch", "--detach", `origin/${base}`);
+      if (sw.status !== 0) {
+        io.out(`! git switch --detach origin/${base}: ${sw.stderr.trim()}`);
+        continue;
+      }
+      io.out(`+ checkout — on origin/${base} (detached)`);
+    }
+    if (git("branch", "--list", branch).stdout.trim()) {
+      const d = git("branch", "-D", branch);
+      io.out(d.status === 0 ? `+ local branch ${branch} deleted` : `! git branch -D ${branch}: ${d.stderr.trim()}`);
+    }
+    if (git("ls-remote", "--heads", "origin", branch).stdout.trim()) {
+      const d = git("push", "origin", "--delete", branch);
+      io.out(d.status === 0 ? `+ remote branch ${branch} deleted` : `! git push origin --delete ${branch}: ${d.stderr.trim()}`);
+    } else
+      io.out(`○ remote branch ${branch} is already gone`);
+  }
+  const top = git("rev-parse", "--show-toplevel").stdout.trim();
+  const common = git("rev-parse", "--git-common-dir").stdout.trim();
+  if (!top || !common || path.resolve(io.cwd ?? process.cwd(), common) === path.join(top, ".git"))
+    return;
+  if (AGENT_WORKTREE.test(top))
+    io.out(`○ agent worktree ${top}: the dispatcher's next task queue removes it`);
+  else
+    io.out(`Next: remove worktree ${top} from the main checkout: git worktree remove ${top}`);
+}
+function addLabels(io, issue, names, all) {
+  const missing = names.filter((n) => !issue.labels.includes(n));
+  if (!missing.length)
+    return "";
+  if (issue.rest)
+    rest(io, `${issue.rest}/labels`, { method: "POST", payload: { labels: missing } });
+  else
+    mutate(io, { op: "AddLabels", input: { labelableId: issue.id, labelIds: missing.map((n) => all.find((l) => l.name === n).id) } });
+  issue.labels.push(...missing);
+  return missing.join(", ");
+}
+var LEGACY_EXCEPTIONS = /^exceptions\.(ts|mts|js|mjs|json)$/;
+function exceptionFile(p) {
+  const parts = p.split("/");
+  if (parts[0] !== "tests" || parts.length < 4 || !DECISION_KINDS.some((k) => DECISIONS[k].dir === parts[1]))
+    return null;
+  const folder = parts.slice(0, 3).join("/");
+  const inner = parts.slice(3);
+  if (inner.some((s) => s.startsWith(".")))
+    return null;
+  const at = inner.findIndex((s, i) => i < inner.length - 1 ? s === "exceptions" : LEGACY_EXCEPTIONS.test(s));
+  if (at < 0)
+    return null;
+  const dir = "exceptions";
+  if (at === inner.length - 1)
+    return { folder, dir, legacy: true };
+  if (at > 0)
+    return { folder, dir, legacy: false, error: "the exceptions directory is in a subfolder" };
+  if (inner.length > 2 || !p.endsWith(".json"))
+    return { folder, dir, legacy: false, error: "an exception is not a .json file" };
+  return { folder, dir, legacy: false };
+}
+function mechanical(f) {
+  if (f.changeType === "DELETED")
+    return true;
+  if (f.changeType === "RENAMED" && f.additions === 0 && f.deletions === 0)
+    return true;
+  const x = exceptionFile(f.path);
+  return !!x && !x.error;
+}
+function decisionsOfFiles(files, modules) {
+  const out = new Map;
+  const add = (name, kind, f) => {
+    const d = out.get(name) ?? { kinds: new Set, changed: false };
+    d.kinds.add(kind);
+    d.changed ||= !mechanical(f);
+    out.set(name, d);
+  };
+  const byDir = Object.fromEntries(DECISION_KINDS.map((k) => [DECISIONS[k].dir, k]));
+  for (const f of files) {
+    const parts = f.path.split("/");
+    if (parts[0] === "tests") {
+      const kind = byDir[parts[1] ?? ""];
+      if (kind && parts.length > 3)
+        add(parts[2], kind, f);
+      continue;
+    }
+    let best = null;
+    for (const [m, dirs] of Object.entries(modules)) {
+      for (const d of dirs)
+        if ((f.path === d || f.path.startsWith(d + "/")) && (!best || d.length > best[1]))
+          best = [m, d.length];
+    }
+    if (best)
+      add(best[0], "architecture", f);
+  }
+  const names = [...out.keys()].sort();
+  return {
+    changed: new Map(names.filter((n) => out.get(n).changed).map((n) => [n, DECISION_KINDS.filter((k) => out.get(n).kinds.has(k))])),
+    mechanical: names.filter((n) => !out.get(n).changed)
+  };
+}
+function statementDecisions(files, body) {
+  const dirs = new Set(DECISION_KINDS.map((k) => DECISIONS[k].dir));
+  const out = new Set;
+  for (const f of files) {
+    const [root, dir, name, file, ...rest] = f.path.split("/");
+    if (root === "tests" && dirs.has(dir) && file === `${name}.md` && !rest.length && !mechanical(f))
+      out.add(name);
+  }
+  const heads = locale_default.every((n) => n.prSpecSection);
+  const exceptions = locale_default.every((n) => n.spec.diff.exceptionsTitle).map((t) => `**${t}`);
+  let inSection = false;
+  let skip = false;
+  for (const raw of body.split(/\r?\n/)) {
+    const line = raw.trim();
+    if (heads.includes(line))
+      [inSection, skip] = [true, false];
+    else if (/^##\s/.test(line))
+      inSection = false;
+    else if (!inSection)
+      continue;
+    else if (/^#{3,}\s/.test(line))
+      skip = false;
+    else if (line.startsWith("**"))
+      skip = exceptions.some((t) => line.startsWith(t));
+    else if (!skip) {
+      const m = /^(?:[-*]\s+(?:✅\s+)?|\|\s*)`tests\/([^`/]+)\/([^`/]+)[^`]*`/.exec(line);
+      if (m && dirs.has(m[1]))
+        out.add(m[2]);
+    }
+  }
+  return out;
+}
+function putLabels(io, issue, who, want, statements, all) {
+  const lines = [];
+  const missing = want.filter((n) => !issue.labels.includes(n));
+  const room = Math.max(0, ISSUE_LABEL_LIMIT - issue.labels.length);
+  let add = missing;
+  if (missing.length > room) {
+    const named = statements ? missing.filter((n) => statements.has(n)) : [...missing].sort();
+    const bodies = statements ? missing.filter((n) => !statements.has(n)) : [];
+    add = named.slice(0, room);
+    const which = statements ? "only decisions whose <folder>.md or test names the PR changes" : "alphabetically, as many as fit";
+    const without = bodies.length ? `; test bodies and code only, no label: ${bodies.join(", ")}` : "";
+    lines.push(`○ ${who}: ${missing.length} new decision labels, room for ${room} (GitHub puts at most ${ISSUE_LABEL_LIMIT} on an issue, it has ${issue.labels.length}) — ${which}${without}`);
+    if (named.length > room)
+      lines.push(`○ ${who}: no room — not set: ${named.slice(room).join(", ")}`);
+  }
+  const added = addLabels(io, issue, add, all);
+  if (added)
+    lines.push(`+ ${who}: ${added}`);
+  return lines;
+}
+function closingInBody(body) {
+  const out = [];
+  for (const m of body.matchAll(/\b(?:close[sd]?|fix(?:e[sd])?|resolve[sd]?):?\s+#(\d+)\b/gi))
+    if (!out.includes(Number(m[1])))
+      out.push(Number(m[1]));
+  return out;
+}
+function loadPrChange(io, slug, number) {
+  const [owner, name] = slug.split("/");
+  let head = null;
+  const files = pages((after) => {
+    const pr = graphql(io, Q.PrChange, { owner, name, number, after })?.repository?.pullRequest;
+    if (!pr)
+      throw new GhError(`no PR #${number} in ${slug}`);
+    head ??= pr;
+    return pr.files;
+  });
+  return { head, files };
+}
+function cmdPrLabels(io, slug, number) {
+  const [owner, name] = slug.split("/");
+  const { head, files } = loadPrChange(io, slug, number);
+  let closes = (head.closingIssuesReferences?.nodes ?? []).map((x) => x.number);
+  if (!closes.length)
+    closes = closingInBody(head.body ?? "");
+  if (!closes.length)
+    throw new GhError(`PR #${number} has no «Closes #N» — nowhere to put the labels`);
+  const model = graphql(io, Q.ModelAt, { owner, name, expression: `${head.headRefOid}:${MODEL_PATH}` })?.repository?.object;
+  let modules = {};
+  if (model) {
+    const m = modelModules(model.text ?? "");
+    if (typeof m === "string")
+      io.err(`warning: model ${MODEL_PATH} of the PR head doesn't load — modules not counted: ${m}`);
+    else
+      modules = m;
+  }
+  const { changed: decided, mechanical: skipped } = decisionsOfFiles(files, modules);
+  const all = decided.size ? loadLabels(io, slug) : [];
+  const dimensions = all.flatMap((l) => {
+    const dim = decided.has(l.name) ? labelDimension(l.description) : null;
+    return dim ? [{ name: l.name, dim }] : [];
+  });
+  const want = [...decided.keys()].filter((n) => !dimensions.some((x) => x.name === n));
+  io.out(`PR #${number} → ${closes.map((n) => `#${n}`).join(", ")}: ${want.join(", ") || "no decisions in the diff"}`);
+  for (const l of skipped)
+    io.out(`○ ${l} — only a mechanical edit (a deletion, a rename without changes, exceptions): no label`);
+  for (const x of dimensions)
+    io.out(`○ ${x.name} — label ${q(x.name)} is slice ${q(x.dim)}, not a decision label: not set`);
+  if (!want.length)
+    return 0;
+  const fresh = want.filter((l) => !all.some((x) => x.name === l));
+  const repoId = fresh.length ? loadRepo(io, slug).id : "";
+  for (const l of fresh) {
+    const label = decisionLabel(l, decided.get(l));
+    const created = mutate(io, { op: "CreateLabel", input: { repositoryId: repoId, ...label } }).createLabel.label;
+    all.push({ id: created.id, ...label, open: { total: 0, numbers: [] } });
+    io.out(`+ created label ${q(l)}`);
+  }
+  const isDecision = (n) => legacyDecision(n) !== null || labelKinds(all.find((x) => x.name === n)?.description) !== null;
+  const statements = statementDecisions(files, head.body ?? "");
+  const epics = new Map;
+  for (const n of closes) {
+    const issue = loadIssue(io, slug, n);
+    for (const l of putLabels(io, issue, `#${n}`, want, statements, all))
+      io.out(l);
+    for (const l of issue.labels.filter((x) => isDecision(x) && !want.includes(x)))
+      io.out(`= #${n}: ${l} — the decision is not in the PR diff, the label stays`);
+    if (issue.parent && !epics.has(issue.parent.number))
+      epics.set(issue.parent.number, loadIssue(io, slug, issue.parent.number));
+  }
+  for (const epic of epics.values())
+    for (const l of putLabels(io, epic, `epic #${epic.number}`, want, statements, all))
+      io.out(l);
+  return 0;
+}
+var PREMERGE_SCRIPTS = ["typecheck", "test:spec"];
+var SPEC_ROOTS = ["tests/standards", "tests/architecture"];
+var specRoots = (dir) => SPEC_ROOTS.filter((d) => statSync(path.join(dir, d), { throwIfNoEntry: false })?.isDirectory());
+var MERGE_REF_SLACK_MS = 60000;
+var INSTALL = { bun: ["bun", "install", "--frozen-lockfile"], pnpm: ["pnpm", "install", "--frozen-lockfile"], yarn: ["yarn", "install", "--frozen-lockfile"], npm: ["npm", "ci"] };
+var FAILED_LINE = /^\s*(\(fail\)|FAIL\s|×|✗|✘|●\s)|\berror TS\d+:/;
+var BUN_CHECK_ERROR = /<error file="([^"]+)" line="(\d+)" column="(\d+)" code="(TS\d+)">\n([^\n]*)/g;
+var asTsc = (out) => out.replace(BUN_CHECK_ERROR, "$1($2,$3): error $4: $5");
+function packageManager(dir) {
+  const lockfiles = [["bun.lock", "bun"], ["bun.lockb", "bun"], ["pnpm-lock.yaml", "pnpm"], ["yarn.lock", "yarn"], ["package-lock.json", "npm"]];
+  const has = (file) => existsSync(path.join(dir, file));
+  let field = "";
+  try {
+    field = String(JSON.parse(readFileSync(path.join(dir, "package.json"), "utf8"))?.packageManager ?? "");
+  } catch {}
+  const declared = /^(bun|pnpm|yarn|npm)@((\d*)(?:\.\d+)*)/.exec(field);
+  const found = lockfiles.filter(([file]) => has(file));
+  const yarnrc = has(".yarnrc.yml");
+  const name = declared?.[1] ?? found[0]?.[1] ?? (yarnrc ? "yarn" : "npm");
+  const berry = name === "yarn" && (declared ? Number(declared[3]) >= 2 : yarnrc);
+  return { name, berry, lockfile: (found.find(([, pm]) => pm === name) ?? found[0])?.[0] ?? null, version: declared?.[2] || null };
+}
+function projectCommands(dir) {
+  const pm = packageManager(dir);
+  return { install: pm.lockfile ? INSTALL[pm.name] : null, run: (script) => [pm.name, "run", script] };
+}
+var tail = (r, n = 20) => `${r.stdout}
+${r.stderr}`.split(`
+`).filter((l) => l.trim()).slice(-n);
+var failure = (l) => l.trim().replace(/\s*\[[\d.]+\s*m?s\]$/, "").replace(/\s+[\d.]+\s*m?s$/, "").replace(/^(\S+?)\(\d+,\d+\)(?=:)/, "$1");
+var waitCi = () => path.resolve(import.meta.dir, "../../ci-wait/scripts/wait-ci.sh");
+var RED_RUN = new Set(["failure", "timed_out", "startup_failure"]);
+var RED_STATUS = new Set(["failure", "error"]);
+var SPEC_PUBLISH = /^(?:.+ \/ )?spec-publish$/;
+function redChecksOf(io, slug, base) {
+  const ref = encodeURIComponent(base);
+  const latest = new Map;
+  for (const r of restCall(io, ["api", `repos/${slug}/commits/${ref}/check-runs?per_page=100`]).check_runs ?? []) {
+    if (!latest.has(r.name) || latest.get(r.name).id < r.id)
+      latest.set(r.name, r);
+  }
+  const status = restCall(io, ["api", `repos/${slug}/commits/${ref}/status`]);
+  const names = [
+    ...[...latest.values()].filter((r) => r.status === "completed" && RED_RUN.has(r.conclusion)).map((r) => r.name),
+    ...(status.statuses ?? []).filter((x) => RED_STATUS.has(x.state)).map((x) => x.context)
+  ];
+  const red = [...new Set(names)].sort();
+  return { sha: String(status.sha ?? ""), names: red.filter((n) => !SPEC_PUBLISH.test(n)), publish: red.filter((n) => SPEC_PUBLISH.test(n)) };
+}
+var mainRedPrefixes = (base) => [...new Set([N, ...locale_default.everyNames()].map((n) => locale_default.fill(n.mainRed.title, { base })))];
+function mainBugsOf(io, slug, base) {
+  const prefixes = mainRedPrefixes(base);
+  const found = new Map;
+  for (const prefix of prefixes) {
+    const q = `repo:${slug} is:issue is:open in:title "${prefix}"`;
+    for (const i of restCall(io, ["api", `search/issues?q=${encodeURIComponent(q)}&per_page=20`]).items ?? [])
+      found.set(i.number, i);
+  }
+  return [...found.values()].filter((i) => !i.pull_request && prefixes.some((p) => String(i.title).startsWith(p))).sort((a, b) => a.number - b.number);
+}
+function bugNames(base, title, check) {
+  const prefix = mainRedPrefixes(base).find((p) => title.startsWith(p)) ?? "";
+  return new RegExp(`(?:^|[\\s,«"(])${locale_default.escapeRe(check)}(?=$|[\\s,;»")])`, "u").test(title.slice(prefix.length));
+}
+function cmdPrPremerge(io, slug, number) {
+  const pr = restCall(io, ["api", `repos/${slug}/pulls/${number}`]);
+  if (pr.state !== "open")
+    throw new GhError(`PR #${number} is not open — nothing to merge`);
+  const head = pr.head.sha;
+  const base = pr.base.ref;
+  const closes = closingInBody(pr.body ?? "");
+  const mainRed = (lead, why, red, what, say = what) => {
+    let bugs = [];
+    try {
+      bugs = mainBugsOf(io, slug, base);
+    } catch (e) {
+      if (!(e instanceof GhError))
+        throw e;
+      io.out(`○ open bug on red ${base} not found by search: ${e.message}`);
+    }
+    const fix = bugs.find((b) => closes.includes(b.number));
+    if (fix) {
+      io.out(`○ ${base} is red — ${why}; the PR closes bug #${fix.number} about it — checking the PR as usual`);
+      return null;
+    }
+    io.out(lead);
+    const named = (b) => red.some((n) => bugNames(base, b.title, n));
+    for (const b of bugs.filter((b) => !named(b)))
+      io.out(`○ #${b.number} «${b.title}» — about another check: don't wait`);
+    const wait = (n) => `wait for it to close — bash ${waitCi()} issue ${n} as a background command, then pr premerge ${number} again`;
+    const bug = bugs.find(named);
+    if (bug)
+      io.out(`bug on red ${base} — #${bug.number} «${bug.title}»: ${wait(String(bug.number))}`);
+    const unnamed = red.filter((n) => !bugs.some((b) => bugNames(base, b.title, n)));
+    if (unnamed.length) {
+      const priority = pr.base?.repo?.owner?.type === "Organization" ? " --priority Urgent" : "";
+      const title = `${locale_default.fill(N.mainRed.title, { base })}: ${what(unnamed)}`;
+      io.out(`no bug on red ${base} about ${say(unnamed)} — find an open one on the failed test or file one (label — the failed test's decision) and ask the owner whether to queue it: bun --no-env-file ${import.meta.path} task new --type ${N.issueTypes.bug}${priority} --title ${JSON.stringify(title)}; ${wait("<N>")}`);
+    }
+    io.out(`⛔ don't merge: ${base} is red, not this PR — don't fix it in your PR`);
+    return 3;
+  };
+  try {
+    const red = redChecksOf(io, slug, base);
+    if (red.publish.length) {
+      io.out(`○ ${red.publish.join(", ")} red on the last commit of ${base} (${red.sha.slice(0, 7)}) — publishing the documentation, not a check of ${base}: not counted`);
+    }
+    if (red.names.length) {
+      const checks = (names) => `${names.length > 1 ? "checks" : "check"} ${names.join(", ")}`;
+      const titled = (names) => locale_default.fill(names.length > 1 ? N.mainRed.checks : N.mainRed.check, { names: names.join(", ") });
+      const why = `${checks(red.names)} of the last commit of ${base} (${red.sha.slice(0, 7)})`;
+      const code = mainRed(`${base} is red: ${why}`, why, red.names, titled, checks);
+      if (code !== null)
+        return code;
+    }
+  } catch (e) {
+    if (!(e instanceof GhError))
+      throw e;
+    io.out(`○ checks of the last commit of ${base} not read (${e.message}) — whether ${base} is red is unknown from the checks`);
+  }
+  const suites = (restCall(io, ["api", `repos/${slug}/commits/${head}/check-suites?per_page=100`]).check_suites ?? []).map((s) => s.created_at).filter(Boolean);
+  const ci = suites.sort()[0];
+  let moved = null;
+  let unread = null;
+  try {
+    moved = restCall(io, ["api", `repos/${slug}/activity?ref=${encodeURIComponent(`refs/heads/${base}`)}&per_page=1`])[0]?.timestamp ?? null;
+  } catch (e) {
+    if (!(e instanceof GhError))
+      throw e;
+    unread = e.message;
+  }
+  const check = `checking the merge with origin/${base}`;
+  if (!ci)
+    io.out(`the head of PR #${number} has no checks — what CI checked is unknown: ${check}`);
+  else if (unread)
+    io.out(`○ movement of ${base} not read (${unread}) — ${check}`);
+  else if (!moved || Date.parse(moved) <= Date.parse(ci) - MERGE_REF_SLACK_MS) {
+    io.out(`✅ merge: ${base} hasn't moved since the CI of PR #${number} (CI since ${ci}, last movement of ${base} — ${moved ?? "none"}) — CI checked this merge`);
+    return 0;
+  } else
+    io.out(`${base} moved after the CI of PR #${number} (CI since ${ci}, ${base} — ${moved}) — ${check}`);
+  const run = io.run ?? realRun;
+  const git = (cwd, ...args) => run("git", args, cwd);
+  if (!checkoutOfRepo(io, originUrl(io), slug))
+    throw new GhError(`the merge check runs from a checkout of ${slug}: the current directory is not one`);
+  const fetched = git(io.cwd, "fetch", "-q", "origin", base);
+  if (fetched.status !== 0)
+    throw new GhError(`git fetch origin ${base}: ${fetched.stderr.trim()}`);
+  const got = git(io.cwd, "fetch", "-q", "origin", head);
+  if (got.status !== 0)
+    throw new GhError(`PR head ${head} not fetched from origin (${got.stderr.trim().split(`
+`).at(-1)}) — was the PR updated? ci-wait again`);
+  const dirs = [];
+  const worktree = () => {
+    const dir = mkdtempSync(path.join(os.tmpdir(), "elves-premerge-"));
+    dirs.push(dir);
+    const add = git(io.cwd, "worktree", "add", "-q", "--detach", dir, `origin/${base}`);
+    if (add.status !== 0)
+      throw new GhError(`git worktree add: ${add.stderr.trim()}`);
+    return dir;
+  };
+  const ON_MERGE = "on the merge";
+  const scriptsOf = (dir) => {
+    const pkg = path.join(dir, "package.json");
+    return existsSync(pkg) ? JSON.parse(readFileSync(pkg, "utf8")).scripts ?? {} : {};
+  };
+  const checks = (dir, where, scripts) => {
+    const defined = scriptsOf(dir);
+    const present = scripts.filter((s) => defined[s]);
+    if (!present.length)
+      return null;
+    const cmds = projectCommands(dir);
+    if (cmds.install) {
+      const r = run(cmds.install[0], cmds.install.slice(1), dir);
+      if (r.status !== 0)
+        throw new GhError(`installing dependencies ${where} failed (${cmds.install.join(" ")}): ${tail(r, 5).join(" / ")}`);
+      io.out(`+ dependencies${where === ON_MERGE ? "" : ` ${where}`}: ${cmds.install.join(" ")}`);
+    }
+    const ran = [];
+    for (const script of present) {
+      const cmd = cmds.run(script);
+      const result = run(cmd[0], cmd.slice(1), dir);
+      ran.push(script);
+      if (result.status === 0)
+        continue;
+      const failed = [...new Set(asTsc(`${result.stdout}
+${result.stderr}`).split(`
+`).filter((l) => FAILED_LINE.test(l)).map((l) => l.trim()))];
+      return { ran, red: { script, cmd: cmd.join(" "), result, failed } };
+    }
+    return { ran, red: null };
+  };
+  const breaks = (script) => `❌ don't merge: ${script} is red on the merge with origin/${base} — fix the root cause in the PR: rebase onto origin/${base}, edit, push --force-with-lease, ci-wait again`;
+  try {
+    const dir = worktree();
+    const short = (ref) => git(dir, "rev-parse", "--short=7", ref).stdout.trim();
+    const merge = git(dir, "-c", "user.name=elves", "-c", "user.email=elves@localhost", "-c", "commit.gpgsign=false", "merge", "-q", "--no-ff", "--no-verify", "--no-edit", head);
+    if (merge.status !== 0) {
+      const files = git(dir, "diff", "--name-only", "--diff-filter=U").stdout.split(`
+`).filter(Boolean);
+      if (!files.length)
+        throw new GhError(`git merge: ${merge.stderr.trim()}`);
+      io.out(`❌ don't merge: a merge conflict with origin/${base} — ${files.join(", ")}; rebase onto origin/${base}, push --force-with-lease, ci-wait again`);
+      return 1;
+    }
+    io.out(`+ merge of ${head.slice(0, 7)} with origin/${base} ${short("HEAD^1")} — no conflicts`);
+    const roots = specRoots(dir);
+    if (roots.length && !scriptsOf(dir)["test:spec"])
+      io.out(`○ ${roots.join(", ")} aren't checked on the merge: the merge's package.json has no test:spec script — the project's check names the line to add (bunx github:miroshnik/elves check)`);
+    const merged = checks(dir, ON_MERGE, PREMERGE_SCRIPTS);
+    if (!merged) {
+      io.out(`○ no fast checks: the merge's package.json has no ${PREMERGE_SCRIPTS.join(" or ")} scripts — step skipped`);
+      io.out(`✅ merge: the merge with origin/${base} has no conflicts`);
+      return 0;
+    }
+    const red = merged.red;
+    if (!red) {
+      io.out(`✅ merge: ${merged.ran.join(" and ")} ${merged.ran.length > 1 ? "are" : "is"} green on the merge with origin/${base}`);
+      return 0;
+    }
+    io.out(`${red.cmd} failed:`);
+    for (const l of red.failed.length ? red.failed.slice(0, 20) : tail(red.result))
+      io.out(`  ${l.trim()}`);
+    io.out(`checking bare origin/${base}: is it red by itself`);
+    const bare = checks(worktree(), `on origin/${base}`, [red.script])?.red;
+    if (!bare) {
+      io.out(breaks(red.script));
+      return 1;
+    }
+    const onMain = new Set(bare.failed.map(failure));
+    const own = red.failed.filter((l) => !onMain.has(failure(l)));
+    if (own.length && bare.failed.length) {
+      io.out(`${base} is red by itself, the PR breaks beyond it:`);
+      for (const l of own.slice(0, 20))
+        io.out(`  ${l}`);
+      io.out(breaks(red.script));
+      return 1;
+    }
+    const why = `${red.script} is red on bare origin/${base} too, with the same failures`;
+    const code = mainRed(`${base} is red by itself: ${why}`, why, [red.script], (names) => names.join(", "));
+    if (code !== null)
+      return code;
+    io.out(breaks(red.script));
+    return 1;
+  } finally {
+    for (const dir of dirs) {
+      git(io.cwd, "worktree", "remove", "--force", dir);
+      rmSync(dir, { recursive: true, force: true });
+    }
+    git(io.cwd, "worktree", "prune");
+  }
+}
+var HELP = {
+  "project check": `github project check [--repo owner/repo]
+
+Items ✅/❌; code 0 — everything per the canon, 1 — there are ❌. Decision labels — by the default branch's spec tree; a
+new decision's label on an open task and a slice label («Slice: …») with a decision's name — an ○ line, not ❌.
+
+Examples:
+  github project check
+  github project check --repo acme/shop`,
+  "project fix": `github project fix [--repo owner/repo] [--confirm] [--template owner/N | none]
+
+Fixes via the API and prints UI steps with links; deleting and renaming in a project with tasks and organization
+settings — only with --confirm (after the user's "yes"). No project — links the one of the same name, otherwise copies
+the template (${DEFAULT_TEMPLATE}), otherwise creates one.
+
+Examples:
+  github project fix
+  github project fix --confirm --template none`,
+  "task new": `github task new --title "…" --branch-type <type> [--body "…" | --body-file F] [--type Task|Bug|Epic] [--epic N]
+                [--milestone "…"] [--blocked-by N,N] [--priority Urgent|High|Medium|Low]
+                [--labels <decision>,<kind>:<new decision>,<label>] [--repo owner/repo]
+
+A task by the canon: type, project and Backlog, Priority, epic, blocked by, milestone, decision labels, the questions
+label when the description has a question without ✅ (created if missing); sets the estimate itself (est estimate
+--write with --branch-type: feat, fix, docs, refactor, perf, test, chore, ci, build, research; a bug without it is
+fix, an epic isn't estimated) and prints what was created and the next step. A Claude Code cloud session — over the
+repository's REST, without the project: Status, the estimate and an organization's Priority — a line for a local session.
+
+Examples:
+  github task new --title "Billing · Export invoices to PDF" --branch-type feat --epic 40 --body-file task.md
+  github task new --title "Login fails on Safari" --type Bug --priority High --body "Steps: …"`,
+  "task show": `github task show <N> [--repo owner/repo]
+
+The task in one output: title, type, Status, estimate, the epic with its open questions and tasks, subtasks, open
+blockers, the PRs with their checks, open and answered questions, the description; read-only. A cloud session — over the
+repository's REST, without the project's fields; the PRs — by the task branch or «Closes #N».
+
+Examples:
+  github task show 42`,
+  "task answer": `github task answer <N> <k> "<answer>" [--auto] [--repo owner/repo]
+
+✅ and «**Answer:** …» at question k of the questions section (--auto — the auto mark), the numbering unchanged; no open
+questions left — the questions label is removed; an answered question is refused. A question is answered by ✅ at the
+start of its answer, not by ✅ in its text. A cloud session — over the repository's REST.
+
+Examples:
+  github task answer 42 1 "Only PDF, no CSV yet"
+  github task answer 42 2 "Medium, by recommendation" --auto`,
+  "task status": `github task status <N> <Backlog|In progress|Done> [--branch <type>/<N>-<slug>] [--repo owner/repo]
+
+Status in the project (and the epic's In progress once its first subtask is taken). In progress pins the task to the
+session (file sessions/<CLAUDE_CODE_SESSION_ID> in ~/.config/elves): another task in the same session — a refusal
+(code 2) with the question to the owner whether to queue it and its executor's prompt; a task handed out to an
+executor of this session (task queue --assignment) isn't pinned; a human removes the pin. --branch — the worktree
+tool's branch becomes the task branch (git branch -m with its .git/config section); a .git/config locked by another
+checkout — retried ~10 s, then a ! line with the command that finishes it (code 1).
+
+Examples:
+  github task status 42 "In progress" --branch feat/42-invoice-export
+  github task status 42 Backlog`,
+  "task drop": `github task drop <N> [--duplicate-of M] [--repo owner/repo]
+
+Closes the task without doing it (not planned) and removes it from the project.
+
+Examples:
+  github task drop 42
+  github task drop 42 --duplicate-of 17`,
+  "task actualize": `github task actualize <N> [--assignment] [--repo owner/repo]
+
+Right after the merge, in parallel with the deploy: the epic refresh's mechanics (blocked by on done tasks, the questions
+label without open questions, milestones without open tasks; a comment on the epic) and the subagent's prompt;
+--assignment (read-only, the subagent's first call) — its whole assignment: the texts of the epic and its open tasks,
+the PR files, copies of links and answers in comments, the checks by meaning; no epic or no open tasks in it —
+"refresh not needed".
+
+Examples:
+  github task actualize 42
+  github task actualize 42 --assignment`,
+  "task resume": `github task resume
+
+The SessionStart hook runs it: the wait to restart for the task pinned to the session — an open PR's checks, a merged PR
+of an open task — the deploy and task close; no pin — nothing (code 0). Read-only on GitHub; a session with executors —
+its stopped executors continued with SendMessage, then the queue command (a dispatcher's); a new executor only for one
+that can't be continued, in the worktree of its task's branch.
+
+Examples:
+  github task resume`,
+  "task queue": `github task queue [--epic N] [--type Task|Bug] [--priority Urgent,High] [--repo owner/repo]
+github task queue --assignment <N> [--cloud] [--repo owner/repo]
+
+The dispatcher session's queue: ready tasks (open, not an epic, not in work, no open blockers — other repositories'
+too —, no external blocker label) by Priority, then number, each with its executor's prompt; the rest — in work (=: In
+progress, an open PR with its link, handed out to an executor of this session) and ○ lines with the reason (the
+label's — from the latest «External blocker: …» comment). Marks the session as a dispatcher
+(dispatchers/<CLAUDE_CODE_SESSION_ID> in ~/.config/elves): task status in it doesn't pin — the executors are subagents
+with the session's id; a session with a pinned task keeps it. Before the queue, in the repository's checkout —
+finished agents' worktrees (.claude/worktrees/agent-*, detached or on worktree-agent-*, not locked by a live process,
+not an executor's whose handed-out task is open): clean and merged (git cherry) — removed with the branch (+),
+otherwise left (○ with the reason), and so is one a subagent works in without a worktree of its own (its transcript
+written in the last ${QUIET_MINUTES} min); loose worktree-agent-* branches — the same. --type and --priority — in an
+organization. --assignment N (the executor's first call; read-only on GitHub) — its whole assignment; in a session
+(not one pinned to N) it records the task as handed out with the executor's worktree (dispatchers/<id>.tasks). A
+restart while the task's previous executor or its subagent is alive — a worktree of it locked by a live process, with
+such a subagent at work or HEAD moved in the last ${QUIET_MINUTES} min — code 1: ! lines and the answer that makes the
+dispatcher wait, no hand-out. --cloud — printed by the dispatcher: the brief of a cloud executor (claude.ai/code) —
+whole, # only at its task — and the dispatcher's steps: a cloud session can't message a local one, so the dispatcher
+waits for the task's closing (ci-wait issue N, background) and closes it locally; the hand-out has no worktree, and the
+queue's = line names that wait.
+
+Examples:
+  github task queue --epic 40
+  github task queue --type Bug --priority Urgent,High
+  github task queue --assignment 42
+  github task queue --assignment 42 --cloud`,
+  "task close": `github task close <N> [--no-git] [--repo owner/repo]
+
+After the PR merge and the deploy (or a close without a PR) in one call: the actual (est fact --write), Status Done, the
+epic and the milestone, the task's stacks taken down with their volumes (task-env down), the merged branches removed
+(--no-git — without git). The epic has other open tasks and no report of the refresh subagent on it («Refresh after
+#N, result: …») — a refusal before any changes. A task of the scripts' own repository: before the actual the scripts'
+clone catches up with origin (pull --ff-only; only on the default branch, without uncommitted changes). Docker and gh
+don't work in an agent's sandbox — run it outside.
+
+Examples:
+  github task close 42
+  github task close 42 --no-git`,
+  "pr labels": `github pr labels <N> [--repo owner/repo]
+
+Decision labels from the PR diff for the tasks from «Closes #N» and their epics; doesn't remove earlier ones. A decision
+touched only mechanically (a deletion, a rename without changes, exceptions) and a decision with a slice label's name —
+an ○ line, no label. More than fit on an issue (GitHub allows ${ISSUE_LABEL_LIMIT}) — only decisions whose <folder>.md
+or test names (the PR body's spec section) the PR changes, as many as fit; the rest — ○ lines.
+
+Examples:
+  github pr labels 57`,
+  "pr premerge": `github pr premerge <N> [--repo owner/repo]
+
+Before gh pr merge, after ci-wait PASS: the default branch moved after the PR's CI — the PR head merged with it in a
+temporary worktree and ${PREMERGE_SCRIPTS.join(", then ")} from package.json (those that exist, as in CI). Code 0 —
+merge, 1 — don't merge (red, conflict), 2 — couldn't check, 3 — main is red by itself (the same check on bare main, a
+red check on its last commit): don't merge, one bug for it — wait for it to close.
+
+Examples:
+  github pr premerge 57`
+};
+var OVERVIEW = [
+  "github — the repository's GitHub project and tasks by the AGENTS.md canon",
+  "",
+  ...Object.values(HELP).map((h) => h.split(`
+
+`)[0].replace(/^/gm, "  ")),
+  "",
+  "github <command> --help — the command's details and examples"
+].join(`
+`);
+function helpOf(argv) {
+  if (!argv.some((a) => a === "--help" || a === "-h"))
+    return;
+  const words = `${argv.join(" ")} `;
+  const cmd = Object.keys(HELP).find((c) => words.startsWith(`${c} `));
+  return cmd ? HELP[cmd] : OVERVIEW;
+}
+var issueNumber = (s, what) => {
+  const m = /^#?(\d+)$/.exec((s ?? "").trim());
+  if (!m)
+    throw new GhError(`${what}: expected an issue number, not «${s ?? ""}»`);
+  return Number(m[1]);
+};
+var ORIGIN_RE = /^(?:[a-z][a-z\d+.-]*:\/\/(?:[^@/\s]+@)?(?:ssh\.)?github\.com(?::\d+)?\/|(?:[^@/\s:]+@)?(?:ssh\.)?github\.com:)([^/\s]+)\/([^/\s]+?)(?:\.git)?\/?$/i;
+function originRepo(url) {
+  const m = ORIGIN_RE.exec(url.trim());
+  return m ? `${m[1]}/${m[2]}` : null;
+}
+function checkoutOf(origin, repo) {
+  return originRepo(origin)?.toLowerCase() === repo.toLowerCase();
+}
+function detectRepo() {
+  const r = spawnSync("git", ["remote", "get-url", "origin"], { encoding: "utf8" });
+  const repo = r.status === 0 ? originRepo(r.stdout ?? "") : null;
+  if (!repo)
+    throw new GhError("couldn't determine the repository from git remote origin; pass --repo owner/repo");
+  return repo;
+}
+var canonicalNames = new WeakMap;
+function canonicalRepo(io, slug) {
+  let known = canonicalNames.get(io);
+  if (!known)
+    canonicalNames.set(io, known = new Map);
+  const key = slug.toLowerCase();
+  if (!known.has(key)) {
+    const [owner, name] = slug.split("/");
+    const out = io.gh(["api", "graphql", "--input", "-"], JSON.stringify({ query: Q.RepoName, variables: { owner, name } }));
+    let current = null;
+    try {
+      current = JSON.parse(out)?.data?.repository?.nameWithOwner;
+    } catch {
+      current = null;
+    }
+    known.set(key, typeof current === "string" && current ? current : slug);
+  }
+  return known.get(key);
+}
+function checkoutOfRepo(io, origin, slug) {
+  if (checkoutOf(origin, slug))
+    return true;
+  const repo = originRepo(origin);
+  return repo !== null && canonicalRepo(io, repo).toLowerCase() === slug.toLowerCase();
+}
+function main(argv, io) {
+  const help = helpOf(argv);
+  if (help)
+    return io.out(help), 0;
+  N = locale_default.names(locale_default.projectLanguage(io.cwd ?? process.cwd()));
+  try {
+    const [group, cmd, ...rest] = argv;
+    if (!group)
+      return io.out(OVERVIEW), 2;
+    if (!Object.hasOwn(HELP, `${group} ${cmd ?? ""}`)) {
+      io.err(`unknown command «${argv.slice(0, 2).join(" ")}»; expected ${Object.keys(HELP).join(", ")} (github --help)`);
+      return 2;
+    }
+    if (inCloud(io) && group === "task" && cmd === "close") {
+      const n = /^#?(\d+)$/.exec(rest.find((a) => !a.startsWith("--")) ?? "")?.[1] ?? "<N>";
+      io.err(`cloud session: task close is unavailable to it — no GitHub Projects in the cloud (docs/cloud-sessions.md). The actual — the ${q(N.est.cloud.actual.replace(/:$/, ""))} comment printed by est fact ${n}; ${q(N.status.done)} is set by the project's workflow ${q(WORKFLOW_CLOSED)}; the cloud's branch and container are temporary, nothing to clean up.`);
+      return 2;
+    }
+    if (inCloud(io) && !CLOUD_COMMANDS.includes(`${group} ${cmd}`)) {
+      io.err(`cloud session: GitHub GraphQL and Projects are unavailable to it (403, docs/cloud-sessions.md) — ${group} ${cmd} runs in a local session; in the cloud — ${CLOUD_COMMANDS.join(", ")} over the repository's REST`);
+      return 2;
+    }
+    const repoOf = (v) => {
+      const slug = v ?? detectRepo();
+      if (!/^[\w.-]+\/[\w.-]+$/.test(slug))
+        throw new GhError(`invalid --repo «${slug}», expected owner/repo`);
+      return inCloud(io) ? slug : canonicalRepo(io, slug);
+    };
+    if (group === "pr") {
+      const { values, positionals } = parseArgs({ args: rest, allowPositionals: true, options: { repo: { type: "string" } } });
+      if (positionals.length > 1)
+        throw new GhError(`extra arguments: ${positionals.slice(1).join(" ")}`);
+      const m = /^#?(\d+)$/.exec((positionals[0] ?? "").trim());
+      if (!m)
+        throw new GhError(`pr ${cmd}: expected a PR number, not «${positionals[0] ?? ""}»`);
+      return (cmd === "premerge" ? cmdPrPremerge : cmdPrLabels)(io, repoOf(values.repo), Number(m[1]));
+    }
+    if (group === "task") {
+      const { values, positionals } = parseArgs({
+        args: rest,
+        allowPositionals: true,
+        options: {
+          repo: { type: "string" },
+          title: { type: "string" },
+          body: { type: "string" },
+          "body-file": { type: "string" },
+          type: { type: "string" },
+          epic: { type: "string" },
+          milestone: { type: "string" },
+          "blocked-by": { type: "string" },
+          priority: { type: "string" },
+          "duplicate-of": { type: "string" },
+          labels: { type: "string" },
+          "branch-type": { type: "string" },
+          branch: { type: "string" },
+          "no-git": { type: "boolean", default: false },
+          assignment: { type: "boolean", default: false },
+          cloud: { type: "boolean", default: false },
+          auto: { type: "boolean", default: false }
+        }
+      });
+      if (cmd === "resume") {
+        if (positionals.length)
+          throw new GhError(`extra arguments: ${positionals.join(" ")} — task resume takes the task from the session pin`);
+        return cmdTaskResume(io);
+      }
+      const slug = repoOf(values.repo);
+      if (cmd === "new") {
+        if (positionals.length)
+          throw new GhError(`extra arguments: ${positionals.join(" ")}`);
+        if (!values.title?.trim())
+          throw new GhError("--title is required");
+        if (values.body !== undefined && values["body-file"])
+          throw new GhError("--body or --body-file, not both");
+        const body = values["body-file"] ? readFileSync(values["body-file"], "utf8") : values.body ?? "";
+        const blockedBy = (values["blocked-by"] ?? "").split(",").filter((x) => x.trim()).map((x) => issueNumber(x, "--blocked-by"));
+        const epic = values.epic === undefined ? undefined : issueNumber(values.epic, "--epic");
+        const labels = (values.labels ?? "").split(",").map((x) => x.trim()).filter(Boolean);
+        return cmdTaskNew(io, slug, { title: values.title, body, type: values.type ?? N.issueTypes.task, epic, milestone: values.milestone, blockedBy, priority: values.priority, labels, branchType: values["branch-type"] });
+      }
+      if (cmd === "queue") {
+        if (values.cloud && !values.assignment)
+          throw new GhError("--cloud — only with --assignment <N>: the brief of one task's cloud executor");
+        if (values.assignment) {
+          if (positionals.length !== 1)
+            throw new GhError("task queue --assignment <N>: one task number");
+          return cmdTaskAssignment(io, slug, issueNumber(positionals[0], "task queue --assignment"), { cloud: values.cloud });
+        }
+        if (positionals.length)
+          throw new GhError(`extra arguments: ${positionals.join(" ")} — the queue is chosen by --epic, --type and --priority`);
+        const priority = values.priority === undefined ? undefined : values.priority.split(",").map((x) => x.trim()).filter(Boolean);
+        return cmdTaskQueue(io, slug, { epic: values.epic === undefined ? undefined : issueNumber(values.epic, "--epic"), type: values.type, priority });
+      }
+      const number = issueNumber(positionals[0], `task ${cmd}`);
+      if (cmd === "status")
+        return cmdTaskStatus(io, slug, number, positionals.slice(1).join(" "), values.branch);
+      if (cmd === "answer") {
+        const k = /^\d+$/.exec((positionals[1] ?? "").trim());
+        if (!k)
+          throw new GhError(`task answer: expected a question number, not «${positionals[1] ?? ""}»`);
+        return cmdTaskAnswer(io, slug, number, Number(k[0]), positionals.slice(2).join(" "), values.auto);
+      }
+      if (positionals.length > 1)
+        throw new GhError(`extra arguments: ${positionals.slice(1).join(" ")}`);
+      if (cmd === "show")
+        return cmdTaskShow(io, slug, number);
+      if (cmd === "close")
+        return cmdTaskClose(io, slug, number, { git: !values["no-git"] });
+      if (cmd === "actualize")
+        return cmdTaskActualize(io, slug, number, { assignment: values.assignment });
+      return cmdTaskDrop(io, slug, number, values["duplicate-of"] === undefined ? undefined : issueNumber(values["duplicate-of"], "--duplicate-of"));
+    }
+    const { values } = parseArgs({ args: rest, options: { repo: { type: "string" }, confirm: { type: "boolean", default: false }, template: { type: "string", default: DEFAULT_TEMPLATE } } });
+    const slug = repoOf(values.repo);
+    const template = values.template === "none" ? null : values.template;
+    if (template && !/^[\w.-]+\/\d+$/.test(template))
+      throw new GhError(`invalid --template «${template}», expected owner/N or none`);
+    return cmd === "check" ? cmdCheck(io, slug) : cmdFix(io, slug, { confirm: values.confirm, template });
+  } catch (e) {
+    if (e instanceof GhError || e?.code === "ERR_PARSE_ARGS_UNKNOWN_OPTION") {
+      io.err(`error: ${e.message}`);
+      return 2;
+    }
+    throw e;
+  }
+}
+if (false) {}
+export {
+  DECISIONS,
+  DEFAULT_PRIORITY,
+  DEFAULT_TEMPLATE,
+  EPIC_LABEL,
+  GhError,
+  HEAD_CHECKS,
+  PREMERGE_SCRIPTS,
+  PRIORITIES,
+  PRIORITY,
+  Q,
+  QUEUE_EXECUTORS,
+  RULESET,
+  SPEC_PUBLISH,
+  SPEC_ROOTS,
+  STABLE_PRS,
+  STATUS,
+  WORKFLOW_ADDED,
+  WORKFLOW_AUTO_ADD,
+  WORKFLOW_CLOSED,
+  analyze,
+  checkStates,
+  checkoutOf,
+  cmdCheck,
+  cmdFix,
+  cmdPrLabels,
+  cmdPrPremerge,
+  cmdTaskActualize,
+  cmdTaskAnswer,
+  cmdTaskAssignment,
+  cmdTaskClose,
+  cmdTaskDrop,
+  cmdTaskNew,
+  cmdTaskQueue,
+  cmdTaskResume,
+  cmdTaskShow,
+  cmdTaskStatus,
+  decisionLabel,
+  decisionsOfFiles,
+  epicPrefix,
+  exceptionFile,
+  graphql,
+  labelKinds,
+  legacyDecision,
+  loadDecisions,
+  loadState,
+  main,
+  modelModules,
+  originRepo,
+  packageManager,
+  pinLine,
+  projectCommands,
+  questionItems,
+  realGh,
+  realRun,
+  sessionPin,
+  specRoots,
+  taskBranch,
+  taskTemplate
+};