@remogram/core 0.1.0-beta.6 → 0.1.0-beta.9

package/auth-classes.js

@@ -18,12 +18,14 @@ export const API_PROVIDER_COMMAND_AUTH = {
   merge_plan: AUTH_CLASS.TOKEN_REQUIRED,
   sync_plan: AUTH_CLASS.GIT_ONLY,
   cr_open: AUTH_CLASS.TOKEN_REQUIRED,
+  issue_open: AUTH_CLASS.TOKEN_REQUIRED,
   status_set: AUTH_CLASS.TOKEN_REQUIRED,
   whoami: AUTH_CLASS.TOKEN_REQUIRED,
   branch_protection: AUTH_CLASS.TOKEN_REQUIRED,
   cr_files: AUTH_CLASS.TOKEN_REQUIRED,
   cr_comments: AUTH_CLASS.TOKEN_REQUIRED,
   forge_changes: AUTH_CLASS.TOKEN_REQUIRED,
+  merge_execute: AUTH_CLASS.TOKEN_REQUIRED,
 };
 
 export function commandCapability(name, { implemented = true } = {}) {
@@ -36,20 +38,24 @@ export function commandCapability(name, { implemented = true } = {}) {
 
 export function apiProviderCommands({
   writeCommandsImplemented = false,
+  issueOpenImplemented = false,
   statusSetImplemented = false,
   branchProtectionImplemented = false,
   crFilesImplemented = false,
   crCommentsImplemented = false,
   forgeChangesImplemented = false,
+  mergeExecuteImplemented = false,
 } = {}) {
   return Object.keys(API_PROVIDER_COMMAND_AUTH).map((name) => {
     let implemented = true;
     if (name === 'cr_open') implemented = writeCommandsImplemented;
+    if (name === 'issue_open') implemented = issueOpenImplemented;
     if (name === 'status_set') implemented = statusSetImplemented;
     if (name === 'branch_protection') implemented = branchProtectionImplemented;
     if (name === 'cr_files') implemented = crFilesImplemented;
     if (name === 'cr_comments') implemented = crCommentsImplemented;
     if (name === 'forge_changes') implemented = forgeChangesImplemented;
+    if (name === 'merge_execute') implemented = mergeExecuteImplemented;
     return commandCapability(name, { implemented });
   });
 }

package/change-request-merge-execute.js

@@ -0,0 +1,148 @@
+import { sanitizeField } from './caps.js';
+import { mergeBlockersFromFacts } from './merge-blockers.js';
+import { mergePolicyAuditFacts } from './merge-policy.js';
+
+const SHA40 = /^[0-9a-f]{40}$/i;
+
+export function mergeExecuteViewFacts(view) {
+  return {
+    sourceBranchRef: view.forge_source_branch_ref ?? view.head_ref ?? null,
+    sourceSha: view.forge_source_sha ?? view.head_sha ?? null,
+    targetSha: view.forge_target_sha ?? view.base_sha ?? null,
+  };
+}
+
+export function mergeExecuteChecksFacts(checks) {
+  return {
+    sourceSha: checks.forge_source_sha ?? checks.head_sha ?? null,
+  };
+}
+
+export function assertExpectedSha(value, flagName) {
+  const normalized = String(value ?? '').trim().toLowerCase();
+  if (!SHA40.test(normalized)) {
+    throw Object.assign(new Error(`Invalid ${flagName}`), {
+      invalidArgs: `${flagName} must be a 40-character git SHA`,
+    });
+  }
+  return normalized;
+}
+
+export function buildMergeExecuteBeforeFacts(
+  view,
+  checks,
+  mergePlanBody,
+  forgeHeadRefSha = null,
+  mergePolicy = null,
+) {
+  const viewFacts = mergeExecuteViewFacts(view);
+  const checksFacts = mergeExecuteChecksFacts(checks);
+  const audit = mergePolicyAuditFacts(mergePolicy);
+  return {
+    base_sha: viewFacts.targetSha ?? null,
+    head_sha: viewFacts.sourceSha ?? null,
+    checks_head_sha: checksFacts.sourceSha ?? null,
+    forge_head_ref_sha: forgeHeadRefSha ?? null,
+    mergeability: view.mergeability ?? 'unknown',
+    checks_conclusion: checks.check_conclusion ?? 'unknown',
+    checks_truncated: checks.checks_truncated === true,
+    merge_plan_blockers: Array.isArray(mergePlanBody.blockers) ? [...mergePlanBody.blockers] : [],
+    ...(audit ? { merge_policy: audit } : {}),
+  };
+}
+
+/**
+ * Collect merge-execute blockers before forge mutation.
+ * @returns {string[]} normalized blocker ids
+ */
+export function collectMergeExecuteBlockers(
+  view,
+  checks,
+  mergePlanBody,
+  expected,
+  { forgeHeadRefSha, mergePolicy = {} } = {},
+) {
+  const viewFacts = mergeExecuteViewFacts(view);
+  const checksFacts = mergeExecuteChecksFacts(checks);
+  const blockers = [];
+  const baseSha = viewFacts.targetSha ? String(viewFacts.targetSha).toLowerCase() : null;
+  const headSha = viewFacts.sourceSha ? String(viewFacts.sourceSha).toLowerCase() : null;
+
+  if (baseSha && expected.baseSha !== baseSha) blockers.push('base_sha_mismatch');
+  if (headSha && expected.headSha !== headSha) blockers.push('head_sha_mismatch');
+
+  const forgeHead = forgeHeadRefSha ? String(forgeHeadRefSha).toLowerCase() : null;
+  const checksHead = checksFacts.sourceSha ? String(checksFacts.sourceSha).toLowerCase() : null;
+  if (headSha && checksHead && headSha !== checksHead) blockers.push('checks_head_sha_mismatch');
+  if (headSha && forgeHead && headSha !== forgeHead) blockers.push('forge_pr_head_mismatch');
+  if (checksHead && forgeHead && checksHead !== forgeHead) blockers.push('checks_forge_head_mismatch');
+  if (forgeHead && forgeHead !== expected.headSha) blockers.push('head_ref_moved');
+
+  const planBlockers = mergeBlockersFromFacts(view, checks, {}, mergePolicy);
+  for (const blocker of planBlockers) {
+    if (!blockers.includes(blocker)) blockers.push(blocker);
+  }
+
+  if (view.mergeability !== 'clean') {
+    if (view.mergeability === 'conflicted' && !blockers.includes('merge_conflict')) {
+      blockers.push('merge_conflict');
+    } else if (view.mergeability !== 'conflicted' && !blockers.includes('mergeability_not_clean')) {
+      blockers.push('mergeability_not_clean');
+    }
+  }
+
+  return blockers;
+}
+
+export function buildCrMergeBlockedBody({
+  prNumber,
+  expected,
+  before,
+  blockers,
+}) {
+  return {
+    change_request: { number: prNumber },
+    expected: {
+      base_sha: expected.baseSha,
+      head_sha: expected.headSha,
+    },
+    before,
+    blockers,
+  };
+}
+
+export function buildCrMergedBody({
+  prNumber,
+  expected,
+  before,
+  merge,
+  after,
+}) {
+  return {
+    change_request: { number: prNumber, state: 'merged' },
+    expected: {
+      base_sha: expected.baseSha,
+      head_sha: expected.headSha,
+    },
+    before,
+    merge,
+    after,
+  };
+}
+
+export function buildMergeExecuteAfterFacts(view, mergeResult = {}) {
+  const viewFacts = mergeExecuteViewFacts(view);
+  return {
+    state: 'merged',
+    base_sha: mergeResult.base_sha ?? viewFacts.targetSha ?? null,
+    head_sha: viewFacts.sourceSha ?? null,
+  };
+}
+
+export function buildMergeExecuteMergeFacts(method, providerResult = {}) {
+  return {
+    method: sanitizeField(method),
+    commit_sha: providerResult.commit_sha ?? null,
+    provider_status: providerResult.provider_status ?? null,
+  };
+}

package/check-diagnostics.js

@@ -0,0 +1,92 @@
+import { sanitizeField } from './caps.js';
+
+function uniqueSorted(values) {
+  return [...new Set(values.filter(Boolean))].sort((a, b) => a.localeCompare(b));
+}
+
+/**
+ * @param {object} entry
+ * @param {{ headSha?: string | null, requiredContexts?: Set<string> }} opts
+ */
+export function enrichCheckStatus(entry, opts = {}) {
+  const headSha = opts.headSha ?? null;
+  const context = sanitizeField(entry?.context);
+  const rawSha = entry?.sha != null ? sanitizeField(entry.sha) : headSha;
+  const sha = rawSha || null;
+  const stale = Boolean(headSha && sha && sha !== headSha);
+  const required = context ? opts.requiredContexts?.has(context) === true : false;
+  return {
+    context,
+    state: entry?.state ?? 'unknown',
+    ...(sha ? { sha } : {}),
+    required,
+    source: sanitizeField(entry?.source) || 'commit_status',
+    ...(entry?.target_url ? { target_url: sanitizeField(entry.target_url) } : {}),
+    ...(entry?.description ? { description: sanitizeField(entry.description) } : {}),
+    ...(stale ? { stale: true } : {}),
+  };
+}
+
+/**
+ * @param {object[]} statuses
+ * @param {{ headSha?: string | null, requiredContexts?: string[] }} opts
+ */
+export function buildCheckDiagnostics(statuses, opts = {}) {
+  const headSha = opts.headSha ?? null;
+  const requiredContexts = uniqueSorted(
+    Array.isArray(opts.requiredContexts) ? opts.requiredContexts.map((c) => sanitizeField(c)) : [],
+  );
+  const requiredSet = new Set(requiredContexts);
+  const enriched = (Array.isArray(statuses) ? statuses : []).map((entry) =>
+    enrichCheckStatus(entry, { headSha, requiredContexts: requiredSet }),
+  );
+  const byContext = new Map();
+  for (const status of enriched) {
+    if (status.context) byContext.set(status.context, status);
+  }
+
+  const failed_contexts = [];
+  const pending_contexts = [];
+  const stale_contexts = [];
+  for (const status of enriched) {
+    if (!status.context) continue;
+    if (status.stale === true) stale_contexts.push(status.context);
+    if (status.state === 'failure') failed_contexts.push(status.context);
+    if (status.state === 'pending') pending_contexts.push(status.context);
+  }
+
+  const missing_required_contexts = [];
+  for (const context of requiredContexts) {
+    if (!byContext.has(context)) missing_required_contexts.push(context);
+  }
+
+  return {
+    statuses: enriched,
+    required_contexts: requiredContexts,
+    missing_required_contexts: uniqueSorted(missing_required_contexts),
+    failed_contexts: uniqueSorted(failed_contexts),
+    pending_contexts: uniqueSorted(pending_contexts),
+    stale_contexts: uniqueSorted(stale_contexts),
+  };
+}
+
+/**
+ * @param {{ forge_source_sha: string, check_conclusion: string, checks_truncated?: boolean, statuses?: object[], required_contexts?: string[] }} body
+ */
+export function buildPrChecksBody(body) {
+  const diagnostics = buildCheckDiagnostics(body.statuses ?? [], {
+    headSha: body.forge_source_sha,
+    requiredContexts: body.required_contexts ?? [],
+  });
+  return {
+    forge_source_sha: body.forge_source_sha,
+    check_conclusion: body.check_conclusion,
+    checks_truncated: body.checks_truncated === true,
+    statuses: diagnostics.statuses,
+    required_contexts: diagnostics.required_contexts,
+    missing_required_contexts: diagnostics.missing_required_contexts,
+    failed_contexts: diagnostics.failed_contexts,
+    pending_contexts: diagnostics.pending_contexts,
+    stale_contexts: diagnostics.stale_contexts,
+  };
+}

package/check-pagination.js

@@ -189,6 +189,7 @@ export async function paginateOffsetListPages({
       };
     }
     page = 2;
+    activeLimit = pageSize;
   }
 
   for (; page <= maxPages; page += 1) {

package/config-schema.js

@@ -25,6 +25,12 @@ export const configSchema = z
     repo: repoSegmentSchema,
     baseUrl: z.string().url().optional(),
     write_commands: z.array(writeCommandSchema).optional(),
+    merge_policy: z
+      .object({
+        allow_missing_checks: z.boolean().optional(),
+        allow_pending_checks: z.boolean().optional(),
+      })
+      .optional(),
   })
   .strict();
 

package/contracts/envelope.js

@@ -14,12 +14,15 @@ export const PACKET_TYPES = {
   PROVIDER_DOCTOR: 'provider_doctor',
   FORGE_ERROR: 'forge_error',
   CHANGE_REQUEST_OPENED: 'change_request_opened',
+  ISSUE_OPENED: 'issue_opened',
   COMMIT_STATUS_SET: 'commit_status_set',
   PROVIDER_IDENTITY: 'provider_identity',
   BRANCH_PROTECTION: 'branch_protection',
   CR_FILES: 'cr_files',
   CR_COMMENTS: 'cr_comments',
   FORGE_CHANGES: 'forge_changes',
+  CR_MERGED: 'cr_merged',
+  CR_MERGE_BLOCKED: 'cr_merge_blocked',
 };
 
 export const FORBIDDEN_PACKET_KEYS = new Set([
@@ -57,6 +60,11 @@ export function forgePacket(type, context, body = {}, error = null) {
     ok: error == null,
   };
 
+  delete packet.base_url;
+  if (context.baseUrl) {
+    packet.base_url = context.baseUrl;
+  }
+
   if (error) {
     packet.error_code = error.code;
     packet.error_message = sanitizeField(error.message);

package/contracts/errors.js

@@ -15,7 +15,10 @@ export const ERROR_CODES = {
   REMOTE_INFER_FAILED: 'remote_infer_failed',
   WRITE_NOT_CONFIGURED: 'write_not_configured',
   IDEMPOTENCY_SCAN_INCOMPLETE: 'idempotency_scan_incomplete',
+  IDEMPOTENCY_CONFLICT: 'idempotency_conflict',
   INVENTORY_LIST_INCOMPLETE: 'inventory_list_incomplete',
+  MERGE_BLOCKED: 'merge_blocked',
+  MERGE_ENDPOINT_FAILED: 'merge_endpoint_failed',
 };
 
 export function forgeError(code, message, status = null, fields = null) {

package/contracts/forge-error-fields.js

@@ -7,6 +7,7 @@ const FORBIDDEN_ERROR_FIELD_KEYS = new Set([
   'provider_id',
   'remote_name',
   'repo_id',
+  'base_url',
   'observed_at',
   'ok',
   'error_code',

package/contracts/semantic-diff-facts.js

@@ -28,7 +28,7 @@ export const V1_READ_PLAN_COMMANDS = Object.freeze([
 ]);
 
 /** v1 write surface (Gitea cr open and status set in first slices). */
-export const V1_WRITE_COMMANDS = Object.freeze(['cr open', 'status set']);
+export const V1_WRITE_COMMANDS = Object.freeze(['cr open', 'status set', 'merge execute', 'issue open']);
 
 /**
  * Planned fact-inventory packet types (not emitted until wave 2+ commands ship).
@@ -46,6 +46,7 @@ export const TRUSTED_ENVELOPE_FIELDS = Object.freeze([
   'provider_id',
   'remote_name',
   'repo_id',
+  'base_url',
   'observed_at',
   'ok',
 ]);
@@ -74,6 +75,9 @@ export const TRUSTED_NORMALIZED_BODY_FIELDS = Object.freeze({
   auth_present: true,
   can_write: true,
   reused_existing: true,
+  created: true,
+  idempotency_fingerprint: true,
+  ambiguous_after_write: true,
   idempotency_scan: true,
 });
 
@@ -83,9 +87,9 @@ export const TRUSTED_NORMALIZED_BODY_FIELDS = Object.freeze({
  */
 export const FORGE_SOURCED_STRING_LEAVES = Object.freeze({
   repo_status: ['default_branch', 'auth_env', 'capabilities'],
-  ref_compare: ['base_ref', 'head_ref', 'base_sha', 'head_sha'],
-  pr_status: ['url', 'title', 'base_ref', 'head_ref', 'base_sha', 'head_sha'],
-  pr_checks: ['head_sha', 'statuses[].context', 'statuses[].description', 'statuses[].target_url'],
+  ref_compare: ['compare_base_ref', 'compare_head_ref', 'compare_base_sha', 'compare_head_sha'],
+  pr_status: ['url', 'title', 'forge_target_branch_ref', 'forge_source_branch_ref', 'forge_target_sha', 'forge_source_sha'],
+  pr_checks: ['forge_source_sha', 'statuses[].context', 'statuses[].description', 'statuses[].target_url'],
   merge_plan: ['blockers[].message', 'blockers[].context'],
   sync_plan: ['remote', 'local_sha', 'remote_sha', 'blockers[].message'],
   ref_inventory: ['refs[].name', 'refs[].sha', 'default_ref'],
@@ -99,16 +103,16 @@ export const FORGE_SOURCED_STRING_LEAVES = Object.freeze({
   ],
   cr_files: ['changed_paths[]'],
   cr_comments: ['comments[].id', 'comments[].author', 'comments[].path', 'comments[].body'],
-  forge_changes: ['events[].title', 'events[].url', 'events[].head_sha'],
+  forge_changes: ['events[].title', 'events[].url', 'events[].forge_source_sha'],
   cr_inventory_slice: [
     'entries[].url',
     'entries[].title',
-    'entries[].base_ref',
-    'entries[].head_ref',
-    'entries[].base_sha',
-    'entries[].head_sha',
+    'entries[].forge_target_branch_ref',
+    'entries[].forge_source_branch_ref',
+    'entries[].forge_target_sha',
+    'entries[].forge_source_sha',
     'entries[].head_reconcile.local_head_sha',
-    'entries[].head_reconcile.head_sha',
+    'entries[].head_reconcile.forge_source_sha',
     'entries[].checks[].context',
     'entries[].checks[].description',
   ],
@@ -125,15 +129,23 @@ export const FACT_INVENTORY_BODY_SHAPES = Object.freeze({
   [FACT_INVENTORY_PACKET_TYPES.REF_INVENTORY]: {
     refs: 'array<{ name: string, sha: string, kind?: string, is_default?: boolean }>',
     default_ref: 'string optional',
-    ancestry_hints: 'array<{ base_ref: string, head_ref: string, ahead_by?: number, behind_by?: number }> optional',
+    ancestry_hints: 'array<{ compare_base_ref: string, compare_head_ref: string, ahead_by?: number, behind_by?: number }> optional',
   },
   [FACT_INVENTORY_PACKET_TYPES.CR_INVENTORY_SLICE]: {
     entries:
-      'array<{ pr_number: number, url?: string, title?: string, state?: string, base_ref?: string, head_ref?: string, base_sha?: string, head_sha?: string, mergeability?: string, checks_conclusion?: string, checks_truncated?: boolean, blockers?: array, head_reconcile?: { stale: boolean, local_head_sha?: string, head_sha?: string } }>',
+      'array<{ pr_number: number, url?: string, title?: string, state?: string, forge_target_branch_ref?: string, forge_source_branch_ref?: string, forge_target_sha?: string, forge_source_sha?: string, mergeability?: string, checks_conclusion?: string, checks_truncated?: boolean, blockers?: array, head_reconcile?: { stale: boolean, local_head_sha?: string, forge_source_sha?: string } }>',
     entry_count: 'number',
     /** true when list cap applied (entry_count > limit), not missing entries */
     truncated: 'boolean',
     list_truncated: 'boolean',
+    /** true when more pages remain via next_cursor */
+    has_more: 'boolean',
+    /** true when open-list enumeration is complete for slice_sort */
+    complete: 'boolean',
+    /** opaque cursor for the next page when has_more is true */
+    next_cursor: 'string optional',
+    /** numbers consumed from open-list ordering including skipped entries */
+    entry_count_observed: 'number',
     /** normalized slice sort preset applied to open-list resolution */
     slice_sort: 'string',
     entries_skipped:

package/cr-inventory-cursor.js

@@ -0,0 +1,64 @@
+import { ERROR_CODES, forgeError } from './contracts/errors.js';
+import { normalizeCrInventorySort } from './open-pull-list.js';
+
+export const CR_INVENTORY_CURSOR_VERSION = 1;
+
+/**
+ * @param {{ sort: string, offset: number }} state
+ * @returns {string}
+ */
+export function encodeCrInventoryCursor(state) {
+  const sort = normalizeCrInventorySort(state.sort);
+  const offset = Number(state.offset);
+  if (!Number.isInteger(offset) || offset < 0) {
+    throw Object.assign(new Error('Invalid cursor offset'), {
+      forgeError: forgeError(ERROR_CODES.INVALID_ARGS, 'cursor offset must be a non-negative integer'),
+    });
+  }
+  const payload = JSON.stringify({ v: CR_INVENTORY_CURSOR_VERSION, sort, offset });
+  return Buffer.from(payload, 'utf8').toString('base64url');
+}
+
+/**
+ * @param {unknown} raw
+ * @param {{ sort?: string | null }} [opts]
+ * @returns {{ sort: string, offset: number }}
+ */
+export function decodeCrInventoryCursor(raw, opts = {}) {
+  if (raw == null || raw === '') {
+    throw Object.assign(new Error('Missing cursor'), {
+      forgeError: forgeError(ERROR_CODES.INVALID_ARGS, '--cursor must not be empty when provided'),
+    });
+  }
+  let decoded;
+  try {
+    decoded = JSON.parse(Buffer.from(String(raw), 'base64url').toString('utf8'));
+  } catch {
+    throw Object.assign(new Error('Invalid cursor'), {
+      forgeError: forgeError(ERROR_CODES.INVALID_ARGS, '--cursor is malformed or not base64url JSON'),
+    });
+  }
+  if (decoded?.v !== CR_INVENTORY_CURSOR_VERSION) {
+    throw Object.assign(new Error('Invalid cursor version'), {
+      forgeError: forgeError(ERROR_CODES.INVALID_ARGS, '--cursor version is unsupported'),
+    });
+  }
+  const sort = normalizeCrInventorySort(decoded.sort);
+  const offset = Number(decoded.offset);
+  if (!Number.isInteger(offset) || offset < 0) {
+    throw Object.assign(new Error('Invalid cursor offset'), {
+      forgeError: forgeError(ERROR_CODES.INVALID_ARGS, '--cursor offset must be a non-negative integer'),
+    });
+  }
+  const requestedSort =
+    opts.sort == null || opts.sort === '' ? null : normalizeCrInventorySort(opts.sort);
+  if (requestedSort != null && requestedSort !== sort) {
+    throw Object.assign(new Error('Cursor sort mismatch'), {
+      forgeError: forgeError(
+        ERROR_CODES.INVALID_ARGS,
+        '--sort must match the cursor slice_sort when both are provided',
+      ),
+    });
+  }
+  return { sort, offset };
+}

package/cr-inventory.js

@@ -1,5 +1,6 @@
 import { sanitizeField } from './caps.js';
 import { ERROR_CODES, forgeError } from './contracts/errors.js';
+import { decodeCrInventoryCursor, encodeCrInventoryCursor } from './cr-inventory-cursor.js';
 import { mergeBlockersFromFacts, isOpenPrState } from './merge-blockers.js';
 import {
   DEFAULT_CR_INVENTORY_SLICE_SORT,
@@ -22,9 +23,9 @@ export function normalizeCrInventoryLimit(value) {
   return n;
 }
 
-async function resolveOpenPullList(provider, ctx, entryLimit, sliceSort) {
+async function resolveOpenPullList(provider, ctx, listWindow, sliceSort) {
   if (typeof provider.listOpenPullsWithMeta === 'function') {
-    return provider.listOpenPullsWithMeta(ctx, { retain_max: entryLimit, sort: sliceSort });
+    return provider.listOpenPullsWithMeta(ctx, { retain_max: listWindow, sort: sliceSort });
   }
   const numbers = await provider.listOpenPulls(ctx, {});
   return { numbers, list_truncated: false };
@@ -39,14 +40,14 @@ export function buildHeadReconcile(ctx, view) {
   const details = staleHeadDetails(
     ctx.cwd,
     ctx.config?.remote ?? ctx.remoteName,
-    view.head_ref,
-    view.head_sha,
+    view.forge_source_branch_ref,
+    view.forge_source_sha,
   );
   if (!details) return { stale: false };
   return {
     stale: true,
     local_head_sha: details.local_head_sha,
-    head_sha: details.head_sha,
+    forge_source_sha: details.forge_source_sha,
   };
 }
 
@@ -59,16 +60,16 @@ export function buildCrInventoryEntry(ctx, view, checks) {
     url: view.url,
     title: view.title,
     state: view.state,
-    base_ref: view.base_ref,
-    head_ref: view.head_ref,
+    forge_target_branch_ref: view.forge_target_branch_ref,
+    forge_source_branch_ref: view.forge_source_branch_ref,
     mergeability: view.mergeability,
     checks_conclusion: checks.check_conclusion,
     checks_truncated: checks.checks_truncated === true,
-    blockers: mergeBlockersFromFacts(view, checks),
+    blockers: mergeBlockersFromFacts(view, checks, {}, ctx.mergePolicy ?? {}),
     head_reconcile: buildHeadReconcile(ctx, view),
   };
-  if (view.base_sha) entry.base_sha = view.base_sha;
-  if (view.head_sha) entry.head_sha = view.head_sha;
+  if (view.forge_target_sha) entry.forge_target_sha = view.forge_target_sha;
+  if (view.forge_source_sha) entry.forge_source_sha = view.forge_source_sha;
   return entry;
 }
 
@@ -76,18 +77,26 @@ 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, sort?: string }} [opts]
+ * @param {{ slice_ref?: string, limit?: number, sort?: string, cursor?: string }} [opts]
  */
 export async function crInventory(ctx, provider, opts = {}) {
   const limit = normalizeCrInventoryLimit(opts.limit);
-  const sliceSort = normalizeCrInventorySort(opts.sort);
+  let sliceSort = normalizeCrInventorySort(opts.sort);
+  let offset = 0;
+  if (opts.cursor != null && opts.cursor !== '') {
+    const decoded = decodeCrInventoryCursor(opts.cursor, { sort: opts.sort });
+    offset = decoded.offset;
+    sliceSort = decoded.sort;
+  }
+
+  const listWindow = offset + limit;
   const {
     numbers,
     list_truncated: listTruncated,
     entry_count: providerEntryCount,
-  } = await resolveOpenPullList(provider, ctx, limit, sliceSort);
+  } = await resolveOpenPullList(provider, ctx, listWindow, sliceSort);
   const entryCount = providerEntryCount ?? numbers.length;
-  const selected = numbers.slice(0, limit);
+  const selected = numbers.slice(offset, offset + limit);
   const entries = [];
   const entries_skipped = [];
   for (const number of selected) {
@@ -106,13 +115,22 @@ export async function crInventory(ctx, provider, opts = {}) {
       });
     }
   }
+
+  const observedEnd = offset + selected.length;
+  const hasMore = listTruncated || observedEnd < entryCount;
+  const complete = !hasMore;
+
   return {
     entries,
     ...(entries_skipped.length ? { entries_skipped } : {}),
     entry_count: entryCount,
-    truncated: entryCount > selected.length,
+    entry_count_observed: observedEnd,
+    truncated: entryCount > observedEnd || listTruncated,
     list_truncated: listTruncated,
     slice_sort: sliceSort ?? DEFAULT_CR_INVENTORY_SLICE_SORT,
+    has_more: hasMore,
+    complete,
+    ...(hasMore ? { next_cursor: encodeCrInventoryCursor({ sort: sliceSort, offset: observedEnd }) } : {}),
     ...(opts.slice_ref ? { slice_ref: sanitizeField(opts.slice_ref) } : {}),
   };
 }

package/cr-open.js

@@ -5,7 +5,7 @@ import { ERROR_CODES, forgeError } from './contracts/errors.js';
 export function buildChangeRequestOpenedBody(
   pull,
   { head, base, title },
-  { reusedExisting = false } = {},
+  { reusedExisting = false, idempotencyFields = null } = {},
 ) {
   const prNumber = Number(pull?.number);
   if (!Number.isInteger(prNumber) || prNumber <= 0) {
@@ -28,6 +28,11 @@ export function buildChangeRequestOpenedBody(
   };
   if (reusedExisting) {
     body.reused_existing = true;
+  } else {
+    body.created = true;
+  }
+  if (idempotencyFields && typeof idempotencyFields === 'object') {
+    Object.assign(body, idempotencyFields);
   }
   return body;
 }