chainlesschain 0.166.106 → 0.166.108

package/src/lib/plugin-runtime/examples/goal-progress-viewer/plugin.json

@@ -0,0 +1,21 @@
+{
+  "name": "goal-progress-viewer",
+  "version": "0.1.0",
+  "description": "Read-only summary of an explicitly selected standalone CLI goal",
+  "permissions": { "goalExtension": ["panel:goal.summary"] },
+  "goalExtension": {
+    "apiVersion": "1.0.0",
+    "hosts": { "cli": ">=0.166.104" },
+    "events": [],
+    "panels": [
+      {
+        "id": "goal-progress",
+        "title": "Goal progress",
+        "slot": "goal.summary",
+        "fields": ["objective", "status"],
+        "fallback": "text"
+      }
+    ],
+    "proposals": []
+  }
+}

package/src/lib/plugin-runtime/examples/project-delivery-assistant/plugin.json

@@ -0,0 +1,38 @@
+{
+  "name": "project-delivery-assistant",
+  "version": "0.1.0",
+  "description": "Declarative project delivery assistant prototype; requires a goal extension host adapter",
+  "permissions": {
+    "goalExtension": [
+      "event:goal.status.changed",
+      "event:risk.review.completed",
+      "event:action.receipt.updated",
+      "panel:goal.evidence",
+      "proposal:task.create",
+      "proposal:task.description.update"
+    ]
+  },
+  "goalExtension": {
+    "apiVersion": "1.0.0",
+    "hosts": {
+      "cli": ">=0.166.104",
+      "vscode": ">=0.37.149",
+      "jetbrains": ">=0.4.166"
+    },
+    "events": [
+      "goal.status.changed",
+      "risk.review.completed",
+      "action.receipt.updated"
+    ],
+    "panels": [
+      {
+        "id": "delivery-evidence",
+        "title": "Project delivery evidence",
+        "slot": "goal.evidence",
+        "fields": ["objective", "status", "riskSummary", "receiptSummary"],
+        "fallback": "text"
+      }
+    ],
+    "proposals": ["task.create", "task.description.update"]
+  }
+}

package/src/lib/plugin-runtime/goal-extension-contract.js

@@ -0,0 +1,190 @@
+/** DMM-07: data-only declarations. Compatibility never grants execution. */
+import semver from "semver";
+
+export const GOAL_EXTENSION_API_VERSION = "1.0.0";
+export const GOAL_EXTENSION_HOSTS = Object.freeze([
+  "cli",
+  "vscode",
+  "jetbrains",
+  "desktop",
+]);
+export const GOAL_EXTENSION_EVENTS = Object.freeze([
+  "goal.status.changed",
+  "risk.review.completed",
+  "action.receipt.updated",
+]);
+export const GOAL_EXTENSION_SLOTS = Object.freeze([
+  "goal.summary",
+  "goal.evidence",
+  "goal.actions",
+]);
+export const GOAL_EXTENSION_PROPOSALS = Object.freeze([
+  "task.create",
+  "task.description.update",
+]);
+const PANEL_FIELDS = ["objective", "status", "riskSummary", "receiptSummary"];
+
+function object(value, keys, label) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    throw new Error(`${label} must be an object`);
+  for (const key of Object.keys(value)) {
+    if (!keys.includes(key))
+      throw new Error(`${label}: unsupported field ${key}`);
+  }
+}
+
+function text(value, label, max = 128) {
+  if (
+    typeof value !== "string" ||
+    !value.trim() ||
+    value.length > max ||
+    /[\u0000-\u001f\u007f]/.test(value)
+  )
+    throw new Error(`${label} must be non-empty text (max ${max})`);
+  return value;
+}
+
+function list(value, allowed, label) {
+  if (
+    !Array.isArray(value) ||
+    value.length > 16 ||
+    value.some((entry) => !allowed.includes(entry)) ||
+    new Set(value).size !== value.length
+  )
+    throw new Error(
+      `${label} must be a unique list of supported values (max 16)`,
+    );
+  return [...value];
+}
+
+export function requiredGoalExtensionCapabilities(extension) {
+  return [
+    ...new Set([
+      ...extension.events.map((event) => `event:${event}`),
+      ...extension.panels.map((panel) => `panel:${panel.slot}`),
+      ...extension.proposals.map((action) => `proposal:${action}`),
+    ]),
+  ].sort();
+}
+
+/** Unknown fields include code entrypoints, approval claims and receipt writers. */
+export function normalizeGoalExtension(raw, permissions) {
+  if (raw === undefined) return null;
+  object(
+    raw,
+    ["apiVersion", "hosts", "events", "panels", "proposals"],
+    "goalExtension",
+  );
+  const apiVersion = text(raw.apiVersion, "goalExtension.apiVersion");
+  if (!semver.valid(apiVersion))
+    throw new Error("goalExtension.apiVersion must be semver");
+  object(raw.hosts, GOAL_EXTENSION_HOSTS, "goalExtension.hosts");
+  if (!Object.keys(raw.hosts).length)
+    throw new Error("goalExtension.hosts must declare a host");
+  const hosts = {};
+  for (const [host, range] of Object.entries(raw.hosts)) {
+    text(range, `goalExtension.hosts.${host}`);
+    if (!semver.validRange(range))
+      throw new Error(`goalExtension.hosts.${host} must be a semver range`);
+    hosts[host] = range;
+  }
+  const events = list(
+    raw.events ?? [],
+    GOAL_EXTENSION_EVENTS,
+    "goalExtension.events",
+  );
+  const proposals = list(
+    raw.proposals ?? [],
+    GOAL_EXTENSION_PROPOSALS,
+    "goalExtension.proposals",
+  );
+  if (!Array.isArray(raw.panels ?? []) || (raw.panels ?? []).length > 16)
+    throw new Error("goalExtension.panels must be a list (max 16)");
+  const ids = new Set();
+  const panels = (raw.panels ?? []).map((panel) => {
+    object(
+      panel,
+      ["id", "title", "slot", "fields", "fallback"],
+      "goalExtension.panel",
+    );
+    const id = text(panel.id, "goalExtension.panel.id", 64);
+    if (!/^[a-z][a-z0-9-]*$/.test(id) || ids.has(id))
+      throw new Error("goalExtension.panel.id must be unique kebab-case");
+    ids.add(id);
+    if (!GOAL_EXTENSION_SLOTS.includes(panel.slot))
+      throw new Error("goalExtension.panel.slot is unsupported");
+    if (panel.fallback !== "text")
+      throw new Error("goalExtension.panel.fallback must be text");
+    return {
+      id,
+      title: text(panel.title, "goalExtension.panel.title"),
+      slot: panel.slot,
+      fields: list(panel.fields, PANEL_FIELDS, "goalExtension.panel.fields"),
+      fallback: "text",
+    };
+  });
+  const extension = { apiVersion, hosts, events, panels, proposals };
+  const allowed = [
+    ...GOAL_EXTENSION_EVENTS.map((event) => `event:${event}`),
+    ...GOAL_EXTENSION_SLOTS.map((slot) => `panel:${slot}`),
+    ...GOAL_EXTENSION_PROPOSALS.map((action) => `proposal:${action}`),
+  ];
+  // Validate RAW permissions: permissive legacy coercion cannot admit this API.
+  object(permissions, Object.keys(permissions || {}), "permissions");
+  const grants = list(
+    permissions.goalExtension,
+    allowed,
+    "permissions.goalExtension",
+  );
+  for (const required of requiredGoalExtensionCapabilities(extension)) {
+    if (!grants.includes(required))
+      throw new Error(
+        `goalExtension requires permissions.goalExtension: ${required}`,
+      );
+  }
+  return extension;
+}
+
+/** Pure version/capability check; callers must still check current authorization. */
+export function checkGoalExtensionCompatibility(extension, host = {}) {
+  if (!extension) return { compatible: false, reason: "legacy_unsupported" };
+  if (!semver.eq(extension.apiVersion, GOAL_EXTENSION_API_VERSION))
+    return { compatible: false, reason: "unsupported_api" };
+  if (!Object.hasOwn(extension.hosts, host.id))
+    return { compatible: false, reason: "unsupported_host" };
+  if (
+    !semver.valid(host.version) ||
+    !semver.satisfies(host.version, extension.hosts[host.id])
+  )
+    return { compatible: false, reason: "host_version_mismatch" };
+  const supported = Array.isArray(host.capabilities) ? host.capabilities : [];
+  const missing = requiredGoalExtensionCapabilities(extension).filter(
+    (cap) => !supported.includes(cap),
+  );
+  return missing.length
+    ? { compatible: false, reason: "unsupported_capabilities", missing }
+    : { compatible: true, reason: "compatible" };
+}
+
+/** Safe management summary; never an admission token or a claim of a live host. */
+export function summarizeGoalExtension(manifest) {
+  const extension = manifest?.goalExtension;
+  if (!extension)
+    return {
+      status: manifest?.goalExtensionDeclared ? "invalid" : "legacy",
+      runtimeAvailable: false,
+    };
+  return {
+    status: "declaration-only",
+    runtimeAvailable: false,
+    apiVersion: extension.apiVersion,
+    apiCompatible: semver.eq(extension.apiVersion, GOAL_EXTENSION_API_VERSION),
+    hosts: { ...extension.hosts },
+    events: [...extension.events],
+    panels: extension.panels.map((panel) => ({
+      ...panel,
+      fields: [...panel.fields],
+    })),
+    proposals: [...extension.proposals],
+  };
+}

package/src/lib/plugin-runtime/goal-extensions.js

@@ -0,0 +1,277 @@
+import {
+  goalExtensionRef as goalRef,
+  normalizeGoalExtensionProposal,
+} from "@chainlesschain/session-core/goal-extension-proposal-contract";
+/**
+ * DMM-07 host boundary. Only trusted host code calls this module; plugins supply
+ * declarations, never callbacks. Re-discover for every delivery/proposal so a
+ * retained session cannot outlive disable, uninstall, policy or consent changes.
+ */
+import { discoverPlugins } from "./scopes.js";
+import { loadManagedPluginPolicy, filterByManagedPolicy } from "./policy.js";
+import { isPluginTrusted } from "./trust.js";
+import { isPluginCapabilityConsented } from "./capability-consent.js";
+import { checkGoalExtensionCompatibility } from "./goal-extension-contract.js";
+import path from "node:path";
+import { managedSettingsPath } from "../settings-loader.cjs";
+
+export const _deps = {
+  discoverPlugins,
+  loadManagedPluginPolicy,
+  filterByManagedPolicy,
+  isPluginTrusted,
+  isPluginCapabilityConsented,
+};
+
+function fixedHostOptions(options) {
+  const env = Object.freeze({ ...(options.env || process.env) });
+  return Object.freeze({
+    cwd: path.resolve(options.cwd || process.cwd()),
+    env,
+    managedSettingsFile: managedSettingsPath({
+      env,
+      managedSettingsFile: options.managedSettingsFile,
+    }),
+    host: Object.freeze({
+      id: options.host?.id,
+      version: options.host?.version,
+      capabilities: Object.freeze([...(options.host?.capabilities || [])]),
+    }),
+    authorize: options.authorize,
+    readEvent: options.readEvent,
+    readPanel: options.readPanel,
+    enqueueProposal: options.enqueueProposal,
+  });
+}
+
+/** Compatibility and mandatory consent are independent of legacy policy flags. */
+export function collectGoalExtensions(options = {}) {
+  const extensions = [];
+  const dropped = [];
+  try {
+    const { cwd, env, managedSettingsFile, host } = fixedHostOptions(options);
+    const managed = _deps.loadManagedPluginPolicy({
+      env,
+      managedSettingsFile,
+      fresh: true,
+    });
+    const plugins = _deps.discoverPlugins({
+      cwd,
+      env,
+      managedSettingsFile,
+      skipPolicy: true,
+      includeDisabled: true,
+      includeBlocked: true,
+    });
+    for (const plugin of plugins) {
+      let reason = null;
+      try {
+        if (plugin.runtimeBlocked || plugin.manifest?.ok !== true)
+          reason = "invalid_plugin";
+        else if (plugin.enabled === false) reason = "disabled";
+        else if (!_deps.filterByManagedPolicy([plugin], managed).kept.length)
+          reason = "policy_blocked";
+        else {
+          const compatibility = checkGoalExtensionCompatibility(
+            plugin.manifest.goalExtension,
+            host,
+          );
+          if (!compatibility.compatible) reason = compatibility.reason;
+          else if (plugin.manifest.capabilitiesDeclared !== true)
+            reason = "capabilities_undeclared";
+          else if (
+            !_deps.isPluginTrusted({
+              ...plugin,
+              workspaceRoot: cwd || process.cwd(),
+            })
+          )
+            reason = "untrusted";
+          else if (
+            !_deps.isPluginCapabilityConsented(
+              plugin,
+              plugin.manifest.capabilities,
+            )
+          )
+            reason = "consent_required";
+        }
+      } catch {
+        reason = "authorization_unavailable";
+      }
+      if (reason)
+        dropped.push({ name: plugin.name, scope: plugin.scope, reason });
+      else
+        extensions.push({
+          name: plugin.name,
+          scope: plugin.scope,
+          version: plugin.version,
+          declaration: JSON.parse(
+            JSON.stringify(plugin.manifest.goalExtension),
+          ),
+        });
+    }
+  } catch {
+    // Management I/O failure is never permission to continue with old state.
+    return { extensions: [], dropped: [{ reason: "discovery_unavailable" }] };
+  }
+  return { extensions, dropped };
+}
+
+function admittedPlugin(ref, options, kind, value) {
+  const plugin = collectGoalExtensions(options).extensions.find(
+    (entry) =>
+      entry.name === ref?.name &&
+      entry.scope === ref?.scope &&
+      entry.version === ref?.version,
+  );
+  if (!plugin) throw new Error("goal extension is not currently admitted");
+  if (kind && !plugin.declaration[kind].includes(value))
+    throw new Error(`goal extension ${kind} is undeclared`);
+  return plugin;
+}
+
+async function authorize(callback, context) {
+  if (typeof callback !== "function" || (await callback(context)) !== true)
+    throw new Error("goal extension source authorization denied");
+}
+
+/** Deliver a bounded read-only view, checking source access again after I/O. */
+export async function projectGoalExtensionEvent(ref, request, options = {}) {
+  options = fixedHostOptions(options);
+  const type = request?.type;
+  const plugin = admittedPlugin(ref, options, "events", type);
+  const source = goalRef(request.goalRef);
+  const context = Object.freeze({
+    plugin: Object.freeze({
+      name: plugin.name,
+      scope: plugin.scope,
+      version: plugin.version,
+    }),
+    goalRef: source,
+    operation: "read-event",
+    type,
+  });
+  await authorize(options.authorize, context);
+  if (typeof options.readEvent !== "function")
+    throw new Error("host event reader unavailable");
+  const data = await options.readEvent(context);
+  await authorize(options.authorize, context);
+  admittedPlugin(context.plugin, options, "events", type);
+  // The host reader owns object access. Never spread raw goal/memory/receipt data.
+  if (
+    !data ||
+    typeof data.summary !== "string" ||
+    data.summary.length > 4096 ||
+    typeof data.occurredAt !== "string" ||
+    data.occurredAt.length > 64 ||
+    !Number.isFinite(Date.parse(data.occurredAt))
+  )
+    throw new Error("invalid host event projection");
+  return Object.freeze({
+    type,
+    goalRef: source,
+    summary: data.summary,
+    occurredAt: data.occurredAt,
+  });
+}
+
+/** Fixed-slot UI has a plain-text fallback; extensions cannot supply markup. */
+export async function projectGoalExtensionPanel(ref, request, options = {}) {
+  options = fixedHostOptions(options);
+  const plugin = admittedPlugin(ref, options);
+  const panel = plugin.declaration.panels.find(
+    (entry) => entry.id === request?.panelId,
+  );
+  if (!panel) throw new Error("goal extension panel is undeclared");
+  const source = goalRef(request.goalRef);
+  const context = Object.freeze({
+    plugin: Object.freeze({
+      name: plugin.name,
+      scope: plugin.scope,
+      version: plugin.version,
+    }),
+    goalRef: source,
+    operation: "read-panel",
+    panel: Object.freeze({
+      ...panel,
+      fields: Object.freeze([...panel.fields]),
+    }),
+  });
+  await authorize(options.authorize, context);
+  if (typeof options.readPanel !== "function")
+    throw new Error("host panel reader unavailable");
+  const data = await options.readPanel(context);
+  await authorize(options.authorize, context);
+  const current = admittedPlugin(context.plugin, options);
+  if (
+    !current.declaration.panels.some(
+      (entry) => JSON.stringify(entry) === JSON.stringify(panel),
+    )
+  )
+    throw new Error("goal extension panel changed during projection");
+  const lines = [panel.title];
+  for (const field of panel.fields) {
+    if (typeof data?.[field] !== "string" || data[field].length > 4096)
+      throw new Error(`invalid host panel field ${field}`);
+    lines.push(`${field}: ${data[field]}`);
+  }
+  return Object.freeze({
+    id: panel.id,
+    slot: panel.slot,
+    format: "text",
+    text: lines.join("\n"),
+  });
+}
+
+/** Queue an unapproved proposal through a host adapter; no action execution API. */
+export async function proposeGoalExtensionAction(ref, raw, options = {}) {
+  options = fixedHostOptions(options);
+  const plugin = admittedPlugin(ref, options);
+  raw = normalizeGoalExtensionProposal(raw);
+  if (!plugin.declaration.proposals.includes(raw.type))
+    throw new Error("goal extension proposal is undeclared");
+  const source = raw.goalRef;
+  const title = raw.title;
+  const description = raw.description;
+  const context = Object.freeze({
+    plugin: Object.freeze({
+      name: plugin.name,
+      scope: plugin.scope,
+      version: plugin.version,
+    }),
+    goalRef: source,
+    operation: "propose-action",
+    type: raw.type,
+    sourceRef: raw.sourceRef,
+    requestId: raw.requestId,
+  });
+  await authorize(options.authorize, context);
+  if (typeof options.enqueueProposal !== "function")
+    throw new Error("host proposal queue unavailable");
+  admittedPlugin(context.plugin, options, "proposals", context.type);
+  // The host queue must revalidate source revision/control generation in its
+  // transaction, and deduplicate requestId within plugin/version/goal identity.
+  // It stores a pending suggestion; native confirmation stays later.
+  const result = await options.enqueueProposal(
+    Object.freeze({
+      ...context,
+      title,
+      description,
+      state: "pending-confirmation",
+    }),
+  );
+  if (
+    !result ||
+    typeof result !== "object" ||
+    Array.isArray(result) ||
+    Object.keys(result).some((key) => !["proposalId", "state"].includes(key)) ||
+    result.state !== "pending-confirmation" ||
+    typeof result.proposalId !== "string" ||
+    !result.proposalId ||
+    result.proposalId.length > 256
+  )
+    throw new Error("invalid host proposal receipt");
+  return Object.freeze({
+    proposalId: result.proposalId,
+    state: "pending-confirmation",
+  });
+}

package/src/lib/plugin-runtime/install.js

@@ -17,6 +17,7 @@
  */
 
 import fs from "fs";
+import { summarizeGoalExtension } from "./goal-extension-contract.js";
 import os from "os";
 import path from "path";
 import crypto from "node:crypto";
@@ -2115,6 +2116,7 @@ export function listInstalled(opts = {}) {
       scope: p.scope,
       dir: p.root,
       ok: p.manifest?.ok === true,
+      goalExtension: summarizeGoalExtension(p.manifest),
       enabled: p.enabled !== false,
       runtimeBlocked: p.runtimeBlocked === true,
       activePointer: {
@@ -3388,17 +3390,17 @@ function sameSourceAuthority(current, candidate) {
   if (current.type === "registry") {
     return Boolean(
       current.sourceDigest &&
-      candidate.sourceDigest &&
-      current.sourceDigest === candidate.sourceDigest &&
-      current.resolvedSourceDigest &&
-      candidate.resolvedSourceDigest &&
-      current.resolvedSourceDigest === candidate.resolvedSourceDigest,
+        candidate.sourceDigest &&
+        current.sourceDigest === candidate.sourceDigest &&
+        current.resolvedSourceDigest &&
+        candidate.resolvedSourceDigest &&
+        current.resolvedSourceDigest === candidate.resolvedSourceDigest,
     );
   }
   return Boolean(
     current.sourceDigest &&
-    candidate.sourceDigest &&
-    current.sourceDigest === candidate.sourceDigest,
+      candidate.sourceDigest &&
+      current.sourceDigest === candidate.sourceDigest,
   );
 }
 
@@ -3661,11 +3663,7 @@ function normalizeSourceMetadata(value) {
               value.resolvedSource,
               catalogAuthority.commandSource,
             )
-          : pluginSourceAuthorityDigest(
-              value.resolvedSource,
-              "git",
-              value.ref,
-            )
+          : pluginSourceAuthorityDigest(value.resolvedSource, "git", value.ref)
       : null);
   const policyDigest = normalizeSourceAuthorityDigest(value.policyDigest);
   if (resolvedSourceDigest) {
@@ -3998,8 +3996,8 @@ function assertCatalogRemoteArtifactBindings(metadata) {
   const expectedSignature = expectations.signature || {};
   const expectsRemoteSignature = Boolean(
     expectedSignature.url &&
-    expectedSignature.publicKeyUrl &&
-    expectedSignature.publicKeySha256,
+      expectedSignature.publicKeyUrl &&
+      expectedSignature.publicKeySha256,
   );
   if (expectsRemoteSignature !== Boolean(evidence.signature)) {
     throw new Error(
@@ -5628,9 +5626,9 @@ function samePointerState(left, right) {
   if (!left.present) return true;
   return Boolean(
     Buffer.isBuffer(left.bytes) &&
-    Buffer.isBuffer(right.bytes) &&
-    left.bytes.equals(right.bytes) &&
-    sameFileGeneration(left.generation, right.generation),
+      Buffer.isBuffer(right.bytes) &&
+      left.bytes.equals(right.bytes) &&
+      sameFileGeneration(left.generation, right.generation),
   );
 }
 
@@ -5668,9 +5666,9 @@ function sameLifecycleFileState(left, right) {
   if (!left.present) return true;
   return Boolean(
     Buffer.isBuffer(left.bytes) &&
-    Buffer.isBuffer(right.bytes) &&
-    left.bytes.equals(right.bytes) &&
-    sameFileGeneration(left.generation, right.generation),
+      Buffer.isBuffer(right.bytes) &&
+      left.bytes.equals(right.bytes) &&
+      sameFileGeneration(left.generation, right.generation),
   );
 }
 
@@ -5718,11 +5716,11 @@ function serializePluginNameState(state) {
 function samePluginNameState(left, right) {
   return Boolean(
     left &&
-    right &&
-    sameFileGeneration(left.generation, right.generation) &&
-    left.payloadDigest === right.payloadDigest &&
-    left.fileCount === right.fileCount &&
-    left.totalBytes === right.totalBytes,
+      right &&
+      sameFileGeneration(left.generation, right.generation) &&
+      left.payloadDigest === right.payloadDigest &&
+      left.fileCount === right.fileCount &&
+      left.totalBytes === right.totalBytes,
   );
 }
 
@@ -5745,8 +5743,8 @@ function lifecycleFileContentMatches(left, right) {
   if (!left.present) return true;
   return Boolean(
     Buffer.isBuffer(left.bytes) &&
-    Buffer.isBuffer(right.bytes) &&
-    left.bytes.equals(right.bytes),
+      Buffer.isBuffer(right.bytes) &&
+      left.bytes.equals(right.bytes),
   );
 }
 
@@ -5812,7 +5810,9 @@ function hasRetainedLifecycleRecovery(nameDir) {
 function authoritativeTransactionCleanupPending(cleanup) {
   return Boolean(
     cleanup?.cleanupPending === true &&
-    /^\.(?:install|uninstall)-/u.test(path.basename(cleanup.cleanupPath || "")),
+      /^\.(?:install|uninstall)-/u.test(
+        path.basename(cleanup.cleanupPath || ""),
+      ),
   );
 }
 
@@ -5902,22 +5902,22 @@ function fileGeneration(stat) {
 function sameFileGeneration(left, right) {
   return Boolean(
     left &&
-    right &&
-    left.dev === right.dev &&
-    left.ino === right.ino &&
-    left.birthtimeMs === right.birthtimeMs &&
-    left.mtimeMs === right.mtimeMs &&
-    left.size === right.size,
+      right &&
+      left.dev === right.dev &&
+      left.ino === right.ino &&
+      left.birthtimeMs === right.birthtimeMs &&
+      left.mtimeMs === right.mtimeMs &&
+      left.size === right.size,
   );
 }
 
 function sameInstalledVersionState(left, right) {
   return Boolean(
     left &&
-    right &&
-    sameFileGeneration(left.generation, right.generation) &&
-    left.payloadDigest === right.payloadDigest &&
-    left.sourceDigest === right.sourceDigest,
+      right &&
+      sameFileGeneration(left.generation, right.generation) &&
+      left.payloadDigest === right.payloadDigest &&
+      left.sourceDigest === right.sourceDigest,
   );
 }
 
@@ -5999,8 +5999,8 @@ function activePointerMatchesSnapshot(transaction) {
   if (!snapshot.present) return true;
   return Boolean(
     Buffer.isBuffer(current.bytes) &&
-    Buffer.isBuffer(snapshot.bytes) &&
-    current.bytes.equals(snapshot.bytes),
+      Buffer.isBuffer(snapshot.bytes) &&
+      current.bytes.equals(snapshot.bytes),
   );
 }