@joshuafolkken/kit 1.3044.0 → 1.3092.0

package/dist/commands/chunk-5VQCL33M.js

@@ -0,0 +1,46 @@
+import {
+  PLATFORM_TEMP_ROOT,
+  platform_temporary
+} from "./chunk-VLN6TSPJ.js";
+
+// scripts/josh/durable-state-root.ts
+import path from "node:path";
+var STATE_DIRECTORY = "josh";
+var RUN_STATE_DIRECTORY = "run-state";
+var OVERRIDE_STATE_DIRECTORY = "josh-state";
+function state_root(override, read_common) {
+  if (override !== void 0 && override !== "") {
+    return path.join(override, OVERRIDE_STATE_DIRECTORY);
+  }
+  const common = read_common();
+  if (common === void 0) return PLATFORM_TEMP_ROOT;
+  return path.join(common, STATE_DIRECTORY, RUN_STATE_DIRECTORY);
+}
+var STATE_ROOT_OVERRIDE = process.env[platform_temporary.TEMP_ROOT_KEY];
+var PREFIX = {
+  CARRY: "josh-run-carry-",
+  ENDED: "josh-run-ended-",
+  EVENTS: "josh-run-events-",
+  LANE_STATE: "josh-lane-state-",
+  LANE_LEDGER: "josh-lane-ledger-",
+  WAKE_LOG: "josh-run-wake-log-",
+  BACKLOGRUN_LAUNCH: "josh-backlogrun-launch-",
+  BACKLOGRUN_LOG: "josh-backlogrun-log-",
+  HANDOFF_LOG: "josh-run-handoff-log-",
+  SHIP_LOG: "josh-ship-log-",
+  SHIP_RESULT: "josh-ship-result-",
+  LANE_DISPATCH: "josh-lane-dispatch-",
+  LANE_PLAN: "josh-lane-plan-",
+  INVESTIGATION: "josh-investigation-record-",
+  GH_USAGE: "josh-gh-usage-"
+};
+var durable_state_root = {
+  PREFIX,
+  STATE_DIRECTORY,
+  STATE_ROOT_OVERRIDE,
+  state_root
+};
+
+export {
+  durable_state_root
+};

package/dist/commands/chunk-5Y7FOJLX.js

@@ -0,0 +1,186 @@
+import {
+  lane_handoff,
+  lane_process_table
+} from "./chunk-BRMJVCP7.js";
+import {
+  PROCESS_ALIVE,
+  PROCESS_NONE,
+  PROCESS_UNKNOWN,
+  run_liveness
+} from "./chunk-DHJRFBKO.js";
+import {
+  lane_child_invocation,
+  lane_reap,
+  process_tools
+} from "./chunk-ON4IKRGS.js";
+import {
+  poll
+} from "./chunk-SBGTCT2C.js";
+import {
+  agent_session_environment
+} from "./chunk-HHBC6QZE.js";
+import {
+  issue_number_shape
+} from "./chunk-G75GWNNY.js";
+import {
+  MS_PER_SECOND,
+  PROBE_TIMEOUT_MS
+} from "./chunk-WPAQUMHC.js";
+
+// scripts/lane/lane-await.ts
+import { spawnSync } from "node:child_process";
+import { setTimeout as sleep } from "node:timers/promises";
+import { parseArgs } from "node:util";
+var RECONFIRM_MS = 15e3;
+var DEFAULT_POLL_MS = 5e3;
+var NEVER_APPEARED_TIMEOUT_MS = 6e5;
+var PROCESS_FOUND = 0;
+var PROCESS_NOT_FOUND = 1;
+var PGREP_COMMAND = "pgrep";
+function process_trace_default(issue) {
+  const pattern = lane_child_invocation.process_pattern(issue);
+  const result = spawnSync(PGREP_COMMAND, ["-f", pattern], {
+    encoding: "utf8",
+    timeout: PROBE_TIMEOUT_MS
+  });
+  process_tools.throw_if_missing(PGREP_COMMAND, result.error);
+  if (result.status === PROCESS_FOUND || lane_handoff.is_ship_running(issue, process.cwd())) {
+    return PROCESS_ALIVE;
+  }
+  return result.status === PROCESS_NOT_FOUND ? PROCESS_NONE : PROCESS_UNKNOWN;
+}
+function is_process_running_default(issue) {
+  return process_trace_default(issue) === PROCESS_ALIVE;
+}
+async function other_process_trace(issue) {
+  if (lane_handoff.is_ship_running(issue, process.cwd())) return PROCESS_ALIVE;
+  const rows = await lane_process_table.read_table();
+  if (!rows?.some((row) => row.pid === process.pid)) return PROCESS_UNKNOWN;
+  return lane_reap.is_child_running(issue, lane_process_table.probes_of(rows)) ? PROCESS_ALIVE : PROCESS_NONE;
+}
+function is_shipped_default(issue, since_ms) {
+  return lane_handoff.is_ship_succeeded(issue, process.cwd(), since_ms);
+}
+async function is_settled_default(issue) {
+  return await run_liveness.read_child_settled(issue) === true;
+}
+function read_await_args(rest) {
+  try {
+    return parseArgs({
+      args: [...rest],
+      allowPositionals: true,
+      strict: true,
+      options: { owner: { type: "string" } }
+    });
+  } catch {
+    return void 0;
+  }
+}
+function is_valid(raw) {
+  const { owner } = raw.values;
+  const numbers = owner === void 0 ? raw.positionals : [...raw.positionals, owner];
+  return raw.positionals.length > 0 && numbers.every((value) => issue_number_shape.is_issue_number(value));
+}
+function parse_arguments(rest) {
+  const raw = read_await_args(rest);
+  if (raw === void 0 || !is_valid(raw)) return void 0;
+  const { owner } = raw.values;
+  return {
+    issues: raw.positionals,
+    owner: owner === void 0 ? agent_session_environment.own_session_pid() : Number(owner)
+  };
+}
+function make_initial_state(is_settled) {
+  return { appeared: false, disappeared_at: void 0, first_polled_at: void 0, is_settled };
+}
+async function make_states(issues, is_settled) {
+  const settled = await Promise.all(issues.map(async (issue) => await is_settled(issue)));
+  return new Map(issues.map((issue, index) => [issue, make_initial_state(settled[index] === true)]));
+}
+function resolve_timing(options) {
+  return {
+    poll_ms: options.poll_ms ?? DEFAULT_POLL_MS,
+    reconfirm_ms: options.reconfirm_ms ?? RECONFIRM_MS,
+    never_appeared_timeout_ms: options.never_appeared_timeout_ms ?? NEVER_APPEARED_TIMEOUT_MS
+  };
+}
+function resolve_probes(options) {
+  return {
+    is_running: options.is_running ?? is_process_running_default,
+    is_shipped: options.is_shipped ?? is_shipped_default
+  };
+}
+function resolve_options(options) {
+  return {
+    ...resolve_probes(options),
+    is_settled: options.is_settled ?? is_settled_default,
+    now: options.now ?? Date.now,
+    sleep: options.sleep ?? sleep,
+    ...resolve_timing(options)
+  };
+}
+function update_liveness(state, is_live, now_ms) {
+  if (!is_live) return;
+  if (!state.appeared || state.disappeared_at !== void 0) state.alive_since = now_ms;
+  state.appeared = true;
+  state.disappeared_at = void 0;
+}
+function check_not_appeared(issue, state, now_ms, timeout_ms) {
+  if (state.is_settled === true) return issue;
+  state.first_polled_at ??= now_ms;
+  const elapsed_ms = now_ms - state.first_polled_at;
+  if (elapsed_ms >= timeout_ms) {
+    throw new Error(
+      `lane child ${issue} never appeared within ${String(timeout_ms / MS_PER_SECOND)}s`
+    );
+  }
+  return void 0;
+}
+function is_own_ship_done(issue, state, config) {
+  const { alive_since } = state;
+  return alive_since !== void 0 && config.is_shipped?.(issue, alive_since) === true;
+}
+function check_gone(issue, state, now_ms, config) {
+  if (is_own_ship_done(issue, state, config)) return issue;
+  state.disappeared_at ??= now_ms;
+  return now_ms - state.disappeared_at >= config.reconfirm_ms ? issue : void 0;
+}
+function check_issue(issue, state, now_ms, config) {
+  const is_live = config.is_running(issue);
+  update_liveness(state, is_live, now_ms);
+  if (is_live) return void 0;
+  if (!state.appeared) {
+    return check_not_appeared(issue, state, now_ms, config.never_appeared_timeout_ms);
+  }
+  return check_gone(issue, state, now_ms, config);
+}
+function check_any(states, now_ms, config) {
+  for (const [issue, state] of states) {
+    const result = check_issue(issue, state, now_ms, config);
+    if (result !== void 0) return result;
+  }
+  return void 0;
+}
+async function wait_for_any(issues, options = {}) {
+  const config = resolve_options(options);
+  const states = await make_states(issues, config.is_settled);
+  return await poll.wait_for(() => check_any(states, config.now(), config), {
+    interval_ms: config.poll_ms,
+    sleeper: config.sleep
+  });
+}
+var lane_await = {
+  NEVER_APPEARED_TIMEOUT_MS,
+  RECONFIRM_MS,
+  check_issue,
+  is_process_running_default,
+  is_shipped_default,
+  parse_arguments,
+  other_process_trace,
+  process_trace_default,
+  wait_for_any
+};
+
+export {
+  lane_await
+};

package/dist/commands/chunk-5YTEMF4O.js

@@ -0,0 +1,110 @@
+import {
+  git_gh_etag_read
+} from "./chunk-IPS7EBE5.js";
+import {
+  shared_cache
+} from "./chunk-WXLW7S4M.js";
+import {
+  author_fields_schema
+} from "./chunk-34DND4BA.js";
+import {
+  git_gh_api_path
+} from "./chunk-RDRN56E4.js";
+import {
+  parse_json
+} from "./chunk-43DU7DYZ.js";
+
+// scripts/gh/gh-permission-cache.ts
+import { z } from "zod";
+var MS_KEPT = 36e5;
+var WRITERS_CACHE = { prefix: "josh-write-permission-", ttl_ms: MS_KEPT };
+var entries_schema = z.array(z.object({ login: z.string(), read_at: z.number() }));
+function fresh_entries(repo, now_ms) {
+  const entries = shared_cache.read(WRITERS_CACHE, repo, entries_schema, now_ms) ?? [];
+  return entries.filter((entry) => entry.read_at <= now_ms && now_ms - entry.read_at < MS_KEPT);
+}
+function is_writer(repo, login, now_ms = Date.now()) {
+  return fresh_entries(repo, now_ms).some((entry) => entry.login === login);
+}
+function remember_writer(repo, login, now_ms = Date.now()) {
+  const fresh = fresh_entries(repo, now_ms);
+  if (fresh.some((entry) => entry.login === login)) return;
+  shared_cache.write(WRITERS_CACHE, repo, [...fresh, { login, read_at: now_ms }], now_ms);
+}
+var gh_permission_cache = { WRITERS_CACHE, is_writer, remember_writer };
+
+// scripts/gh/gh-author-association.ts
+import { z as z2 } from "zod";
+var OWNER = "OWNER";
+var ASKED_ASSOCIATIONS = /* @__PURE__ */ new Set(["MEMBER", "COLLABORATOR"]);
+var WRITE_ROLES = /* @__PURE__ */ new Set(["admin", "maintain", "write"]);
+var LOGIN_PATTERN = /^[\da-z](?:[\w-]*[\da-z])?$/iu;
+var TRUSTED_LIST = "OWNER, or MEMBER / COLLABORATOR with write access";
+var AUTHOR_FIELDS = "author_association,user";
+var permission_schema = z2.looseObject({
+  permission: z2.string().nullish(),
+  role_name: z2.string().nullish()
+});
+var answers = /* @__PURE__ */ new Map();
+function permission_path(login, repo) {
+  return `${git_gh_api_path.repo_api_path(repo)}/collaborators/${login}/permission`;
+}
+function has_write_role(raw) {
+  const parsed = parse_json.parse_json_object_or_undefined(raw, permission_schema);
+  const roles = [parsed?.role_name, parsed?.permission];
+  return roles.some((role) => typeof role === "string" && WRITE_ROLES.has(role));
+}
+async function read_permission(asked) {
+  try {
+    const path = permission_path(asked.login, asked.repo);
+    const raw = await git_gh_etag_read.read(path, asked.timeout_ms);
+    return has_write_role(raw);
+  } catch {
+    return void 0;
+  }
+}
+async function ask_permission(asked) {
+  if (asked.is_shared !== true) return await read_permission(asked);
+  const repo = asked.repo ?? "";
+  if (gh_permission_cache.is_writer(repo, asked.login)) return true;
+  const has_write = await read_permission(asked);
+  if (has_write === true) gh_permission_cache.remember_writer(repo, asked.login);
+  return has_write;
+}
+async function can_write(author) {
+  const key = `${author.repo ?? ""} ${author.login}`;
+  const asked = answers.get(key) ?? ask_permission(author);
+  answers.set(key, asked);
+  const has_write = await asked;
+  if (has_write === void 0 && answers.get(key) === asked) answers.delete(key);
+  return has_write;
+}
+function is_user_login(login) {
+  return login !== void 0 && LOGIN_PATTERN.test(login);
+}
+function is_asked(author) {
+  return ASKED_ASSOCIATIONS.has(author.association ?? "") && is_user_login(author.login);
+}
+async function trust_of(author) {
+  if (author.association === OWNER) return true;
+  if (author.login === void 0 || !is_asked(author)) return false;
+  return await can_write({ ...author, login: author.login });
+}
+async function is_trusted(author) {
+  return await trust_of(author) === true;
+}
+function author_of(row, timeout_ms) {
+  return { login: row.user?.login, association: row.author_association, timeout_ms };
+}
+var gh_author_association = {
+  AUTHOR_FIELDS,
+  TRUSTED_LIST,
+  author_fields_schema,
+  author_of,
+  is_trusted,
+  trust_of
+};
+
+export {
+  gh_author_association
+};

package/dist/commands/chunk-62NYXZCC.js

@@ -0,0 +1,241 @@
+import {
+  review_stamps
+} from "./chunk-XSKJAG72.js";
+import {
+  stamp_file
+} from "./chunk-VLN6TSPJ.js";
+import {
+  PACKAGE_JSON
+} from "./chunk-WB4T3VY2.js";
+import {
+  git_command
+} from "./chunk-IXZZSST7.js";
+
+// scripts/review/review-code-tree.ts
+import { readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import path from "node:path";
+
+// scripts/review/comment-ranges.ts
+var COMMENT_OPENINGS = ["//", "/*"];
+var MARK = "\uE000";
+var LINE_BREAK = "\n";
+var SEPARATOR = " ";
+var RAW_BLOCK = /<(?<tag>script|style)\b[^>]*>(?<body>[\s\S]*?)<\/\k<tag>>/gu;
+var SCRIPT_TAG = "script";
+var MARKUP_COMMENT = /<!--[\s\S]*?-->/gu;
+var VIRTUAL_FILE_NAME = "fix-delta.ts";
+var DIRECTIVE_MARKERS = [
+  "///",
+  "@ts-",
+  "eslint",
+  "jshint",
+  "global ",
+  "globals ",
+  "prettier-ignore",
+  "svelte-ignore",
+  "cspell",
+  "v8 ignore",
+  "c8 ignore",
+  "istanbul ignore",
+  "__PURE__",
+  "__NO_SIDE_EFFECTS__",
+  "@vite-ignore",
+  "webpack",
+  "@jsx",
+  "@vitest-environment"
+];
+var JSDOC_TYPE_TAG = /@(?:type|typedef|param|returns?|template|satisfies|import|callback|overload|enum|this)\b/u;
+var JSDOC_TYPE_EXPRESSION = /@\w+\s*\{/u;
+function is_directive(text, range) {
+  const comment = text.slice(range[0], range[1]);
+  if (JSDOC_TYPE_TAG.test(comment) || JSDOC_TYPE_EXPRESSION.test(comment)) return true;
+  return DIRECTIVE_MARKERS.some((marker) => comment.includes(marker));
+}
+function is_comment(text, range) {
+  return COMMENT_OPENINGS.some((opening) => text.startsWith(opening, range[0]));
+}
+function trivia_at(api, text, position) {
+  const found = [
+    ...api.getLeadingCommentRanges(text, position) ?? [],
+    ...api.getTrailingCommentRanges(text, position) ?? []
+  ];
+  return found.map((range) => [range.pos, range.end]);
+}
+function collect(api, node, source, into) {
+  if (api.isJSDoc(node)) return;
+  into.push(...trivia_at(api, source.text, node.pos));
+  for (const child of node.getChildren(source)) collect(api, child, source, into);
+}
+function script_ranges(api, text) {
+  const source = api.createSourceFile(VIRTUAL_FILE_NAME, text, api.ScriptTarget.Latest, false);
+  const diagnostics = source.parseDiagnostics;
+  if (diagnostics === void 0 || diagnostics.length > 0) return void 0;
+  const ranges = [];
+  collect(api, source, source, ranges);
+  return ranges.filter((range) => is_comment(text, range));
+}
+function shifted(ranges, offset) {
+  return ranges.map((range) => [range[0] + offset, range[1] + offset]);
+}
+function is_inside(blocks, index) {
+  return blocks.some((block) => index >= block[0] && index < block[1]);
+}
+function markup_ranges(text, blocks) {
+  return [...text.matchAll(MARKUP_COMMENT)].filter((match) => !is_inside(blocks, match.index)).map((match) => [match.index, match.index + match[0].length]);
+}
+function block_ranges(api, match) {
+  if (match.groups?.["tag"] !== SCRIPT_TAG) return [];
+  const body = match.groups["body"] ?? "";
+  const ranges = script_ranges(api, body);
+  return ranges && shifted(ranges, match.index + match[0].indexOf(body));
+}
+function svelte_ranges(api, text) {
+  const matches = [...text.matchAll(RAW_BLOCK)];
+  const scripts = matches.map((match) => block_ranges(api, match));
+  if (scripts.includes(void 0)) return void 0;
+  const blocks = matches.map((match) => [match.index, match.index + match[0].length]);
+  return [...scripts.flatMap((ranges) => ranges ?? []), ...markup_ranges(text, blocks)];
+}
+function mark_for(text, start, end) {
+  return text.slice(start, end).includes(LINE_BREAK) ? `${MARK}${LINE_BREAK}${MARK}` : MARK;
+}
+function marked(text, ranges) {
+  const ordered = ranges.toSorted((left, right) => left[0] - right[0]);
+  let result = "";
+  let cursor = 0;
+  for (const [start, end] of ordered) {
+    if (start < cursor) continue;
+    result += `${text.slice(cursor, start)}${mark_for(text, start, end)}`;
+    cursor = end;
+  }
+  return `${result}${text.slice(cursor)}`;
+}
+function normalized_line(line) {
+  if (!line.includes(MARK)) return [line];
+  const indentation = line.slice(0, line.length - line.trimStart().length);
+  const words = line.split(MARK).map((part) => part.trim()).filter((part) => part !== "");
+  return words.length === 0 ? [] : [`${indentation}${words.join(SEPARATOR)}`];
+}
+function without(text, ranges) {
+  return marked(text, ranges).split(LINE_BREAK).flatMap((line) => normalized_line(line)).join(LINE_BREAK);
+}
+function strip(api, text, is_svelte2) {
+  const ranges = is_svelte2 ? svelte_ranges(api, text) : script_ranges(api, text);
+  return ranges && without(
+    text,
+    ranges.filter((range) => !is_directive(text, range))
+  );
+}
+var comment_ranges = { strip };
+
+// scripts/review/import-specifiers.ts
+var VIRTUAL_FILE_NAME2 = "import-delta.ts";
+var SVELTE_EXTENSION = ".svelte";
+var EMPTY_SPECIFIER = "''";
+function specifier_ranges(api, text) {
+  const source = api.createSourceFile(VIRTUAL_FILE_NAME2, text, api.ScriptTarget.Latest, true);
+  return source.statements.filter((statement) => api.isImportDeclaration(statement)).filter((statement) => statement.importClause !== void 0).map((statement) => [statement.moduleSpecifier.getStart(source), statement.moduleSpecifier.end]);
+}
+function blank(api, text, relative) {
+  if (relative.endsWith(SVELTE_EXTENSION)) return text;
+  const ranges = specifier_ranges(api, text);
+  const starts = [0, ...ranges.map(([, end]) => end)];
+  return starts.map((start, index) => text.slice(start, ranges[index]?.[0] ?? text.length)).join(EMPTY_SPECIFIER);
+}
+var import_specifiers = { blank };
+
+// scripts/review/review-code-tree.ts
+var SCRIPT_EXTENSIONS = [".ts", ".js"];
+var SVELTE_EXTENSION2 = ".svelte";
+var EXCLUDED_PREFIX = ".claude/";
+var TYPESCRIPT_MODULE = "typescript";
+function is_svelte(relative) {
+  return relative.endsWith(SVELTE_EXTENSION2);
+}
+function is_source(relative) {
+  if (relative.startsWith(EXCLUDED_PREFIX)) return false;
+  return is_svelte(relative) || SCRIPT_EXTENSIONS.some((extension) => relative.endsWith(extension));
+}
+function load_typescript(root) {
+  try {
+    return createRequire(path.join(root, PACKAGE_JSON))(TYPESCRIPT_MODULE);
+  } catch {
+    return void 0;
+  }
+}
+function text_digest(api, text, relative) {
+  const code = comment_ranges.strip(api, text, is_svelte(relative));
+  return code === void 0 ? void 0 : stamp_file.digest(code);
+}
+function inert_digest(api) {
+  return (text, relative) => text_digest(api, import_specifiers.blank(api, text, relative), relative);
+}
+function code_digest(digest, root, relative) {
+  try {
+    return digest(readFileSync(path.join(root, relative), "utf8"), relative);
+  } catch {
+    return void 0;
+  }
+}
+async function base_digest(digest, base, relative) {
+  try {
+    const text = await git_command.show_file(`${base}:${relative}`);
+    return digest(`${text}
+`, relative);
+  } catch {
+    return void 0;
+  }
+}
+function digests_of(root, paths, digest) {
+  const entries = paths.filter((relative) => is_source(relative)).flatMap((relative) => {
+    const value = code_digest(digest, root, relative);
+    return value === void 0 ? [] : [[relative, value]];
+  });
+  return Object.fromEntries(entries);
+}
+function tree_of(root, paths, api = load_typescript(root)) {
+  if (api === void 0) return {};
+  return digests_of(root, paths, (text, relative) => text_digest(api, text, relative));
+}
+async function read(paths, root) {
+  return tree_of(root ?? await git_command.repository_root(), paths);
+}
+async function record(paths, base, target, root) {
+  try {
+    review_stamps.round_one_code_stamp.write(await read(paths, root), target, base);
+  } catch {
+    review_stamps.clear_round_one_code(target);
+  }
+}
+function comment_only(snapshot, tree, base, unmoved = []) {
+  if (snapshot === void 0 || base === void 0) return [];
+  const is_same_base = snapshot.base === base;
+  return Object.keys(snapshot.files).filter(
+    (relative) => snapshot.files[relative] === tree[relative] && (is_same_base || unmoved.includes(relative))
+  );
+}
+async function inert_since(base, paths, root, api) {
+  const checkout = root ?? await git_command.repository_root();
+  const typescript = api ?? load_typescript(checkout);
+  if (typescript === void 0) return [];
+  const digest = inert_digest(typescript);
+  const tree = digests_of(checkout, paths, digest);
+  const sources = Object.keys(tree);
+  const digests = await Promise.all(
+    sources.map(async (relative) => await base_digest(digest, base, relative))
+  );
+  return sources.filter((relative, index) => digests[index] === tree[relative]);
+}
+var review_code_tree = {
+  comment_only,
+  inert_since,
+  load_typescript,
+  read,
+  record,
+  tree_of
+};
+
+export {
+  review_code_tree
+};

package/dist/commands/chunk-6KUA7MRG.js

@@ -0,0 +1,64 @@
+import {
+  issue_watch
+} from "./chunk-3CJNQU7P.js";
+import {
+  review_attest
+} from "./chunk-URZ4RDC4.js";
+import {
+  session_cite
+} from "./chunk-22DVQCP6.js";
+import {
+  git_command
+} from "./chunk-IXZZSST7.js";
+
+// scripts/issue/issue-watch-gate.ts
+var EVERY_CALL_MS = 0;
+function ack_command(issue) {
+  return `pnpm josh issue:ack ${issue}`;
+}
+function unread_message(record) {
+  return [
+    `A person updated issue ${session_cite.issue(record.issue)} after this run read it, and the run has not taken the update in:`,
+    record.pending ?? "",
+    `Read it, compare it with the acceptance criteria, fix what it changes, then run \`${ack_command(record.issue)}\` to record that it was read.`
+  ].join("\n\n");
+}
+function review_message(record, briefed_at) {
+  return [
+    `Issue ${session_cite.issue(record.issue)} was updated after the review was briefed (taken in at ${record.acknowledged_at}, briefed at ${briefed_at}), so the review read the earlier specification.`,
+    "Re-run `/code-review` with a fresh `pnpm josh review:brief`, so the review reads the change against the updated issue."
+  ].join("\n");
+}
+async function polled(root) {
+  return await issue_watch.poll({ interval_ms: EVERY_CALL_MS }, root);
+}
+async function unread_refusal(root) {
+  const record = await polled(root);
+  return record?.pending === void 0 ? void 0 : unread_message(record);
+}
+async function review_refusal(root) {
+  const record = await polled(root);
+  if (record === void 0) return void 0;
+  if (record.pending !== void 0) return unread_message(record);
+  const pointer = review_attest.read_pointer(root);
+  if (pointer === void 0 || record.acknowledged_at <= pointer.taken_at) return void 0;
+  return review_message(record, pointer.taken_at);
+}
+async function review_refusal_here() {
+  return await review_refusal(await git_command.repository_root());
+}
+async function assert_read_here() {
+  const refusal = await unread_refusal(await git_command.repository_root());
+  if (refusal !== void 0) throw new Error(refusal);
+}
+var issue_watch_gate = {
+  assert_read_here,
+  review_refusal,
+  review_refusal_here,
+  unread_message,
+  unread_refusal
+};
+
+export {
+  issue_watch_gate
+};