@remogram/core 0.1.0-beta.3 → 0.1.0-beta.5

package/contracts/semantic-diff-facts.js

@@ -20,8 +20,16 @@ export const V1_READ_PLAN_COMMANDS = Object.freeze([
   'sync plan',
   'provider capabilities',
   'doctor',
+  'whoami',
+  'branch protection',
+  'cr files',
+  'cr comments',
+  'forge changes',
 ]);
 
+/** v1 write surface (Gitea cr open and status set in first slices). */
+export const V1_WRITE_COMMANDS = Object.freeze(['cr open', 'status set']);
+
 /**
  * Planned fact-inventory packet types (not emitted until wave 2+ commands ship).
  * All use schema_version 1 envelope discipline via forgePacket.
@@ -55,11 +63,18 @@ export const TRUSTED_NORMALIZED_BODY_FIELDS = Object.freeze({
   truncated: true,
   list_truncated: true,
   checks_truncated: true,
+  paths_truncated: true,
+  comments_truncated: true,
+  events_truncated: true,
+  slice_sort: true,
   entry_count: true,
   mergeability_confidence: true,
   write_support: true,
   diverged: true,
   auth_present: true,
+  can_write: true,
+  reused_existing: true,
+  idempotency_scan: true,
 });
 
 /**
@@ -74,6 +89,17 @@ export const FORGE_SOURCED_STRING_LEAVES = Object.freeze({
   merge_plan: ['blockers[].message', 'blockers[].context'],
   sync_plan: ['remote', 'local_sha', 'remote_sha', 'blockers[].message'],
   ref_inventory: ['refs[].name', 'refs[].sha', 'default_ref'],
+  change_request_opened: ['url', 'title', 'head', 'base'],
+  commit_status_set: ['sha', 'context', 'description', 'target_url'],
+  provider_identity: ['login'],
+  branch_protection: [
+    'branch_ref',
+    'required_status_contexts[]',
+    'protected_branch_rules[].name',
+  ],
+  cr_files: ['changed_paths[]'],
+  cr_comments: ['comments[].id', 'comments[].author', 'comments[].path', 'comments[].body'],
+  forge_changes: ['events[].title', 'events[].url', 'events[].head_sha'],
   cr_inventory_slice: [
     'entries[].url',
     'entries[].title',
@@ -88,7 +114,7 @@ export const FORGE_SOURCED_STRING_LEAVES = Object.freeze({
   ],
 });
 
-/** Keys that must never appear in remogram output (Topogram SDLC/workflow concepts). */
+/** Keys that must never appear in remogram output (external planning/SDLC workflow concepts). */
 export { FORBIDDEN_PACKET_KEYS };
 
 /**
@@ -108,6 +134,8 @@ export const FACT_INVENTORY_BODY_SHAPES = Object.freeze({
     /** true when list cap applied (entry_count > limit), not missing entries */
     truncated: 'boolean',
     list_truncated: 'boolean',
+    /** normalized slice sort preset applied to open-list resolution */
+    slice_sort: 'string',
     entries_skipped:
       'array<{ pr_number: number, error_code: pr_not_open | api_error | oversized_raw_output | ... }> optional',
     slice_ref: 'string optional',
@@ -116,7 +144,7 @@ export const FACT_INVENTORY_BODY_SHAPES = Object.freeze({
 
 /**
  * Build a fact-inventory packet body through the standard envelope gate.
- * Throws if body contains forbidden Topogram workflow keys.
+ * Throws if body contains forbidden workflow/planning-tool keys.
  */
 export function forgeFactInventoryPacket(type, context, body = {}, error = null) {
   if (!Object.values(FACT_INVENTORY_PACKET_TYPES).includes(type)) {

package/cr-comments.js

@@ -0,0 +1,93 @@
+import { sanitizeField } from './caps.js';
+
+export const MAX_CR_COMMENTS = 256;
+
+export function normalizeCrComment(raw) {
+  if (raw == null || typeof raw !== 'object') return null;
+  const id = raw.id ?? raw.comment_id;
+  if (id == null) return null;
+
+  const author =
+    sanitizeField(
+      raw.author ??
+        raw.user?.login ??
+        raw.user?.username ??
+        raw.user?.name ??
+        '',
+    ) || null;
+  const path =
+    raw.path != null && String(raw.path).trim() !== '' ? sanitizeField(raw.path) : null;
+  const lineRaw = raw.line ?? raw.original_line ?? raw.new_line;
+  const line =
+    lineRaw != null && Number.isFinite(Number(lineRaw)) ? Math.floor(Number(lineRaw)) : null;
+  const body = sanitizeField(raw.body ?? raw.note ?? '') ?? '';
+  const resolved = Boolean(raw.resolved ?? raw.is_resolved ?? false);
+
+  return {
+    id: sanitizeField(String(id)),
+    author,
+    path,
+    line,
+    body,
+    resolved,
+  };
+}
+
+export function buildCrCommentsBody({ pr_number, comments, comments_truncated, comment_count }) {
+  const list = Array.isArray(comments) ? comments : [];
+  const count = Number.isFinite(Number(comment_count))
+    ? Math.floor(Number(comment_count))
+    : list.length;
+  return {
+    pr_number: Math.floor(Number(pr_number)),
+    comments: list,
+    comments_truncated: Boolean(comments_truncated),
+    comment_count: count,
+  };
+}
+
+function buildCrCommentsFromNormalizedList(prNumber, all) {
+  const comment_count = all.length;
+  const capped = all.length > MAX_CR_COMMENTS;
+  const comments = all.slice(0, MAX_CR_COMMENTS);
+  return buildCrCommentsBody({
+    pr_number: prNumber,
+    comments,
+    comments_truncated: capped,
+    comment_count,
+  });
+}
+
+export function buildCrCommentsFromGiteaComments(prNumber, commentsArray) {
+  const all = [];
+  if (Array.isArray(commentsArray)) {
+    for (const item of commentsArray) {
+      const normalized = normalizeCrComment(item);
+      if (normalized) all.push(normalized);
+    }
+  }
+  return buildCrCommentsFromNormalizedList(prNumber, all);
+}
+
+export function buildCrCommentsFromGitLabDiscussions(prNumber, discussionsArray) {
+  const all = [];
+  if (Array.isArray(discussionsArray)) {
+    for (const discussion of discussionsArray) {
+      const notes = Array.isArray(discussion?.notes) ? discussion.notes : [];
+      for (const note of notes) {
+        if (note?.system === true) continue;
+        const position = note.position && typeof note.position === 'object' ? note.position : null;
+        const normalized = normalizeCrComment({
+          id: note.id,
+          author: note.author?.username ?? note.author?.name ?? '',
+          path: position?.new_path ?? position?.old_path ?? null,
+          line: position?.new_line ?? position?.old_line ?? null,
+          body: note.body ?? '',
+          resolved: note.resolved ?? false,
+        });
+        if (normalized) all.push(normalized);
+      }
+    }
+  }
+  return buildCrCommentsFromNormalizedList(prNumber, all);
+}

package/cr-files.js

@@ -0,0 +1,62 @@
+import { sanitizeField } from './caps.js';
+
+export const MAX_CR_FILES_PATHS = 256;
+
+function sanitizePathList(filesArray) {
+  if (!Array.isArray(filesArray)) return [];
+  const paths = [];
+  for (const file of filesArray) {
+    if (file == null || typeof file !== 'object') continue;
+    const sanitized = sanitizeField(file.filename);
+    if (sanitized) paths.push(sanitized);
+  }
+  return paths;
+}
+
+export function buildCrFilesBody({ pr_number, changed_paths, paths_truncated, path_count }) {
+  const paths = Array.isArray(changed_paths) ? changed_paths : [];
+  const count = Number.isFinite(Number(path_count)) ? Math.floor(Number(path_count)) : paths.length;
+  return {
+    pr_number: Math.floor(Number(pr_number)),
+    changed_paths: paths,
+    paths_truncated: Boolean(paths_truncated),
+    path_count: count,
+  };
+}
+
+export function buildCrFilesFromGiteaFiles(prNumber, filesArray) {
+  const allPaths = sanitizePathList(filesArray);
+  const path_count = allPaths.length;
+  const capped = allPaths.length > MAX_CR_FILES_PATHS;
+  const changed_paths = allPaths.slice(0, MAX_CR_FILES_PATHS);
+  return buildCrFilesBody({
+    pr_number: prNumber,
+    changed_paths,
+    paths_truncated: capped,
+    path_count,
+  });
+}
+
+export function buildCrFilesFromGitLabChanges(prNumber, changesArray) {
+  const paths = [];
+  const seen = new Set();
+  if (Array.isArray(changesArray)) {
+    for (const change of changesArray) {
+      if (change == null || typeof change !== 'object') continue;
+      const path = sanitizeField(change.new_path ?? change.old_path ?? '');
+      if (path && !seen.has(path)) {
+        seen.add(path);
+        paths.push(path);
+      }
+    }
+  }
+  const path_count = paths.length;
+  const capped = paths.length > MAX_CR_FILES_PATHS;
+  const changed_paths = paths.slice(0, MAX_CR_FILES_PATHS);
+  return buildCrFilesBody({
+    pr_number: prNumber,
+    changed_paths,
+    paths_truncated: capped,
+    path_count,
+  });
+}

package/cr-inventory.js

@@ -1,12 +1,18 @@
 import { sanitizeField } from './caps.js';
 import { ERROR_CODES, forgeError } from './contracts/errors.js';
 import { mergeBlockersFromFacts, isOpenPrState } from './merge-blockers.js';
+import {
+  DEFAULT_CR_INVENTORY_SLICE_SORT,
+  normalizeCrInventorySort,
+} from './open-pull-list.js';
 import { staleHeadDetails } from './pr-head-reconcile.js';
 
 export const DEFAULT_CR_INVENTORY_LIMIT = 50;
+/** Default bound when `--limit` is omitted (keeps forge ingest under cap on large repos). */
+export const DEFAULT_CR_INVENTORY_SAFE_LIMIT = 3;
 
 export function normalizeCrInventoryLimit(value) {
-  if (value == null || value === '') return DEFAULT_CR_INVENTORY_LIMIT;
+  if (value == null || value === '') return DEFAULT_CR_INVENTORY_SAFE_LIMIT;
   const n = Number(value);
   if (!Number.isInteger(n) || n <= 0) {
     throw Object.assign(new Error('Invalid cr inventory limit'), {
@@ -16,12 +22,11 @@ export function normalizeCrInventoryLimit(value) {
   return n;
 }
 
-async function resolveOpenPullList(provider, ctx, limit) {
-  const listOpts = { limit };
+async function resolveOpenPullList(provider, ctx, entryLimit, sliceSort) {
   if (typeof provider.listOpenPullsWithMeta === 'function') {
-    return provider.listOpenPullsWithMeta(ctx, listOpts);
+    return provider.listOpenPullsWithMeta(ctx, { retain_max: entryLimit, sort: sliceSort });
   }
-  const numbers = await provider.listOpenPulls(ctx, listOpts);
+  const numbers = await provider.listOpenPulls(ctx, {});
   return { numbers, list_truncated: false };
 }
 
@@ -71,16 +76,17 @@ export function buildCrInventoryEntry(ctx, view, checks) {
  * Aggregate open change requests into a semantic-diff-oriented inventory slice.
  * @param {object} ctx forge context
  * @param {object} provider must expose listOpenPulls, prView, prChecks
- * @param {{ slice_ref?: string, limit?: number }} [opts]
+ * @param {{ slice_ref?: string, limit?: number, sort?: string }} [opts]
  */
 export async function crInventory(ctx, provider, opts = {}) {
   const limit = normalizeCrInventoryLimit(opts.limit);
-  const { numbers, list_truncated: listTruncated } = await resolveOpenPullList(
-    provider,
-    ctx,
-    limit,
-  );
-  const entryCount = numbers.length;
+  const sliceSort = normalizeCrInventorySort(opts.sort);
+  const {
+    numbers,
+    list_truncated: listTruncated,
+    entry_count: providerEntryCount,
+  } = await resolveOpenPullList(provider, ctx, limit, sliceSort);
+  const entryCount = providerEntryCount ?? numbers.length;
   const selected = numbers.slice(0, limit);
   const entries = [];
   const entries_skipped = [];
@@ -106,6 +112,7 @@ export async function crInventory(ctx, provider, opts = {}) {
     entry_count: entryCount,
     truncated: entryCount > selected.length,
     list_truncated: listTruncated,
+    slice_sort: sliceSort ?? DEFAULT_CR_INVENTORY_SLICE_SORT,
     ...(opts.slice_ref ? { slice_ref: sanitizeField(opts.slice_ref) } : {}),
   };
 }

package/cr-open.js

@@ -0,0 +1,33 @@
+import { sanitizeField, sanitizeUrl } from './caps.js';
+import { ERROR_CODES, forgeError } from './contracts/errors.js';
+
+/** Normalize Gitea pull create response into change_request_opened body fields. */
+export function buildChangeRequestOpenedBody(
+  pull,
+  { head, base, title },
+  { reusedExisting = false } = {},
+) {
+  const prNumber = Number(pull?.number);
+  if (!Number.isInteger(prNumber) || prNumber <= 0) {
+    throw Object.assign(new Error('Provider returned invalid pull number'), {
+      forgeError: forgeError(
+        ERROR_CODES.UNPARSEABLE_PROVIDER_OUTPUT,
+        'Provider returned invalid pull number',
+      ),
+    });
+  }
+  const resolvedTitle = reusedExisting
+    ? sanitizeField(pull?.title ?? title)
+    : sanitizeField(title ?? pull?.title);
+  const body = {
+    pr_number: prNumber,
+    url: sanitizeUrl(pull.html_url ?? pull.url),
+    head: sanitizeField(head),
+    base: sanitizeField(base),
+    title: resolvedTitle,
+  };
+  if (reusedExisting) {
+    body.reused_existing = true;
+  }
+  return body;
+}

package/forge-changes.js

@@ -0,0 +1,181 @@
+import { sanitizeField, sanitizeUrl } from './caps.js';
+import { ERROR_CODES, forgeError } from './contracts/errors.js';
+
+export const MAX_FORGE_CHANGES_EVENTS = 256;
+
+export const FORGE_CHANGE_EVENT_KINDS = Object.freeze({
+  PR_OPENED: 'pr_opened',
+  PR_CLOSED: 'pr_closed',
+  PR_MERGED: 'pr_merged',
+  HEAD_SHA_MOVED: 'head_sha_moved',
+  CHECKS_CONCLUSION_OBSERVED: 'checks_conclusion_observed',
+});
+
+export function parseSinceObservedAt(raw) {
+  if (raw == null || String(raw).trim() === '') {
+    throw Object.assign(new Error('--since required'), {
+      forgeError: forgeError(ERROR_CODES.INVALID_ARGS, '--since required for forge changes'),
+    });
+  }
+  const ms = Date.parse(String(raw));
+  if (!Number.isFinite(ms)) {
+    throw Object.assign(new Error('Invalid --since'), {
+      forgeError: forgeError(
+        ERROR_CODES.INVALID_ARGS,
+        '--since must be a parseable ISO-8601 timestamp',
+      ),
+    });
+  }
+  return new Date(ms).toISOString();
+}
+
+function timestampMs(value) {
+  const ms = Date.parse(value ?? '');
+  return Number.isFinite(ms) ? ms : null;
+}
+
+function isAtOrAfter(value, sinceIso) {
+  const ms = timestampMs(value);
+  const sinceMs = timestampMs(sinceIso);
+  if (ms == null || sinceMs == null) return false;
+  return ms >= sinceMs;
+}
+
+function isBefore(value, sinceIso) {
+  const ms = timestampMs(value);
+  const sinceMs = timestampMs(sinceIso);
+  if (ms == null || sinceMs == null) return false;
+  return ms < sinceMs;
+}
+
+function normalizePrState(state) {
+  const normalized = String(state ?? '').toLowerCase();
+  if (normalized === 'open') return 'open';
+  if (normalized === 'closed') return 'closed';
+  return 'unknown';
+}
+
+function normalizeIsoTimestamp(value) {
+  const ms = timestampMs(value);
+  return ms == null ? null : new Date(ms).toISOString();
+}
+
+function baseEventFields(pull) {
+  return {
+    pr_number: Math.floor(Number(pull.number)),
+    title: sanitizeField(pull.title ?? '') || null,
+    url: sanitizeUrl(pull.html_url ?? pull.url) || null,
+  };
+}
+
+export function buildChecksConclusionObservedEvent(prNumber, checksBody) {
+  return {
+    kind: FORGE_CHANGE_EVENT_KINDS.CHECKS_CONCLUSION_OBSERVED,
+    pr_number: Math.floor(Number(prNumber)),
+    head_sha: sanitizeField(checksBody?.head_sha ?? '') || null,
+    check_conclusion: sanitizeField(checksBody?.check_conclusion ?? '') || 'unknown',
+    checks_truncated: Boolean(checksBody?.checks_truncated ?? false),
+  };
+}
+
+export function buildForgeChangesBody({
+  since,
+  events,
+  events_truncated,
+  event_count,
+  since_kind = 'observed_at',
+}) {
+  const list = Array.isArray(events) ? events : [];
+  const count = Number.isFinite(Number(event_count))
+    ? Math.floor(Number(event_count))
+    : list.length;
+  return {
+    since,
+    since_kind,
+    events: list,
+    events_truncated: Boolean(events_truncated),
+    event_count: count,
+  };
+}
+
+function capForgeChangeEvents(allEvents, sinceIso, { listTruncated = false } = {}) {
+  const event_count = allEvents.length;
+  const capped = allEvents.length > MAX_FORGE_CHANGES_EVENTS;
+  return buildForgeChangesBody({
+    since: sinceIso,
+    events: allEvents.slice(0, MAX_FORGE_CHANGES_EVENTS),
+    events_truncated: capped || listTruncated,
+    event_count,
+  });
+}
+
+export function appendForgeChangeEvents(body, additionalEvents, { listTruncated = false } = {}) {
+  const merged = [...(body.events ?? []), ...(Array.isArray(additionalEvents) ? additionalEvents : [])];
+  return capForgeChangeEvents(merged, body.since, {
+    listTruncated: listTruncated || body.events_truncated,
+  });
+}
+
+export function buildForgeChangesFromGiteaPulls(sinceIso, pullsArray, opts = {}) {
+  const since = parseSinceObservedAt(sinceIso);
+  const events = [];
+  if (Array.isArray(pullsArray)) {
+    for (const pull of pullsArray) {
+      if (pull == null || pull.number == null) continue;
+      const state = normalizePrState(pull.state);
+      const base = baseEventFields(pull);
+      const createdAt = pull.created_at;
+      const updatedAt = pull.updated_at;
+      const closedAt = pull.closed_at;
+      const mergedAt = pull.merged_at;
+      const mergedInWindow = isAtOrAfter(mergedAt, since);
+
+      if (isAtOrAfter(createdAt, since)) {
+        events.push({
+          kind: FORGE_CHANGE_EVENT_KINDS.PR_OPENED,
+          ...base,
+          state,
+          opened_at: normalizeIsoTimestamp(createdAt),
+        });
+      }
+
+      if (mergedInWindow) {
+        events.push({
+          kind: FORGE_CHANGE_EVENT_KINDS.PR_MERGED,
+          ...base,
+          state: 'closed',
+          merged_at: normalizeIsoTimestamp(mergedAt),
+        });
+      }
+
+      const closedNotMerged =
+        state === 'closed' && (mergedAt == null || String(mergedAt).trim() === '');
+      const closedInWindow =
+        isAtOrAfter(closedAt, since) ||
+        (closedAt == null && closedNotMerged && isAtOrAfter(updatedAt, since));
+      if (!mergedInWindow && closedNotMerged && closedInWindow) {
+        events.push({
+          kind: FORGE_CHANGE_EVENT_KINDS.PR_CLOSED,
+          ...base,
+          state: 'closed',
+          closed_at: normalizeIsoTimestamp(closedAt ?? updatedAt),
+        });
+      }
+
+      if (
+        state === 'open' &&
+        isAtOrAfter(updatedAt, since) &&
+        isBefore(createdAt, since)
+      ) {
+        events.push({
+          kind: FORGE_CHANGE_EVENT_KINDS.HEAD_SHA_MOVED,
+          ...base,
+          state: 'open',
+          head_sha: sanitizeField(pull.head?.sha ?? '') || null,
+          updated_at: normalizeIsoTimestamp(updatedAt),
+        });
+      }
+    }
+  }
+  return capForgeChangeEvents(events, since, { listTruncated: Boolean(opts.listTruncated) });
+}

package/git-local.js

@@ -43,3 +43,15 @@ export function gitAheadBehind(cwd, base, head) {
     return { ahead_by: null, behind_by: null };
   }
 }
+
+export function gitDiffNameOnly(cwd, base, head) {
+  assertGitRef(base, 'base');
+  assertGitRef(head, 'head');
+  try {
+    const out = gitExec(cwd, ['diff', '--name-only', base, head]);
+    if (!out) return [];
+    return out.split('\n').filter(Boolean);
+  } catch {
+    return null;
+  }
+}

package/index.js

@@ -16,6 +16,10 @@ export {
   allObserverEligibleCommands,
 } from './contracts/observer-fact-inventory.js';
 export { ERROR_CODES, forgeError } from './contracts/errors.js';
+export {
+  FORGE_ERROR_FIELD_ALLOWLIST,
+  normalizeForgeErrorFields,
+} from './contracts/forge-error-fields.js';
 export {
   capText,
   sanitizeField,
@@ -26,9 +30,14 @@ export {
   FORGE_INGEST_MAX_BYTES_ENV,
   DEFAULT_CHECK_STATUS_PAGE_SIZE,
   MAX_CHECK_STATUS_PAGES,
+  DEFAULT_OPEN_PULL_LIST_PAGE_SIZE,
+  MAX_OPEN_PULL_IDEMPOTENCY_PAGES,
   getEffectiveIngestMaxBytes,
   forgeIngestCapabilityFacts,
   checkPaginationCapabilityFacts,
+  idempotencyScanCapabilityFacts,
+  statusSetIdempotencyScanCapabilityFacts,
+  openPullListCapabilityFacts,
 } from './caps.js';
 export {
   paginateCheckStatusPages,
@@ -39,10 +48,103 @@ export {
   withLimitParam,
 } from './check-pagination.js';
 export { assertGitRef, assertGitRemote } from './git-args.js';
-export { gitRevParse, gitCurrentBranch, gitAheadBehind, gitRepoRoot } from './git-local.js';
+export { gitRevParse, gitCurrentBranch, gitAheadBehind, gitRepoRoot, gitDiffNameOnly } from './git-local.js';
 export { buildRefInventoryBody, refsInventory } from './ref-inventory.js';
-export { buildCrInventoryEntry, buildHeadReconcile, crInventory, DEFAULT_CR_INVENTORY_LIMIT, normalizeCrInventoryLimit } from './cr-inventory.js';
+export { buildCrInventoryEntry, buildHeadReconcile, crInventory, DEFAULT_CR_INVENTORY_LIMIT, DEFAULT_CR_INVENTORY_SAFE_LIMIT, normalizeCrInventoryLimit } from './cr-inventory.js';
+export {
+  CR_INVENTORY_SLICE_SORTS,
+  DEFAULT_CR_INVENTORY_SLICE_SORT,
+  normalizeCrInventorySort,
+  parseTotalCountHeader,
+  isCrInventoryFastPathEligible,
+  forgeOrderAuthoritative,
+  validateFastPathPageLength,
+  isNumberSortFastPathEligible,
+  resolvePaginatedEntryCount,
+  resolveListTruncatedWithTrustedTotal,
+  isRecentCreatedFastPathEligible,
+  giteaRecentCreatedTailPage,
+  isNumberSortFullCollectRequired,
+  prepareGiteaOpenPullPageItems,
+  orderOpenPullNumbers,
+  buildOpenPullListMeta,
+  giteaOpenPullSortQuery,
+  gitlabOpenPullSortQuery,
+  githubOpenPullSortQuery,
+  appendSortQuery,
+} from './open-pull-list.js';
+export { buildChangeRequestOpenedBody } from './cr-open.js';
+export {
+  STATUS_SET_STATES,
+  assertCommitSha,
+  normalizeStatusSetState,
+  parseStatusSetArgs,
+  buildCommitStatusSetBody,
+} from './status-set.js';
+export {
+  buildProviderIdentityBody,
+  buildProviderIdentityFromGiteaUser,
+  parseGitHubOAuthScopes,
+  githubCanWriteFromScopes,
+  buildProviderIdentityFromGitHubUser,
+  normalizeGitLabCanWrite,
+  parseGitLabPatSelfSignals,
+  buildProviderIdentityFromGitLabUser,
+  normalizeGiteaCanWrite,
+  unimplementedTokenScopeSignal,
+  unimplementedTokenExpirySignal,
+} from './whoami.js';
+export {
+  buildBranchProtectionBody,
+  buildBranchProtectionFromGiteaProtection,
+  buildBranchProtectionFromGitHubProtection,
+  buildBranchProtectionFromGitLabProtection,
+  unimplementedApprovalsRequiredSignal,
+  MAX_BRANCH_PROTECTION_STATUS_CONTEXTS,
+  MAX_BRANCH_PROTECTION_RULES,
+} from './branch-protection.js';
+export {
+  buildCrFilesBody,
+  buildCrFilesFromGiteaFiles,
+  buildCrFilesFromGitLabChanges,
+  MAX_CR_FILES_PATHS,
+} from './cr-files.js';
+export {
+  buildCrCommentsBody,
+  buildCrCommentsFromGiteaComments,
+  buildCrCommentsFromGitLabDiscussions,
+  normalizeCrComment,
+  MAX_CR_COMMENTS,
+} from './cr-comments.js';
+export {
+  parseSinceObservedAt,
+  buildForgeChangesBody,
+  buildForgeChangesFromGiteaPulls,
+  buildChecksConclusionObservedEvent,
+  appendForgeChangeEvents,
+  MAX_FORGE_CHANGES_EVENTS,
+  FORGE_CHANGE_EVENT_KINDS,
+} from './forge-changes.js';
+export {
+  WRITE_COMMAND_IDS,
+  CONFIGURED_WRITE_COMMANDS,
+  writeCommandSchema,
+  assertWriteCommandConfigured,
+  writeNotConfiguredMessage,
+  isWriteCommandConfigured,
+} from './write-config.js';
 export { mergeBlockersFromFacts, isOpenPrState } from './merge-blockers.js';
+export {
+  resolveMergePlanPathScope,
+  buildMergePlanBody,
+  buildMergePlanBodyFromFacts,
+} from './merge-plan.js';
+export {
+  matchPathAllowlist,
+  isPathAllowed,
+  pathsOutsideAllowlist,
+  allPathsAllowed,
+} from './path-allowlist.js';
 export {
   localHeadShaForPr,
   staleHeadDetails,