@rness/cli 0.12.0 → 0.13.0

package/dist/{chunk-AEW7ZDFS.js → chunk-4VTYSPZW.js}

@@ -139,6 +139,36 @@ async function changedPaths(dir, paths) {
   }
   return changed;
 }
+async function seenPaths(dir, paths) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const path of new Set(paths)) {
+    try {
+      const commit = await git(
+        [
+          "log",
+          "-1",
+          "--full-history",
+          "--format=%H",
+          "HEAD",
+          "--",
+          `:(literal)${path}`
+        ],
+        dir
+      );
+      if (commit.trim() !== "") seen.add(path);
+    } catch {
+    }
+  }
+  return seen;
+}
+async function gitPath(dir, name) {
+  try {
+    const path = (await git(["rev-parse", "--git-path", name], dir)).trim();
+    return path === "" ? null : resolve(dir, path);
+  } catch {
+    return null;
+  }
+}
 async function pullFastForward(dir, credentials) {
   await git(["pull", "--ff-only", "--quiet"], dir, credentials);
 }
@@ -360,9 +390,9 @@ function readScopes(value) {
     scopes[name] = { path, extends: ext };
   }
   for (const [name, entry] of Object.entries(scopes)) {
-    for (const target of entry.extends) {
-      if (!Object.hasOwn(scopes, target))
-        fail(`scope "${name}" extends unknown scope "${target}"`);
+    for (const target2 of entry.extends) {
+      if (!Object.hasOwn(scopes, target2))
+        fail(`scope "${name}" extends unknown scope "${target2}"`);
     }
   }
   return scopes;
@@ -456,7 +486,7 @@ function parseRepoSpec(spec, org, host) {
 }
 
 // src/version.ts
-var VERSION = "0.12.0";
+var VERSION = "0.13.0";
 
 // src/core/pm.ts
 import { execFile as execFile2 } from "child_process";
@@ -599,8 +629,8 @@ async function collectMarkdown(dir) {
 }
 
 // src/core/scope.ts
-function isPrefix(prefix, target) {
-  return prefix === target || target.startsWith(`${prefix}/`);
+function isPrefix(prefix, target2) {
+  return prefix === target2 || target2.startsWith(`${prefix}/`);
 }
 function resolveScope(manifest, relDir) {
   let best = null;
@@ -624,7 +654,7 @@ function scopeChain(manifest, scope) {
     chain.push(name);
     stack.add(name);
     const entry = Object.hasOwn(manifest.scopes, name) ? manifest.scopes[name] : void 0;
-    for (const target of entry?.extends ?? []) visit(target, stack);
+    for (const target2 of entry?.extends ?? []) visit(target2, stack);
     stack.delete(name);
   };
   visit(scope, /* @__PURE__ */ new Set());
@@ -1116,6 +1146,158 @@ function statusMarkdown(workspace, tabs) {
   return out.join("\n");
 }
 
+// src/pulse/body.ts
+import { createHash } from "crypto";
+import { posix as posix4 } from "path";
+var BODY_LIMIT = 65536;
+var blobUrl = (org, path) => `https://github.com/${org}/.rness/blob/main/${encodeURI(path)}`;
+var issueUrl = (org, number) => `https://github.com/${org}/.rness/issues/${number}`;
+function headerOf(path, org) {
+  return `\`${path}\` \xB7 [on GitHub](${blobUrl(org, path)})`;
+}
+var digest = (text) => createHash("sha256").update(text, "utf8").digest("hex").slice(0, 12);
+var comment = (d) => `<!-- rness ${d} -->`;
+var TAIL = `
+
+${comment("0".repeat(12))}`.length;
+var LAST_LINE = /\n\n<!-- rness ([0-9a-f]{12}) -->\s*$/;
+function digestOf(body) {
+  const text = body.replace(/\r\n?/g, "\n");
+  const m = LAST_LINE.exec(text);
+  const d = m?.[1];
+  if (m === null || d === void 0) return null;
+  return digest(text.slice(0, m.index)) === d ? d : null;
+}
+var OPENER = /^[ \t]*(`{3,}|~{3,})(.*)$/;
+var CLOSER = /^[ \t]*(`{3,}|~{3,})[ \t]*$/;
+function fenced(lines) {
+  const code = [];
+  let run3 = null;
+  for (const line3 of lines) {
+    if (run3 === null) {
+      const m = OPENER.exec(line3);
+      const fence2 = m?.[1];
+      if (fence2 !== void 0 && !(fence2.startsWith("`") && (m?.[2] ?? "").includes("`")))
+        run3 = fence2;
+      code.push(run3 !== null);
+      continue;
+    }
+    code.push(true);
+    const fence = CLOSER.exec(line3)?.[1];
+    if (fence !== void 0 && fence[0] === run3[0] && fence.length >= run3.length)
+      run3 = null;
+  }
+  return code;
+}
+var TITLE = /^ {0,3}#(?:[ \t]|$)/;
+function withoutTitle(lines) {
+  const code = fenced(lines);
+  const at = lines.findIndex((line3, i) => code[i] !== true && TITLE.test(line3));
+  if (at < 0) return [...lines];
+  let end = at + 1;
+  while (end < lines.length && (lines[end] ?? "").trim() === "") end++;
+  return [...lines.slice(0, at), ...lines.slice(end)];
+}
+var SCHEME = /^[a-zA-Z][a-zA-Z0-9+.-]*:/;
+var IMAGE = /\.(?:png|jpe?g|gif|svg|webp|avif)$/i;
+var decoded = (path) => {
+  try {
+    return decodeURI(path);
+  } catch {
+    return path;
+  }
+};
+function target(dest, s) {
+  const raw = dest.startsWith("<") ? dest.slice(1, -1) : dest;
+  if (raw === "" || SCHEME.test(raw) || raw.startsWith("//") || raw.startsWith("#"))
+    return dest;
+  const hash = raw.indexOf("#");
+  const pathPart = hash < 0 ? raw : raw.slice(0, hash);
+  const anchor = hash < 0 ? "" : raw.slice(hash);
+  const file = decoded(
+    posix4.normalize(
+      pathPart.startsWith("/") ? pathPart.slice(1) : posix4.join(posix4.dirname(s.path), pathPart)
+    )
+  );
+  const number = s.numbers.get(file);
+  if (number !== void 0) return issueUrl(s.org, number);
+  if (!s.files.has(file)) return dest;
+  return `${blobUrl(s.org, file)}${IMAGE.test(file) ? "?raw=true" : ""}${anchor}`;
+}
+var PROTECTED = new RegExp(
+  [
+    /(?<!`)(`+)(?!`)[\s\S]*?(?<!`)\1(?!`)/.source,
+    /<!--[\s\S]*?-->/.source,
+    /<[a-zA-Z][a-zA-Z0-9+.-]*:[^\s<>]*>/.source,
+    /^ {0,3}\[(?:[^\]\\\n]|\\.)+\]:[ \t]*(?<def><[^>\n]*>|\S+)/.source,
+    /\]\([ \t]*(?<dest><[^>\n]*>|[^\s()]+)/.source,
+    /\b(?:https?:\/\/|www\.)[^\s<>]*[^\s<>.,:;"')\]]/.source
+  ].join("|"),
+  "gm"
+);
+var MENTION = /(^|[^A-Za-z0-9`\\])@([A-Za-z0-9][A-Za-z0-9-]*)/g;
+var REFERENCE = /(^|[^A-Za-z0-9&#/])#(\d+)(?![A-Za-z0-9])/g;
+var ZWSP = "\u200B";
+var neutral = (text) => text.replace(MENTION, "$1\\@$2").replace(REFERENCE, `$1#${ZWSP}$2`);
+function inline(text, s) {
+  let out = "";
+  let from = 0;
+  for (const m of text.matchAll(PROTECTED)) {
+    const at = m.index ?? 0;
+    out += neutral(text.slice(from, at));
+    const dest = m.groups?.["dest"] ?? m.groups?.["def"];
+    out += dest === void 0 ? m[0] : `${m[0].slice(0, m[0].length - dest.length)}${target(dest, s)}`;
+    from = at + m[0].length;
+  }
+  return out + neutral(text.slice(from));
+}
+function rewrite(lines, s) {
+  const code = fenced(lines);
+  const out = [];
+  let paragraph = [];
+  const flush = () => {
+    if (paragraph.length > 0) out.push(inline(paragraph.join("\n"), s));
+    paragraph = [];
+  };
+  lines.forEach((line3, i) => {
+    if (code[i] === true || line3.trim() === "") {
+      flush();
+      out.push(line3);
+    } else paragraph.push(line3);
+  });
+  flush();
+  return out;
+}
+function cut(text, rest) {
+  const room = BODY_LIMIT - TAIL - 2 - rest.length;
+  const lines = text.split("\n");
+  const code = fenced(lines);
+  let length = -1;
+  let at = 1;
+  for (let k = 1; k < lines.length; k++) {
+    length += 1 + (lines[k - 1] ?? "").length;
+    if (length > room) break;
+    if (code[k] !== true && (lines[k] ?? "").trim() === "") at = k;
+  }
+  return `${lines.slice(0, at).join("\n").trimEnd()}
+
+${rest}`;
+}
+function issueBody(s) {
+  const lines = withoutTitle(
+    stripFrontMatter(s.text.replace(/\r\n?/g, "\n")).split("\n")
+  );
+  const content = rewrite(lines, s).join("\n").replace(/^(?:[ \t]*\n)+/, "").trimEnd();
+  const header2 = headerOf(s.path, s.org);
+  const whole = content === "" ? header2 : `${header2}
+
+${content}`;
+  const text = whole.length + TAIL <= BODY_LIMIT ? whole : cut(whole, `The rest: ${blobUrl(s.org, s.path)}`);
+  return `${text}
+
+${comment(digest(text))}`;
+}
+
 // src/pulse/layout.ts
 var statusOf2 = (status2) => status2 === null || status2 === "?" ? null : status2;
 var LIFECYCLE = [
@@ -1142,8 +1324,8 @@ var STATUS_COLORS = {
   Accepted: "green",
   Implemented: "green",
   Completed: "green",
-  Rejected: "gray",
-  Superseded: "gray",
+  Rejected: "red",
+  Superseded: "yellow",
   Abandoned: "gray"
 };
 var COLLECTION_COLORS = {
@@ -1208,9 +1390,7 @@ function desiredOf(tabs, org) {
     (tab) => tab.rows.map((row) => ({
       path: row.path,
       title: `${row.id} \u2014 ${row.title}`,
-      body: `${row.path}
-
-https://github.com/${org}/.rness/blob/main/${row.path}`,
+      body: headerOf(row.path, org),
       status: statusOf2(row.status),
       type: tab.label,
       statusField: fields2.get(tab.label)?.name ?? null
@@ -1219,6 +1399,7 @@ https://github.com/${org}/.rness/blob/main/${row.path}`,
 }
 
 // src/core/github.ts
+import { setTimeout as delay } from "timers/promises";
 var DEFAULT_GITHUB_API = "https://api.github.com";
 var MAX_PAGES = 50;
 var PER_PAGE = 100;
@@ -1353,6 +1534,39 @@ async function listRepositories(owner, options) {
     truncated: true
   };
 }
+var WAIT_BUDGET_MS = 6e5;
+var DEFAULT_WAIT_MS = 6e4;
+var MIN_WAIT_MS = 1e3;
+var RATE_LIMIT_OUTLASTED = "GitHub's rate limit outlasted the 10 minutes rness waits";
+function rateWait(sleep = (ms) => delay(ms)) {
+  return { left: WAIT_BUDGET_MS, now: () => Date.now(), sleep };
+}
+var PROCESS_WAIT = rateWait();
+var RateLimitError = class extends Error {
+};
+var messageOf = (body) => {
+  const m = body !== null && typeof body === "object" ? body["message"] : void 0;
+  return typeof m === "string" ? m : "";
+};
+function rateDelay(page, now, limited = false) {
+  const h = page.headers;
+  const spent = h.get("x-ratelimit-remaining") === "0";
+  const hit = limited || page.status === 429 || page.status === 403 && (h.has("retry-after") || spent || /rate limit/i.test(messageOf(page.body)));
+  if (!hit) return null;
+  const after = (h.get("retry-after") ?? "").trim();
+  if (/^\d+$/.test(after)) return Number(after) * 1e3;
+  const reset = (h.get("x-ratelimit-reset") ?? "").trim();
+  if (spent && /^\d+$/.test(reset))
+    return Math.max(0, Number(reset) * 1e3 - now);
+  return DEFAULT_WAIT_MS;
+}
+async function waitOut(options, ms) {
+  const wait = options.wait ?? PROCESS_WAIT;
+  const spent = Math.max(ms, MIN_WAIT_MS);
+  if (spent > wait.left) throw new RateLimitError(RATE_LIMIT_OUTLASTED);
+  wait.left -= spent;
+  await wait.sleep(spent);
+}
 function apiHeaders(token) {
   return {
     Accept: "application/vnd.github+json",
@@ -1375,23 +1589,34 @@ async function getJson(path, options) {
   const body = await res.json().catch(() => void 0);
   return { status: res.status, body };
 }
-async function postJson(path, payload, options, explain = false) {
+async function postJson(path, payload, options, explain = false, limited = () => false) {
   const base = (options.apiBase ?? DEFAULT_GITHUB_API).replace(/\/+$/, "");
-  const page = await getPage(
-    `${base}${path}`,
-    { ...apiHeaders(options.token), "Content-Type": "application/json" },
-    options.timeoutMs ?? 15e3,
-    { method: "POST", body: JSON.stringify(payload), errorBody: explain }
-  );
-  if (page.status < 200 || page.status >= 300) {
-    const message2 = explain && page.status !== 401 && page.status !== 429 && page.body !== null && typeof page.body === "object" ? page.body.message : void 0;
-    if (typeof message2 === "string" && message2 !== "")
-      throw new GitHubMessageError(message2, {
-        cause: { status: page.status, path }
-      });
-    throw httpError(page, path);
+  const clock = options.wait ?? PROCESS_WAIT;
+  for (; ; ) {
+    const page = await getPage(
+      `${base}${path}`,
+      { ...apiHeaders(options.token), "Content-Type": "application/json" },
+      options.timeoutMs ?? 15e3,
+      // A refusal's body says whether it is a rate limit. A timeout throws
+      // above and is never retried: the write may have been made.
+      { method: "POST", body: JSON.stringify(payload), errorBody: true }
+    );
+    const ok = page.status >= 200 && page.status < 300;
+    const wait = rateDelay(page, clock.now(), ok && limited(page.body));
+    if (wait !== null) {
+      await waitOut(options, wait);
+      continue;
+    }
+    if (!ok) {
+      const message2 = explain && page.status !== 401 && page.status !== 429 && page.body !== null && typeof page.body === "object" ? page.body.message : void 0;
+      if (typeof message2 === "string" && message2 !== "")
+        throw new GitHubMessageError(message2, {
+          cause: { status: page.status, path }
+        });
+      throw httpError(page, path);
+    }
+    return page.body;
   }
-  return page.body;
 }
 async function getScopes(options) {
   const base = (options.apiBase ?? DEFAULT_GITHUB_API).replace(/\/+$/, "");
@@ -1489,8 +1714,17 @@ async function createRepository(owner, name, options) {
 function isRecord2(v) {
   return v !== null && typeof v === "object";
 }
+var rateLimited = (body) => isRecord2(body) && Array.isArray(body["errors"]) && body["errors"].some(
+  (e) => isRecord2(e) && e["type"] === "RATE_LIMITED"
+);
 async function graphqlRaw(query, variables, options) {
-  const body = await postJson("/graphql", { query, variables }, options, true);
+  const body = await postJson(
+    "/graphql",
+    { query, variables },
+    options,
+    true,
+    rateLimited
+  );
   return isRecord2(body) ? body : {};
 }
 function firstError(answer) {
@@ -1505,6 +1739,15 @@ async function graphql(query, variables, options) {
     throw new Error("GitHub GraphQL answered without data");
   return answer.data;
 }
+async function graphqlFound(query, variables, options) {
+  const answer = await graphqlRaw(query, variables, options);
+  const errors = answer.errors ?? [];
+  if (errors.length > 0 && errors.every((e) => e.type === "NOT_FOUND"))
+    return null;
+  const error = firstError(answer);
+  if (error !== null) throw error;
+  return answer.data ?? null;
+}
 async function orgId(org, o) {
   const d = await graphql(
     "query($login: String!) { organization(login: $login) { id } }",
@@ -1541,7 +1784,9 @@ async function findProject(org, number, o) {
     { login: org, number },
     o
   );
-  if (answer.errors?.every((e) => e.type === "NOT_FOUND") === true) return null;
+  const errors = answer.errors ?? [];
+  if (errors.length > 0 && errors.every((e) => e.type === "NOT_FOUND"))
+    return null;
   const error = firstError(answer);
   if (error !== null) throw error;
   return answer.data?.organization?.projectV2 ?? null;
@@ -1621,7 +1866,7 @@ async function setOptions(field, options, o) {
   );
   return toField(d.updateProjectV2Field.projectV2Field);
 }
-async function listItems(projectId, o) {
+async function listItems(projectId, o, { bodies = true } = {}) {
   const items = [];
   let cursor = null;
   for (; ; ) {
@@ -1639,8 +1884,23 @@ async function listItems(projectId, o) {
                       id
                       title
                     }
+                    ... on Issue {
+                      id
+                      number
+                      title
+                      state
+                      ${bodies ? "body" : ""}
+                      repository {
+                        nameWithOwner
+                      }
+                      labels(first: 20) {
+                        nodes {
+                          name
+                        }
+                      }
+                    }
                   }
-                  fieldValues(first: 20) {
+                  fieldValues(first: 50) {
                     nodes {
                       ... on ProjectV2ItemFieldTextValue {
                         text
@@ -1680,10 +1940,20 @@ async function listItems(projectId, o) {
         const value = v.text ?? v.name;
         if (field !== void 0 && value !== void 0) values2[field] = value;
       }
+      const c = n.content;
+      const issue = c?.id !== void 0 && c.number !== void 0 ? {
+        id: c.id,
+        number: c.number,
+        open: c.state === "OPEN",
+        repository: c.repository?.nameWithOwner ?? "",
+        body: bodies ? c.body ?? "" : null,
+        labels: (c.labels?.nodes ?? []).map((l) => l.name ?? "").filter((l) => l !== "")
+      } : null;
       items.push({
         id: n.id,
-        draftId: n.content?.id ?? null,
-        title: n.content?.title ?? "",
+        draftId: issue === null ? c?.id ?? null : null,
+        issue,
+        title: c?.title ?? "",
         archived: n.isArchived === true,
         values: values2
       });
@@ -1693,41 +1963,6 @@ async function listItems(projectId, o) {
     cursor = endCursor;
   }
 }
-async function addDraft(projectId, title, body, o) {
-  const d = await graphql(
-    `
-      mutation ($projectId: ID!, $title: String!, $body: String) {
-        addProjectV2DraftIssue(
-          input: { projectId: $projectId, title: $title, body: $body }
-        ) {
-          projectItem {
-            id
-          }
-        }
-      }
-    `,
-    { projectId, title, body },
-    o
-  );
-  return d.addProjectV2DraftIssue.projectItem.id;
-}
-async function editDraft(draftId, title, body, o) {
-  await graphql(
-    `
-      mutation ($draftIssueId: ID!, $title: String!, $body: String) {
-        updateProjectV2DraftIssue(
-          input: { draftIssueId: $draftIssueId, title: $title, body: $body }
-        ) {
-          draftIssue {
-            id
-          }
-        }
-      }
-    `,
-    { draftIssueId: draftId, title, body },
-    o
-  );
-}
 async function setValue(projectId, itemId, fieldId, value, o) {
   if (value === null) {
     await graphql(
@@ -1795,6 +2030,90 @@ async function archive(projectId, itemId, o) {
     o
   );
 }
+async function addItem(projectId, contentId, o) {
+  const d = await graphql(
+    `
+      mutation ($projectId: ID!, $contentId: ID!) {
+        addProjectV2ItemById(
+          input: { projectId: $projectId, contentId: $contentId }
+        ) {
+          item {
+            id
+          }
+        }
+      }
+    `,
+    { projectId, contentId },
+    o
+  );
+  return d.addProjectV2ItemById.item.id;
+}
+async function convertDraft(itemId, repositoryId, o) {
+  const d = await graphql(
+    `
+      mutation ($itemId: ID!, $repositoryId: ID!) {
+        convertProjectV2DraftIssueItemToIssue(
+          input: { itemId: $itemId, repositoryId: $repositoryId }
+        ) {
+          item {
+            id
+            content {
+              ... on Issue {
+                id
+                number
+              }
+            }
+          }
+        }
+      }
+    `,
+    { itemId, repositoryId },
+    o
+  );
+  const content = d.convertProjectV2DraftIssueItemToIssue.item.content;
+  const id = content?.id;
+  const number = content?.number;
+  if (id === void 0 || number === void 0)
+    throw new Error(`GitHub converted the item ${itemId} without an issue`);
+  return { id, number };
+}
+async function linkedRepositories(projectId, o) {
+  const d = await graphql(
+    `
+      query ($projectId: ID!) {
+        node(id: $projectId) {
+          ... on ProjectV2 {
+            repositories(first: 100) {
+              nodes {
+                nameWithOwner
+              }
+            }
+          }
+        }
+      }
+    `,
+    { projectId },
+    o
+  );
+  return (d.node?.repositories.nodes ?? []).map((r) => r.nameWithOwner);
+}
+async function linkRepository(projectId, repositoryId, o) {
+  await graphql(
+    `
+      mutation ($projectId: ID!, $repositoryId: ID!) {
+        linkProjectV2ToRepository(
+          input: { projectId: $projectId, repositoryId: $repositoryId }
+        ) {
+          repository {
+            id
+          }
+        }
+      }
+    `,
+    { projectId, repositoryId },
+    o
+  );
+}
 async function createView(org, number, view, o) {
   const body = {
     name: view.name,
@@ -1889,10 +2208,127 @@ async function renameView(viewId, name, visibleFieldIds, o) {
   );
 }
 
+// src/core/github-issues.ts
+async function repository(owner, name, label, o) {
+  const d = await graphqlFound(
+    `query($owner: String!, $name: String!, $label: String!) {
+      repository(owner: $owner, name: $name) { id hasIssuesEnabled label(name: $label) { id } }
+    }`,
+    { owner, name, label },
+    o
+  );
+  const r = d?.repository ?? null;
+  return r === null ? null : { id: r.id, issues: r.hasIssuesEnabled, labelId: r.label?.id ?? null };
+}
+async function createLabel(owner, name, label, o) {
+  const body = await postJson(
+    `/repos/${encodeURIComponent(owner)}/${encodeURIComponent(name)}/labels`,
+    label,
+    o,
+    true
+  );
+  const id = body !== null && typeof body === "object" ? body["node_id"] : void 0;
+  if (typeof id !== "string")
+    throw new Error(`GitHub created the label ${label.name} without a node id`);
+  return id;
+}
+async function createIssue(repositoryId, issue, o) {
+  const d = await graphql(
+    `
+      mutation (
+        $repositoryId: ID!
+        $title: String!
+        $body: String
+        $labelIds: [ID!]
+      ) {
+        createIssue(
+          input: {
+            repositoryId: $repositoryId
+            title: $title
+            body: $body
+            labelIds: $labelIds
+          }
+        ) {
+          issue {
+            id
+            number
+          }
+        }
+      }
+    `,
+    { repositoryId, ...issue },
+    o
+  );
+  return d.createIssue.issue;
+}
+async function updateIssue(id, change, o) {
+  await graphql(
+    `
+      mutation ($id: ID!, $title: String, $body: String) {
+        updateIssue(input: { id: $id, title: $title, body: $body }) {
+          issue {
+            id
+          }
+        }
+      }
+    `,
+    { id, ...change },
+    o
+  );
+}
+async function closeIssue(id, o) {
+  await graphql(
+    `
+      mutation ($id: ID!) {
+        closeIssue(input: { issueId: $id, stateReason: NOT_PLANNED }) {
+          issue {
+            id
+          }
+        }
+      }
+    `,
+    { id },
+    o
+  );
+}
+async function reopenIssue(id, o) {
+  await graphql(
+    `
+      mutation ($id: ID!) {
+        reopenIssue(input: { issueId: $id }) {
+          issue {
+            id
+          }
+        }
+      }
+    `,
+    { id },
+    o
+  );
+}
+async function addLabels(id, labelIds, o) {
+  await graphql(
+    `
+      mutation ($id: ID!, $labelIds: [ID!]!) {
+        addLabelsToLabelable(input: { labelableId: $id, labelIds: $labelIds }) {
+          clientMutationId
+        }
+      }
+    `,
+    { id, labelIds },
+    o
+  );
+}
+
 // src/core/github-board.ts
 var PROJECT_TITLE = "Agent Pulse";
 var WORKING = "working";
 var WORKING_VIEW = "Working";
+var MEMORY = ".rness";
+var LABEL = "rness";
+var LABEL_COLOR = "5319e7";
+var LABEL_DESCRIPTION = "A document of .rness, on Agent Pulse";
+var labelled = (labels) => labels.some((l) => l.toLowerCase() === LABEL.toLowerCase());
 var STATUS_FIELD = "Status";
 var ALL_VIEW = "All";
 var DEFAULT_VIEW = "View 1";
@@ -1921,6 +2357,8 @@ var orderedFirst = (wanted, all) => {
 var GitHubBoards = class {
   #o;
   #cache = /* @__PURE__ */ new Map();
+  /** Each organization's `.rness`, as first read: its id, its Issues, its label. */
+  #memories = /* @__PURE__ */ new Map();
   constructor(options) {
     this.#o = options;
   }
@@ -1943,6 +2381,23 @@ var GitHubBoards = class {
     cache.fields ??= await fields(cache.projectId, this.#o);
     return cache.fields;
   }
+  async #memory(org) {
+    const known = this.#memories.get(org);
+    if (known !== void 0) return known;
+    const found = await repository(org, MEMORY, LABEL, this.#o);
+    if (found === null)
+      throw new Error(
+        `the pulse needs ${org}/${MEMORY} on GitHub: it is not there, or this login cannot see it`
+      );
+    this.#memories.set(org, found);
+    return found;
+  }
+  async checkIssues(org) {
+    if (!(await this.#memory(org)).issues)
+      throw new Error(
+        `the pulse needs Issues on ${org}/${MEMORY}: turn them on in its Settings`
+      );
+  }
   /** The project only: the caller declares it before `ensureLayout` builds it. */
   async createBoard(org) {
     const project = await createProject(
@@ -2079,89 +2534,186 @@ var GitHubBoards = class {
         this.#o
       );
     }
+    const memory = await this.#memory(board.org);
+    if (memory.labelId === null) {
+      memory.labelId = await createLabel(
+        board.org,
+        MEMORY,
+        { name: LABEL, color: LABEL_COLOR, description: LABEL_DESCRIPTION },
+        this.#o
+      );
+      added.push(`label ${LABEL}`);
+    }
+    const repository2 = `${board.org}/${MEMORY}`;
+    const linked = await linkedRepositories(cache.projectId, this.#o);
+    if (!linked.some((r) => r.toLowerCase() === repository2.toLowerCase())) {
+      await linkRepository(cache.projectId, memory.id, this.#o);
+      added.push(`link ${repository2}`);
+    }
     cache.fields = [status2, collection, ...own.values(), agent, session, path];
     return added;
   }
-  async items(board) {
+  async items(board, options = {}) {
     const cache = await this.#cacheOf(board);
-    const raw = await listItems(cache.projectId, this.#o);
+    const raw = await listItems(cache.projectId, this.#o, options);
     cache.known = new Map(raw.map((r) => [r.id, r]));
-    return raw.filter((r) => !r.archived).map((r) => ({
-      id: r.id,
-      // No longer a draft issue (converted by hand): the team's, like an
-      // item without Path — the plan leaves it alone (spec 0017 §4).
-      path: r.draftId === null ? null : r.values["Path"] ?? null,
-      title: r.title,
-      status: r.values[STATUS_FIELD] ?? null,
-      collectionStatus: r.values[statusFieldName(r.values[COLLECTION_FIELD] ?? "")] ?? null,
-      type: r.values[COLLECTION_FIELD] ?? null,
-      agent: r.values["Agent"] ?? null,
-      session: r.values["Session"] ?? null
-    }));
+    const memory = `${board.org}/${MEMORY}`.toLowerCase();
+    return raw.filter((r) => !r.archived).map((r) => {
+      const issue = r.issue !== null && r.issue.repository.toLowerCase() === memory ? r.issue : null;
+      const ours = r.draftId !== null || issue !== null;
+      return {
+        id: r.id,
+        path: ours ? r.values["Path"] ?? null : null,
+        issue: issue === null ? null : {
+          number: issue.number,
+          open: issue.open,
+          labelled: labelled(issue.labels),
+          body: issue.body
+        },
+        title: r.title,
+        status: r.values[STATUS_FIELD] ?? null,
+        collectionStatus: r.values[statusFieldName(r.values[COLLECTION_FIELD] ?? "")] ?? null,
+        type: r.values[COLLECTION_FIELD] ?? null,
+        agent: r.values["Agent"] ?? null,
+        session: r.values["Session"] ?? null
+      };
+    });
   }
   async #set(board, itemId, name, value) {
     const cache = await this.#cacheOf(board);
     const field = (await this.#fields(board)).find((f) => f.name === name);
     if (field === void 0) throw new Error(`the board has no field ${name}`);
-    if (value === null) {
-      await setValue(cache.projectId, itemId, field.id, null, this.#o);
-      return;
+    let sent = null;
+    if (value !== null && field.options === null) sent = { text: value };
+    else if (value !== null) {
+      const option = field.options?.find((opt) => opt.name === value);
+      if (option === void 0)
+        throw new Error(`the field ${name} has no option ${value}`);
+      sent = { optionId: option.id };
     }
-    if (field.options === null) {
-      await setValue(
-        cache.projectId,
-        itemId,
-        field.id,
-        { text: value },
-        this.#o
-      );
-      return;
-    }
-    const option = field.options.find((opt) => opt.name === value);
-    if (option === void 0)
-      throw new Error(`the field ${name} has no option ${value}`);
-    await setValue(
-      cache.projectId,
-      itemId,
-      field.id,
-      { optionId: option.id },
-      this.#o
-    );
+    await setValue(cache.projectId, itemId, field.id, sent, this.#o);
+    const known = cache.known.get(itemId);
+    if (known === void 0) return;
+    if (value === null) delete known.values[name];
+    else known.values[name] = value;
   }
   async apply(board, step2) {
-    if (step2.kind === "unchanged") return;
+    if (step2.kind === "unchanged") return null;
     const cache = await this.#cacheOf(board);
-    if (step2.kind === "archive") {
+    if (step2.kind === "create") return this.#create(board, cache, step2.want);
+    const known = await this.#known(board, step2.id);
+    if (step2.kind === "archive" || step2.kind === "close") {
+      if (step2.kind === "close" && known.issue?.open === true)
+        await closeIssue(known.issue.id, this.#o);
       await archive(cache.projectId, step2.id, this.#o);
       cache.known.delete(step2.id);
-      return;
+      return null;
+    }
+    if (step2.kind === "body") {
+      const issue2 = this.#issueOf(known);
+      await updateIssue(issue2.id, { body: step2.body }, this.#o);
+      issue2.body = step2.body;
+      return null;
+    }
+    const labelId = await this.#labelId(board);
+    if (step2.kind === "convert") {
+      const made = await convertDraft(
+        step2.id,
+        (await this.#memory(board.org)).id,
+        this.#o
+      );
+      known.draftId = null;
+      known.issue = {
+        ...made,
+        open: true,
+        repository: `${board.org}/${MEMORY}`,
+        body: "",
+        labels: []
+      };
+      await this.#issue(known, step2.want, labelId);
+      await this.#values(board, step2.id, step2.want);
+      return { id: step2.id, number: made.number };
+    }
+    const issue = this.#issueOf(known);
+    if (step2.reopen) {
+      await reopenIssue(issue.id, this.#o);
+      issue.open = true;
+    }
+    await this.#issue(known, step2.want, labelId);
+    await this.#values(board, step2.id, step2.want);
+    return null;
+  }
+  /** A new document's issue: labelled, the first line as body, added to the board, Path first. */
+  async #create(board, cache, want) {
+    const memory = await this.#memory(board.org);
+    const labelId = await this.#labelId(board);
+    const made = await createIssue(
+      memory.id,
+      { title: want.title, body: want.body, labelIds: [labelId] },
+      this.#o
+    );
+    const id = await addItem(cache.projectId, made.id, this.#o);
+    cache.known.set(id, {
+      id,
+      draftId: null,
+      issue: {
+        ...made,
+        open: true,
+        repository: `${board.org}/${MEMORY}`,
+        body: want.body,
+        labels: [LABEL]
+      },
+      title: want.title,
+      archived: false,
+      values: {}
+    });
+    await this.#values(board, id, want);
+    return { id, number: made.number };
+  }
+  /** The label and the title an issue of the board carries. */
+  async #issue(known, want, labelId) {
+    const issue = this.#issueOf(known);
+    if (!labelled(issue.labels)) {
+      await addLabels(issue.id, [labelId], this.#o);
+      issue.labels.push(LABEL);
     }
-    const { want } = step2;
-    const values2 = [
+    if (known.title !== want.title) {
+      await updateIssue(issue.id, { title: want.title }, this.#o);
+      known.title = want.title;
+    }
+  }
+  /** Path first — an issue on the board without it is the team's — then the fields, each only when it differs. */
+  async #values(board, id, want) {
+    const values2 = (await this.#known(board, id)).values;
+    const wanted = [
       ["Path", want.path],
       [COLLECTION_FIELD, want.type],
       [STATUS_FIELD, want.status],
       ...want.statusField === null ? [] : [[want.statusField, want.status]]
     ];
-    if (step2.kind === "create") {
-      const id = await addDraft(
-        cache.projectId,
-        want.title,
-        want.body,
-        this.#o
+    for (const [name, value] of wanted)
+      if ((values2[name] ?? null) !== value)
+        await this.#set(board, id, name, value);
+  }
+  async #known(board, id) {
+    const cache = await this.#cacheOf(board);
+    if (!cache.known.has(id)) await this.items(board);
+    const known = cache.known.get(id);
+    if (known === void 0) throw new Error(`the board has no item ${id}`);
+    return known;
+  }
+  #issueOf(known) {
+    if (known.issue === null)
+      throw new Error(`the board's item ${known.id} is no issue`);
+    return known.issue;
+  }
+  async #labelId(board) {
+    const id = (await this.#memory(board.org)).labelId;
+    if (id === null)
+      throw new Error(
+        `${board.org}/${MEMORY} has no label ${LABEL}: run rness pulse sync`
       );
-      for (const [name, value] of values2)
-        if (value !== null) await this.#set(board, id, name, value);
-      return;
-    }
-    if (!cache.known.has(step2.id)) await this.items(board);
-    const known = cache.known.get(step2.id);
-    if (known?.draftId == null)
-      throw new Error(`the board has no draft item ${step2.id}`);
-    await editDraft(known.draftId, want.title, want.body, this.#o);
-    for (const [name, value] of values2)
-      if ((known.values[name] ?? null) !== value)
-        await this.#set(board, step2.id, name, value);
+    return id;
   }
   async mark(board, itemIds, session) {
     for (const id of itemIds) {
@@ -2176,6 +2728,7 @@ var GITHUB_HTTPS = "https://github.com/";
 var GitHubOAuthProvider = class {
   #token;
   #apiBase;
+  #wait;
   #login;
   #boardClient;
   get authenticated() {
@@ -2184,9 +2737,14 @@ var GitHubOAuthProvider = class {
   constructor(options) {
     this.#token = options.token;
     this.#apiBase = options.apiBase;
+    this.#wait = options.wait;
   }
   #api(token) {
-    return this.#apiBase === void 0 ? { token } : { token, apiBase: this.#apiBase };
+    return {
+      token,
+      ...this.#apiBase === void 0 ? {} : { apiBase: this.#apiBase },
+      ...this.#wait === void 0 ? {} : { wait: this.#wait }
+    };
   }
   identity() {
     this.#login ??= (async () => {
@@ -2240,6 +2798,9 @@ var GitHubOAuthProvider = class {
     return this.#boardClient;
   }
   // The board methods are async so that a missing login rejects, never throws.
+  async checkIssues(org) {
+    return this.#boards().checkIssues(org);
+  }
   async createBoard(org) {
     return this.#boards().createBoard(org);
   }
@@ -2249,8 +2810,8 @@ var GitHubOAuthProvider = class {
   async ensureLayout(board, layout) {
     return this.#boards().ensureLayout(board, layout);
   }
-  async items(board) {
-    return this.#boards().items(board);
+  async items(board, options) {
+    return this.#boards().items(board, options);
   }
   async apply(board, step2) {
     return this.#boards().apply(board, step2);
@@ -2263,16 +2824,17 @@ var GitHubOAuthProvider = class {
     return { username: "x-access-token", password: this.#token.token };
   }
 };
-async function githubProvider(apiBase) {
+async function githubProvider(apiBase, wait) {
   return new GitHubOAuthProvider({
     token: await resolveToken(),
-    ...apiBase === void 0 ? {} : { apiBase }
+    ...apiBase === void 0 ? {} : { apiBase },
+    ...wait === void 0 ? {} : { wait }
   });
 }
 
 // src/core/repos.ts
 import { glob as glob2, readFile as readFile5, rm as rm3 } from "fs/promises";
-import { join as join8, posix as posix4, sep as sep2 } from "path";
+import { join as join8, posix as posix5, sep as sep2 } from "path";
 async function addRepository(input) {
   const { name, url } = parseRepoSpec(input.spec, input.org, input.host);
   const dir = join8(input.root, "org", name);
@@ -2352,8 +2914,8 @@ async function workspaceDirs(repoDir) {
   const dirs = /* @__PURE__ */ new Set();
   for (const pattern of patterns) {
     for await (const match of glob2(pattern, { cwd: repoDir })) {
-      const rel = match.split(sep2).join(posix4.sep);
-      if (await exists(join8(repoDir, ...rel.split(posix4.sep), "package.json")))
+      const rel = match.split(sep2).join(posix5.sep);
+      if (await exists(join8(repoDir, ...rel.split(posix5.sep), "package.json")))
         dirs.add(rel);
     }
   }
@@ -2650,7 +3212,7 @@ function reportError(e) {
 }
 
 // src/core/block.ts
-import { createHash } from "crypto";
+import { createHash as createHash2 } from "crypto";
 var BEGIN = "<!-- BEGIN rness -->";
 var END = "<!-- END rness -->";
 var BLOCK_SIZE_WARNING = 32 * 1024;
@@ -2659,7 +3221,7 @@ function toLf(s) {
   return s.replace(/\r\n?/g, "\n");
 }
 function blockHash(body) {
-  return createHash("sha256").update(toLf(body), "utf8").digest("hex").slice(0, 12);
+  return createHash2("sha256").update(toLf(body), "utf8").digest("hex").slice(0, 12);
 }
 function intro(scope, org, depth) {
   if (scope === null) {
@@ -3059,8 +3621,8 @@ function wholeDiff(existing, content) {
 async function filesOf(root, manifest, targets) {
   const files = [];
   if (!await exists(join11(root, "org"))) return files;
-  for (const target of targets)
-    for (const owned of target.files)
+  for (const target2 of targets)
+    for (const owned of target2.files)
       if (owned.at === "root")
         files.push({
           ...owned,
@@ -3069,8 +3631,8 @@ async function filesOf(root, manifest, targets) {
         });
   for (const repo of Object.keys(manifest.repos)) {
     if (!await exists(join11(root, "org", repo))) continue;
-    for (const target of targets)
-      for (const owned of target.files)
+    for (const target2 of targets)
+      for (const owned of target2.files)
         if (owned.at === "clones")
           files.push({
             ...owned,
@@ -3183,7 +3745,7 @@ var PROVIDERS = {
     name: "github",
     label: "GitHub",
     available: true,
-    open: ({ apiBase }) => githubProvider(apiBase)
+    open: ({ apiBase, wait }) => githubProvider(apiBase, wait)
   },
   gitlab: { name: "gitlab", label: "GitLab", available: false },
   atlassian: {
@@ -3885,7 +4447,7 @@ async function addCommand(spec, opts, deps = {}) {
 }
 
 // src/commands/context.ts
-import { posix as posix5, relative, sep as sep3 } from "path";
+import { posix as posix6, relative, sep as sep3 } from "path";
 function renderMarkdown(ctx) {
   const parts = [];
   for (const collection of ctx.collections) {
@@ -3917,7 +4479,7 @@ async function contextCommand(opts) {
       }
       scope = opts.scope;
     } else {
-      const rel = relative(ws.root, cwd).split(sep3).join(posix5.sep);
+      const rel = relative(ws.root, cwd).split(sep3).join(posix6.sep);
       scope = resolveScope(manifest, rel);
     }
     const ctx = await assembleContext({
@@ -5782,9 +6344,9 @@ async function clonesToCommit(root, cwd, manifest) {
   }
   return clones;
 }
-function finish(ui, cwd, rnessDir, label, target, ending) {
+function finish(ui, cwd, rnessDir, label, target2, ending) {
   const rel = relative5(cwd, rnessDir) || ".";
-  const message2 = `chore: rness ${target}`;
+  const message2 = `chore: rness ${target2}`;
   const next = [];
   if (ending.commit === "committed") next.push(`git -C ${rel} push`);
   if (ending.commit === "refused")
@@ -5797,12 +6359,12 @@ function finish(ui, cwd, rnessDir, label, target, ending) {
     next.push("# teammates: git pull \u2014 the next rness command installs it");
   if (ui.session) {
     if (next.length > 0) ui.note("Next steps", next);
-    ui.outro(`${label} runs @rness/cli ${target}`);
+    ui.outro(`${label} runs @rness/cli ${target2}`);
   } else
     process.stdout.write(
       [
         "",
-        status("upgraded", `${label} to @rness/cli ${target}`),
+        status("upgraded", `${label} to @rness/cli ${target2}`),
         "",
         ...next.length > 0 ? ["Next:", ...next.map((line3) => `  ${line3}`), ""] : []
       ].join("\n")
@@ -5838,12 +6400,12 @@ async function upgradeCommand(version, opts, terminal = defaultTerminal, deps =
     }
     const ui = interactive ? await makeUi(terminal) : { ...plainUi };
     ui.intro(`Upgrade workspace ${basename5(ws.root)}`);
-    const target = version ?? await ui.step(
+    const target2 = version ?? await ui.step(
       { doing: "asking   the registry for the latest release", quiet: true },
       () => latestVersion(),
       (v) => v === null ? null : ["latest", `@rness/cli ${v}`]
     );
-    if (target === null) {
+    if (target2 === null) {
       process.stderr.write(
         `cannot reach the registry; name the version: ${rnessCommand()} upgrade <version>
 `
@@ -5871,44 +6433,44 @@ async function upgradeCommand(version, opts, terminal = defaultTerminal, deps =
       return 1;
     }
     const base = await findScaffoldBase(ws.rnessDir);
-    const scaffoldCurrent = base !== null && base.version === target;
-    if (pin.spec === target && installed === target && scaffoldCurrent) {
-      if (ui.session) ui.outro(`Already at ${target}`);
-      else process.stdout.write(`already at ${target}
+    const scaffoldCurrent = base !== null && base.version === target2;
+    if (pin.spec === target2 && installed === target2 && scaffoldCurrent) {
+      if (ui.session) ui.outro(`Already at ${target2}`);
+      else process.stdout.write(`already at ${target2}
 `);
       return 0;
     }
-    const downgrading = EXACT_VERSION.test(pin.spec) && compareVersions(target, pin.spec) < 0;
+    const downgrading = EXACT_VERSION.test(pin.spec) && compareVersions(target2, pin.spec) < 0;
     if (downgrading && version === void 0) {
       process.stderr.write(
-        `${label} pins @rness/cli ${pin.spec}, newer than the latest release ${target}; to downgrade: ${rnessCommand()} upgrade ${target}
+        `${label} pins @rness/cli ${pin.spec}, newer than the latest release ${target2}; to downgrade: ${rnessCommand()} upgrade ${target2}
 `
       );
       return 1;
     }
     const pm = await workspacePackageManager(ws.rnessDir);
-    if (pin.spec === target && installed === target)
+    if (pin.spec === target2 && installed === target2)
       ui.line(
         "scaffold",
-        `@rness/cli ${target} \u2014 merging it into ${label}`,
-        `Merging the @rness/cli ${target} scaffold into ${label}`
+        `@rness/cli ${target2} \u2014 merging it into ${label}`,
+        `Merging the @rness/cli ${target2} scaffold into ${label}`
       );
-    else if (pin.spec === target)
+    else if (pin.spec === target2)
       ui.line(
         "install",
-        `@rness/cli ${target} in ${label} (${pm}) \u2014 ${installed ?? "nothing"} is installed`
+        `@rness/cli ${target2} in ${label} (${pm}) \u2014 ${installed ?? "nothing"} is installed`
       );
     else {
       ui.line(
         "upgrade",
-        `@rness/cli ${pin.spec} \u2192 ${target} in ${label} (${pm})${downgrading ? " \u2014 downgrading" : ""}`
+        `@rness/cli ${pin.spec} \u2192 ${target2} in ${label} (${pm})${downgrading ? " \u2014 downgrading" : ""}`
       );
       ui.line("notes", NOTES, `Release notes: ${NOTES}`);
     }
     if (interactive) {
       const p = await terminal.prompts();
       const ok = await p.confirm({
-        message: `Upgrade @rness/cli to ${target}?`
+        message: `Upgrade @rness/cli to ${target2}?`
       });
       if (p.isCancel(ok) || ok !== true) {
         ui.cancelled();
@@ -5918,31 +6480,31 @@ async function upgradeCommand(version, opts, terminal = defaultTerminal, deps =
     let merged = false;
     if (!scaffoldCurrent) {
       const source = await (deps.scaffoldFor ?? scaffoldFor)(
-        target,
+        target2,
         ws.rnessDir
       );
       try {
         const files = await renderScaffold(source.dir, {
-          version: target,
+          version: target2,
           packageManager: await declaredManager(ws.rnessDir, pm)
         });
         if (base === null)
           ui.line(
             "adopting",
-            `the @rness/cli ${target} scaffold (no scaffold commit in ${label} yet)`,
-            `Adopting the @rness/cli ${target} scaffold \u2014 ${label} has no scaffold commit yet`
+            `the @rness/cli ${target2} scaffold (no scaffold commit in ${label} yet)`,
+            `Adopting the @rness/cli ${target2} scaffold \u2014 ${label} has no scaffold commit yet`
           );
         else
           ui.line(
             "merging",
-            `the @rness/cli ${target} scaffold`,
-            `Merging the @rness/cli ${target} scaffold`
+            `the @rness/cli ${target2} scaffold`,
+            `Merging the @rness/cli ${target2} scaffold`
           );
         const commit = await buildScaffoldCommit(
           ws.rnessDir,
           base?.commit ?? null,
           base === null ? await withoutRedundantKeeps(ws.rnessDir, files) : files,
-          target
+          target2
         );
         const result = await mergeScaffold(
           ws.rnessDir,
@@ -5969,9 +6531,9 @@ async function upgradeCommand(version, opts, terminal = defaultTerminal, deps =
       [packageFile, await readFile9(packageFile, "utf8")]
     ]);
     const moved = await readPin(ws.rnessDir);
-    if (moved !== null && moved.spec !== target)
-      await writePin(ws.rnessDir, moved.spec, target);
-    const mustInstall = !(pin.spec === target && installed === target);
+    if (moved !== null && moved.spec !== target2)
+      await writePin(ws.rnessDir, moved.spec, target2);
+    const mustInstall = !(pin.spec === target2 && installed === target2);
     if (mustInstall) {
       try {
         await ui.step(
@@ -6002,9 +6564,9 @@ async function upgradeCommand(version, opts, terminal = defaultTerminal, deps =
         return 1;
       }
       const now = (await readPinnedCli(ws.rnessDir))?.version ?? null;
-      if (now !== target) {
+      if (now !== target2) {
         process.stderr.write(
-          `${pm} install left @rness/cli ${now ?? "not installed"} in ${label}, not ${target}
+          `${pm} install left @rness/cli ${now ?? "not installed"} in ${label}, not ${target2}
 `
         );
         return 1;
@@ -6013,7 +6575,7 @@ async function upgradeCommand(version, opts, terminal = defaultTerminal, deps =
     ui.gitIsSilent = true;
     const code = await syncBlocks(ui, ws.root, basename5(ws.root));
     if (code !== 0) return code;
-    const message2 = `chore: rness ${target}`;
+    const message2 = `chore: rness ${target2}`;
     const committed = await commitUpgrade(ws.rnessDir, message2);
     if (committed.kind === "committed")
       ui.line(
@@ -6028,7 +6590,7 @@ async function upgradeCommand(version, opts, terminal = defaultTerminal, deps =
       for (const line3 of committed.output.split("\n"))
         if (line3.trim() !== "") ui.hint(line3, "stderr");
     }
-    return finish(ui, cwd, ws.rnessDir, label, target, {
+    return finish(ui, cwd, ws.rnessDir, label, target2, {
       commit: committed.kind,
       clones: await clonesToCommit(
         ws.root,
@@ -6153,11 +6715,11 @@ password=${resolved.token}
 
 // src/commands/hook.ts
 import { realpath as realpath4 } from "fs/promises";
-import { isAbsolute as isAbsolute2, posix as posix7, relative as relative7, resolve as resolve7, sep as sep5 } from "path";
+import { isAbsolute as isAbsolute2, posix as posix8, relative as relative7, resolve as resolve7, sep as sep5 } from "path";
 
 // src/mcp/tools.ts
 import { readFile as readFile10, realpath as realpath3, stat as stat4 } from "fs/promises";
-import { isAbsolute, join as join24, posix as posix6, relative as relative6, resolve as resolve6, sep as sep4 } from "path";
+import { isAbsolute, join as join24, posix as posix7, relative as relative6, resolve as resolve6, sep as sep4 } from "path";
 var LABELS = {
   standards: "Standards",
   adr: "Decisions",
@@ -6197,7 +6759,7 @@ async function documents(rnessDir, only) {
         scope: ownerScope(item.rel),
         id,
         status: typeof status2 === "string" ? status2 : null,
-        title: documentTitle(item.title ?? posix6.basename(item.rel, ".md"), id),
+        title: documentTitle(item.title ?? posix7.basename(item.rel, ".md"), id),
         text: item.body
       });
     }
@@ -6227,7 +6789,7 @@ async function context(cwd, args) {
   } else
     scope = resolveScope(
       manifest,
-      relative6(ws.root, cwd).split(sep4).join(posix6.sep)
+      relative6(ws.root, cwd).split(sep4).join(posix7.sep)
     );
   const summary = await scopeSummary(ws, manifest, scope);
   return {
@@ -6416,8 +6978,9 @@ function mcpTools(cwd) {
 
 // src/pulse/detached.ts
 import { spawn as nodeSpawn } from "child_process";
-import { mkdir as mkdir7, readFile as readFile11, rm as rm8, writeFile as writeFile4 } from "fs/promises";
+import { mkdir as mkdir7, open as open2, readFile as readFile11, rm as rm8, stat as stat5, writeFile as writeFile4 } from "fs/promises";
 import { join as join25 } from "path";
+import { setTimeout as delay2 } from "timers/promises";
 var detached = (args, cwd) => {
   const bin = process.argv[1];
   if (bin === void 0) return;
@@ -6452,6 +7015,33 @@ async function takeFailure() {
     return null;
   }
 }
+var PULSE_LOCK_STALE_MS = 15 * 6e4;
+async function oneSyncAtATime(key, work, options = {}) {
+  await mkdir7(configDir(), { recursive: true, mode: 448 });
+  const file = join25(configDir(), `pulse-${key}.lock`);
+  for (; ; ) {
+    try {
+      const handle = await open2(file, "wx");
+      await handle.close();
+      break;
+    } catch (e) {
+      if (e.code !== "EEXIST") throw e;
+      const age = await stat5(file).then(
+        (s) => Date.now() - s.mtimeMs,
+        () => 0
+      );
+      if (age > PULSE_LOCK_STALE_MS) await rm8(file, { force: true });
+      else if (options.wait !== true) return false;
+      else await (options.sleep ?? ((ms) => delay2(ms)))(1e3);
+    }
+  }
+  try {
+    await work();
+    return true;
+  } finally {
+    await rm8(file, { force: true });
+  }
+}
 
 // src/commands/hook.ts
 var NOUNS = {
@@ -6479,7 +7069,7 @@ function cwdOf(input, env) {
   if (typeof cwd === "string" && cwd !== "") return cwd;
   return env["CLAUDE_PROJECT_DIR"] ?? process.cwd();
 }
-var toPosix2 = (p) => p.split(sep5).join(posix7.sep);
+var toPosix2 = (p) => p.split(sep5).join(posix8.sep);
 function count(n, [one, many]) {
   return `${n} ${n === 1 ? one : many}`;
 }
@@ -6823,29 +7413,162 @@ async function mcpCommand(opts, io = {
   return 0;
 }
 
+// src/commands/pulse.ts
+import { readFile as readFile13, readdir as readdir4 } from "fs/promises";
+import { join as join26 } from "path";
+import { setTimeout as delay3 } from "timers/promises";
+
+// src/pulse/opened.ts
+import { mkdir as mkdir8, readFile as readFile12, rename as rename3, rm as rm9, writeFile as writeFile5 } from "fs/promises";
+import { dirname as dirname9 } from "path";
+var NAME2 = "rness/opened";
+function openedFile(rnessDir) {
+  return gitPath(rnessDir, NAME2);
+}
+var NUMBER = /^[1-9][0-9]*$/;
+async function readOpened(file) {
+  const opened = /* @__PURE__ */ new Map();
+  if (file === null) return opened;
+  let data;
+  try {
+    data = JSON.parse(await readFile12(file, "utf8"));
+  } catch {
+    return opened;
+  }
+  if (data === null || typeof data !== "object" || Array.isArray(data))
+    return opened;
+  for (const [key, path] of Object.entries(data))
+    if (NUMBER.test(key) && typeof path === "string" && path !== "")
+      opened.set(Number(key), path);
+  return opened;
+}
+async function writeOpened(file, opened) {
+  if (file === null) return;
+  try {
+    if (opened.size === 0) {
+      await rm9(file, { force: true });
+      return;
+    }
+    const entries = [...opened].sort(([a], [b]) => a - b);
+    await mkdir8(dirname9(file), { recursive: true });
+    const temporary = `${file}.${process.pid}`;
+    await writeFile5(
+      temporary,
+      `${JSON.stringify(Object.fromEntries(entries), null, 2)}
+`
+    );
+    await rename3(temporary, file);
+  } catch {
+  }
+}
+
 // src/pulse/plan.ts
-function planSync(want, have) {
+var differs = (item, w) => item.title !== w.title || item.status !== w.status || w.statusField !== null && item.collectionStatus !== w.status || item.type !== w.type;
+var rank = (i) => i.issue === null ? 2 : i.issue.open ? 0 : 1;
+var keptFirst = (a, b) => rank(a) - rank(b) || (a.issue?.number ?? 0) - (b.issue?.number ?? 0);
+var gone = (item) => item.issue === null ? { kind: "archive", id: item.id } : { kind: "close", id: item.id };
+var firstLine5 = (body) => body.split(/\r\n?|\n/, 1)[0] ?? "";
+function strays(have) {
+  const byLine = /* @__PURE__ */ new Map();
+  for (const item of have) {
+    if (item.path !== null || item.issue === null || item.issue.body === null || !item.issue.labelled)
+      continue;
+    const line3 = firstLine5(item.issue.body);
+    byLine.set(line3, [...byLine.get(line3) ?? [], item]);
+  }
+  for (const items of byLine.values()) items.sort(keptFirst);
+  return byLine;
+}
+function unwantedPaths(want, have) {
+  const wanted = new Set(want.map((w) => w.path));
+  const paths = /* @__PURE__ */ new Set();
+  for (const item of have)
+    if (item.path !== null && !wanted.has(item.path)) paths.add(item.path);
+  return [...paths];
+}
+function isGone(path, item, seen, opened) {
+  return seen.has(path) || item.issue !== null && opened.get(item.issue.number) === path;
+}
+function planSync(want, have, seen = /* @__PURE__ */ new Set(), opened = /* @__PURE__ */ new Map()) {
   const byPath = /* @__PURE__ */ new Map();
-  const steps = [];
+  for (const item of have)
+    if (item.path !== null)
+      byPath.set(item.path, [...byPath.get(item.path) ?? [], item]);
+  const kept = /* @__PURE__ */ new Map();
   const surplus = [];
-  for (const item of have) {
-    if (item.path === null) continue;
-    if (byPath.has(item.path)) surplus.push({ kind: "archive", id: item.id });
-    else byPath.set(item.path, item);
+  for (const [path, items] of byPath) {
+    const [keep, ...rest] = [...items].sort(keptFirst);
+    if (keep !== void 0) kept.set(path, keep);
+    surplus.push(...rest.map(gone));
   }
+  const left = strays(have);
+  const steps = [];
   const wanted = /* @__PURE__ */ new Set();
   for (const w of want) {
     wanted.add(w.path);
-    const item = byPath.get(w.path);
+    const item = kept.get(w.path) ?? left.get(w.body)?.[0];
     if (item === void 0) steps.push({ kind: "create", want: w });
-    else if (item.title !== w.title || item.status !== w.status || w.statusField !== null && item.collectionStatus !== w.status || item.type !== w.type)
-      steps.push({ kind: "update", id: item.id, want: w });
+    else if (item.issue === null)
+      steps.push({ kind: "convert", id: item.id, want: w });
+    else if (item.path === null || !item.issue.open || !item.issue.labelled || differs(item, w))
+      steps.push({
+        kind: "update",
+        id: item.id,
+        want: w,
+        reopen: !item.issue.open
+      });
     else steps.push({ kind: "unchanged", id: item.id });
   }
-  for (const [path, item] of byPath)
-    if (!wanted.has(path)) steps.push({ kind: "archive", id: item.id });
+  for (const [path, item] of kept)
+    if (!wanted.has(path))
+      steps.push(
+        isGone(path, item, seen, opened) ? gone(item) : { kind: "unchanged", id: item.id }
+      );
   return [...steps, ...surplus];
 }
+function stillOpened(opened, have, seen, closed, created) {
+  const items = /* @__PURE__ */ new Map();
+  for (const item of have)
+    if (item.issue !== null) items.set(item.issue.number, item.id);
+  const next = /* @__PURE__ */ new Map();
+  for (const [number, path] of opened) {
+    const id = items.get(number);
+    if (id !== void 0 && !closed.has(id) && !seen.has(path))
+      next.set(number, path);
+  }
+  for (const [path, placed] of created) next.set(placed.number, path);
+  return next;
+}
+function issuedAfter(steps, have, placed) {
+  const byId = new Map(have.map((i) => [i.id, i]));
+  const issued = /* @__PURE__ */ new Map();
+  for (const step2 of steps) {
+    if (step2.kind === "create" || step2.kind === "convert") {
+      const p = placed.get(step2.want.path);
+      if (p !== void 0) issued.set(step2.want.path, { ...p, body: null });
+    } else if (step2.kind === "update" || step2.kind === "unchanged") {
+      const item = byId.get(step2.id);
+      const path = step2.kind === "update" ? step2.want.path : item?.path;
+      if (item === void 0 || path == null || item.issue === null) continue;
+      issued.set(path, {
+        id: item.id,
+        number: item.issue.number,
+        body: item.issue.body
+      });
+    }
+  }
+  return issued;
+}
+function planBodies(bodies, issued) {
+  const steps = [];
+  for (const [path, body] of bodies) {
+    const i = issued.get(path);
+    if (i === void 0) continue;
+    if (i.body === null || digestOf(i.body) !== digestOf(body))
+      steps.push({ kind: "body", id: i.id, body });
+  }
+  return steps;
+}
 
 // src/commands/pulse.ts
 var PROJECT_SCOPE = "project";
@@ -6861,15 +7584,23 @@ async function fromGithub(work) {
     throw e;
   }
 }
-async function context2(opts) {
+var apiOf = (opts) => opts.githubApi === void 0 ? {} : { apiBase: opts.githubApi };
+var providerOptions = (opts, wait) => ({
+  ...apiOf(opts),
+  ...wait === void 0 ? {} : { wait }
+});
+async function context2(opts, wait) {
   const ws = await findWorkspace(opts.cwd ?? process.cwd());
   const manifest = await loadManifest(ws.rnessDir);
-  const provider = await openProvider(manifest, apiOf(opts));
+  const provider = await openProvider(manifest, providerOptions(opts, wait));
   if (manifest.org === null)
     throw new Error('the pulse needs an organization: rness.json has no "org"');
   return { rnessDir: ws.rnessDir, manifest, org: manifest.org, provider };
 }
-var apiOf = (opts) => opts.githubApi === void 0 ? {} : { apiBase: opts.githubApi };
+var waitSaid = (opts, ui) => rateWait(async (ms) => {
+  ui.line("waiting", `${Math.round(ms / 1e3)} s \u2014 GitHub's rate limit`);
+  await (opts.sleep ?? ((n) => delay3(n)))(ms);
+});
 async function missingAccess(provider) {
   if (!provider.authenticated) return NEEDS_LOGIN;
   const scopes = await fromGithub(provider.scopes());
@@ -6895,33 +7626,131 @@ var createdByKind = (ui, added) => {
     const names = added.filter((a) => a.startsWith(`${kind} `)).map((a) => a.slice(kind.length + 1));
     if (names.length > 0) ui.line("created", `${kind}s ${names.join(", ")}`);
   }
+  for (const a of added) {
+    if (a.startsWith("label ")) ui.line("created", a);
+    else if (a.startsWith("link "))
+      ui.line("linked", `Agent Pulse to ${a.slice("link ".length)}`);
+  }
 };
+async function filesOf2(rnessDir) {
+  const files = /* @__PURE__ */ new Set();
+  const walk = async (rel) => {
+    const dir = rel === "" ? rnessDir : join26(rnessDir, ...rel.split("/"));
+    for (const e of await readdir4(dir, { withFileTypes: true })) {
+      const path = rel === "" ? e.name : `${rel}/${e.name}`;
+      if (e.isDirectory()) {
+        if (e.name !== ".git" && e.name !== "node_modules") await walk(path);
+      } else if (e.isFile()) files.add(path);
+    }
+  };
+  await walk("");
+  return files;
+}
+var count2 = (n, word) => `${n} ${word}${n === 1 ? "" : "s"}`;
+function sayDone(ui, org, documents2, steps, writes) {
+  const n = (kind) => steps.filter((s) => s.kind === kind).length;
+  const reopened = steps.filter((s) => s.kind === "update" && s.reopen).length;
+  if (n("create") > 0) ui.line("created", count2(n("create"), "issue"));
+  if (n("convert") > 0)
+    ui.line(
+      "converted",
+      `${count2(n("convert"), "draft")} into issues of ${org}/.rness`
+    );
+  if (reopened > 0) ui.line("reopened", count2(reopened, "issue"));
+  const written = new Set(writes.map((w) => w.id));
+  const bodyOnly = steps.filter(
+    (s) => s.kind === "unchanged" && written.has(s.id)
+  ).length;
+  const parts = [
+    ["created", n("create")],
+    ["converted", n("convert")],
+    ["updated", n("update") + bodyOnly],
+    [
+      "unchanged",
+      documents2 - n("create") - n("convert") - n("update") - bodyOnly
+    ],
+    ["archived", n("close") + n("archive")]
+  ].filter(([, k]) => k > 0).map(([word, k]) => `${k} ${word}`);
+  ui.line(
+    "synced",
+    `${plural(documents2)}${parts.length > 0 ? `: ${parts.join(", ")}` : ""}`
+  );
+}
 async function syncBoard(c, board, ui, sayLayout) {
+  await fromGithub(c.provider.checkIssues(c.org));
   const tabs = await statusTabs(c.rnessDir);
   const want = desiredOf(tabs, c.org);
   sayLayout(
     ui,
     await fromGithub(c.provider.ensureLayout(board, layoutOf(tabs)))
   );
-  const steps = planSync(want, await fromGithub(c.provider.items(board)));
-  for (const step2 of steps) await fromGithub(c.provider.apply(board, step2));
-  const count2 = (kind) => steps.filter((s) => s.kind === kind).length;
-  const parts = [
-    ["created", "create"],
-    ["updated", "update"],
-    ["unchanged", "unchanged"],
-    ["archived", "archive"]
-  ].map(([word, kind]) => [word, count2(kind)]).filter(([, n]) => n > 0).map(([word, n]) => `${n} ${word}`);
-  ui.line(
-    "synced",
-    `${plural(want.length)}${parts.length > 0 ? `: ${parts.join(", ")}` : ""}`
-  );
+  const have = await fromGithub(c.provider.items(board));
+  const record = await openedFile(c.rnessDir);
+  const opened = await readOpened(record);
+  const seen = await seenPaths(c.rnessDir, [
+    ...unwantedPaths(want, have),
+    ...opened.values()
+  ]);
+  const steps = planSync(want, have, seen, opened);
+  const changes = steps.filter((s) => s.kind !== "unchanged").length;
+  let writes = [];
+  let made = 0;
+  try {
+    const placed = /* @__PURE__ */ new Map();
+    const created = /* @__PURE__ */ new Map();
+    const closed = /* @__PURE__ */ new Set();
+    try {
+      for (const step2 of steps) {
+        const p = await fromGithub(c.provider.apply(board, step2));
+        if (p !== null && (step2.kind === "create" || step2.kind === "convert"))
+          placed.set(step2.want.path, p);
+        if (p !== null && step2.kind === "create") created.set(step2.want.path, p);
+        if (step2.kind === "close" || step2.kind === "archive")
+          closed.add(step2.id);
+        if (step2.kind !== "unchanged") made++;
+      }
+    } finally {
+      await writeOpened(
+        record,
+        stillOpened(opened, have, seen, closed, created)
+      );
+    }
+    const issued = issuedAfter(steps, have, placed);
+    const numbers = new Map([...issued].map(([path, i]) => [path, i.number]));
+    const files = await filesOf2(c.rnessDir);
+    const bodies = /* @__PURE__ */ new Map();
+    for (const w of want)
+      bodies.set(
+        w.path,
+        issueBody({
+          path: w.path,
+          text: await readFile13(join26(c.rnessDir, ...w.path.split("/")), "utf8"),
+          org: c.org,
+          numbers,
+          files
+        })
+      );
+    writes = planBodies(bodies, issued);
+    for (const step2 of writes) {
+      await fromGithub(c.provider.apply(board, step2));
+      made++;
+    }
+  } catch (e) {
+    if (!(e instanceof RateLimitError)) throw e;
+    const total = changes + writes.length;
+    throw new Error(
+      `${e.message}: ${total - made} of ${total} changes not made \u2014 the next rness pulse sync makes them`,
+      { cause: e }
+    );
+  }
+  sayDone(ui, c.org, want.length, steps, writes);
 }
 async function pulseCreateCommand(opts, deps = {}) {
   try {
     const terminal = deps.terminal ?? defaultTerminal;
     const ui = deps.ui ?? await makeUi(terminal);
-    let c = await context2(opts);
+    const wait = waitSaid(opts, ui);
+    let c = await context2(opts, wait);
     if (c.manifest.pulse !== null)
       throw new Error(
         `already declared: ${boardUrl(c.org, c.manifest.pulse.project)} \u2014 rness pulse sync`
@@ -6949,10 +7778,14 @@ async function pulseCreateCommand(opts, deps = {}) {
         { terminal, ui, ...opts.cwd === void 0 ? {} : { cwd: opts.cwd } }
       );
       if (code !== 0) return code;
-      c = { ...c, provider: await openProvider(c.manifest, apiOf(opts)) };
+      c = {
+        ...c,
+        provider: await openProvider(c.manifest, providerOptions(opts, wait))
+      };
       const still = await missingAccess(c.provider);
       if (still !== null) throw new Error(still);
     }
+    await fromGithub(c.provider.checkIssues(c.org));
     const login = (await c.provider.identity())?.login ?? "unknown";
     ui.line(
       "checked",
@@ -6981,7 +7814,7 @@ async function pulseCreateCommand(opts, deps = {}) {
 async function pulseSyncCommand(opts, deps = {}) {
   try {
     const ui = deps.ui ?? await makeUi(deps.terminal ?? defaultTerminal);
-    const c = await context2(opts);
+    const c = await context2(opts, waitSaid(opts, ui));
     await syncBoard(c, await declaredBoard(c), ui, eachAdded);
     return 0;
   } catch (e) {
@@ -6999,17 +7832,37 @@ async function pulseMarkCommand(opts) {
 async function mark(opts) {
   const c = await context2(opts);
   const board = await declaredBoard(c);
-  const items = await fromGithub(c.provider.items(board));
+  const key = `${c.org}-${board.number}`;
+  const lock = opts.sleep === void 0 ? {} : { sleep: opts.sleep };
+  const listed = () => fromGithub(c.provider.items(board, { bodies: false }));
+  let items = await listed();
   if (opts.end === true) {
     const id = opts.session.split(" \xB7 ").pop() ?? opts.session;
     const ids2 = items.filter(
       (i) => i.session === opts.session || i.session?.endsWith(` \xB7 ${id}`)
     ).map((i) => i.id);
     await fromGithub(c.provider.mark(board, ids2, null));
-    await syncBoard(c, board, plainUi, eachAdded);
+    await oneSyncAtATime(key, () => syncBoard(c, board, plainUi, eachAdded), {
+      ...lock,
+      wait: true
+    });
     return 0;
   }
   const wanted = new Set(opts.paths);
+  const documents2 = new Set(
+    (await statusTabs(c.rnessDir)).flatMap((t) => t.rows.map((r) => r.path))
+  );
+  const onBoard = new Set(
+    items.flatMap((i) => i.path === null ? [] : [i.path])
+  );
+  if ([...wanted].some((p) => documents2.has(p) && !onBoard.has(p))) {
+    const synced = await oneSyncAtATime(
+      key,
+      () => syncBoard(c, board, plainUi, eachAdded),
+      lock
+    );
+    if (synced) items = await listed();
+  }
   const ids = items.filter((i) => i.path !== null && wanted.has(i.path)).map((i) => i.id);
   await fromGithub(c.provider.mark(board, ids, opts.session));
   return 0;
@@ -7528,4 +8381,4 @@ export {
   OWN_COMMANDS,
   catchUp
 };
-//# sourceMappingURL=chunk-AEW7ZDFS.js.map
+//# sourceMappingURL=chunk-4VTYSPZW.js.map