pi-codex-marketplace 0.1.0

package/src/projection/overrides.ts

@@ -0,0 +1,230 @@
+/**
+ * Scope Override lifecycle — Project Scope records that explicitly suppress inherited
+ * Global Scope records without modifying them.
+ * See CONTEXT.md: Scope Override, Project Trust, Lifecycle Operation, Attempt Fence, State Revision.
+ *
+ * A Registration override suppresses its marketplace subtree; an Installation override
+ * suppresses only that single Plugin. Removing either reveals the inherited record again at
+ * the next read — inheritance is restored by Effective State recomputation, never by rewriting
+ * the global document. Both operations are Project Scope Lifecycle Operations: they require
+ * Project Trust, run under the scope Attempt Fence, bind the exact State Revision at admission,
+ * commit atomically to the project document only, and produce an immutable Attempt Receipt.
+ */
+
+import { readBridgeState, commitBridgeState } from '../bridge-state/store.js';
+import type { BridgeState, ScopeOverride } from '../bridge-state/types.js';
+import { acquireAttemptFence } from '../registration/fence.js';
+import { CODE, RULE, blocking, type ValidationFinding } from '../registration/findings.js';
+import { createReceipt, type AttemptReceipt } from '../registration/receipt.js';
+import { appendReceipt } from '../journal/journal.js';
+
+export type OverrideKind = ScopeOverride['kind'];
+
+export interface ScopeOverrideFlowOptions {
+  cwd?: string;
+  agentDir?: string;
+  projectTrusted?: boolean;
+  fenceTimeoutMs?: number;
+  /** Integration synchronization seam; production callers leave this undefined. */
+  beforeCommit?: () => void | Promise<void>;
+}
+
+export type OverrideOutcome =
+  | { status: 'completed'; receipt: AttemptReceipt; newRevision: string }
+  | { status: 'blocked'; findings: ValidationFinding[]; receipt: AttemptReceipt }
+  | { status: 'rejected-as-stale'; receipt: AttemptReceipt }
+  | { status: 'persistence-failed'; receipt: AttemptReceipt; isIndeterminate: boolean };
+
+const OPERATION_NAME = {
+  createRegistration: 'Registration Override Creation',
+  createInstallation: 'Installation Override Creation',
+  removeRegistration: 'Registration Override Removal',
+  removeInstallation: 'Installation Override Removal',
+} as const;
+
+function operationName(kind: OverrideKind, direction: 'create' | 'remove'): string {
+  if (kind === 'registration') return direction === 'create' ? OPERATION_NAME.createRegistration : OPERATION_NAME.removeRegistration;
+  return direction === 'create' ? OPERATION_NAME.createInstallation : OPERATION_NAME.removeInstallation;
+}
+
+function admissionFinding(code: string, rule: string, outcome: string, target: ValidationFinding['target']): ValidationFinding {
+  return blocking({ code, rule, target, pointer: '', outcome, scope: 'project', phase: 'admission' });
+}
+
+async function blocked(operation: string, targetId: string, revision: string, findings: ValidationFinding[], opts: ScopeOverrideFlowOptions = {}): Promise<OverrideOutcome> {
+  const receipt = createReceipt({
+    operation,
+    scope: 'project',
+    trigger: `${operation.toLowerCase()} ${targetId}`,
+    expectedStateRevision: revision,
+    summary: 'Blocked',
+    findings,
+  });
+  await appendReceipt('project', receipt, opts);
+  return {
+    status: 'blocked',
+    findings,
+    receipt,
+  };
+}
+
+async function persistenceFailed(operation: string, targetId: string, isIndeterminate: boolean, error?: string, opts: ScopeOverrideFlowOptions = {}): Promise<OverrideOutcome> {
+  const receipt = createReceipt({
+    operation,
+    scope: 'project',
+    trigger: `${operation.toLowerCase()} ${targetId}`,
+    expectedStateRevision: '?',
+    summary: isIndeterminate ? 'Persistence Indeterminate' : 'Persistence Failed',
+    findings: isIndeterminate
+      ? [admissionFinding(CODE.PERSISTENCE_INDETERMINATE, 'PERSIST-01', error ?? 'Bridge State is not readable', 'attempt')]
+      : [],
+  });
+  await appendReceipt('project', receipt, opts);
+  return {
+    status: 'persistence-failed',
+    isIndeterminate,
+    receipt,
+  };
+}
+
+async function runOverrideOperation(
+  direction: 'create' | 'remove',
+  kind: OverrideKind,
+  targetId: string,
+  opts: ScopeOverrideFlowOptions,
+  /** Admission validation over both authoritative documents; returns the blocking denial, if any. */
+  validate: (projectState: BridgeState, globalState: BridgeState) => ValidationFinding | undefined,
+): Promise<OverrideOutcome> {
+  const operation = operationName(kind, direction);
+  if (opts.projectTrusted !== true) {
+    return blocked(operation, targetId, '?', [
+      admissionFinding(CODE.PROJECT_TRUST_DENIED, RULE.PROJECT_TRUST_DENIED, 'Project Trust is not granted by the Pi host; no Project Scope Lifecycle Operation may mutate Bridge State', kind === 'registration' ? 'registration' : 'installation'),
+    ], opts);
+  }
+
+  const storeOpts = { cwd: opts.cwd, agentDir: opts.agentDir };
+  const fence = await acquireAttemptFence('project', { ...storeOpts, fenceTimeoutMs: opts.fenceTimeoutMs, projectTrusted: opts.projectTrusted });
+  if (!fence.ok) return blocked(operation, targetId, '?', [fence.finding!], opts);
+
+  try {
+    const projectRead = await readBridgeState('project', storeOpts);
+    const globalRead = await readBridgeState('global', storeOpts);
+    if (projectRead.status !== 'ok' && projectRead.status !== 'missing') {
+      return persistenceFailed(operation, targetId, true, projectRead.error, opts);
+    }
+    if (globalRead.status !== 'ok' && globalRead.status !== 'missing') {
+      return persistenceFailed(operation, targetId, true, globalRead.error, opts);
+    }
+
+    const projectState = projectRead.state!;
+    const denial = validate(projectState, globalRead.state!);
+    if (denial) return blocked(operation, targetId, projectState.stateRevision, [denial], opts);
+
+    await opts.beforeCommit?.();
+
+    const write = await commitBridgeState(
+      'project',
+      (state) => ({
+        ...state,
+        scopeOverrides:
+          direction === 'create'
+            ? [...state.scopeOverrides.filter((item) => !(item.kind === kind && item.targetId === targetId)), { kind, targetId }]
+            : state.scopeOverrides.filter((item) => !(item.kind === kind && item.targetId === targetId)),
+      }),
+      { ...storeOpts, lockTimeoutMs: opts.fenceTimeoutMs, expectedStateRevision: projectState.stateRevision },
+    );
+
+    if (write.isStale) {
+      const receipt = createReceipt({
+        operation,
+        scope: 'project',
+        trigger: `${operation.toLowerCase()} ${targetId}`,
+        expectedStateRevision: projectState.stateRevision,
+        observedStateRevision: write.observedRevision,
+        summary: 'Rejected as Stale',
+        findings: [blocking({ code: CODE.REJECTED_AS_STALE, rule: RULE.REJECTED_AS_STALE, target: kind === 'registration' ? 'registration' : 'installation', pointer: '', outcome: `State Revision changed after ${operation} admission; re-run the lifecycle operation`, scope: 'project', phase: 'persistence' })],
+      });
+      await appendReceipt('project', receipt, opts);
+      return {
+        status: 'rejected-as-stale',
+        receipt,
+      };
+    }
+    if (!write.success) return persistenceFailed(operation, targetId, write.isIndeterminate ?? false, write.error, opts);
+
+    const receipt = createReceipt({
+      operation,
+      scope: 'project',
+      trigger: `${operation.toLowerCase()} ${targetId}`,
+      expectedStateRevision: projectState.stateRevision,
+      targetStateRevision: write.newRevision,
+      observedStateRevision: write.newRevision,
+      summary: 'Completed',
+      stateChanged: true,
+    });
+    await appendReceipt('project', receipt, opts);
+
+    return {
+      status: 'completed',
+      newRevision: write.newRevision!,
+      receipt,
+    };
+  } finally {
+    fence.handle!.release();
+  }
+}
+
+/**
+ * Create one Scope Override suppressing an inherited Global record.
+ * The target must exist in the inherited Global Scope and must not already be suppressed.
+ */
+export async function createScopeOverride(
+  kind: OverrideKind,
+  targetId: string,
+  opts: ScopeOverrideFlowOptions = {},
+): Promise<OverrideOutcome> {
+  return runOverrideOperation('create', kind, targetId, opts, (projectState, globalState) => {
+    if (projectState.scopeOverrides.some((item) => item.kind === kind && item.targetId === targetId)) {
+      return admissionFinding(
+        CODE.SCOPE_OVERRIDE_ALREADY_PRESENT,
+        RULE.SCOPE_OVERRIDE_ALREADY_PRESENT,
+        `A ${kind} Scope Override for '${targetId}' already exists in Project Scope`,
+        kind === 'registration' ? 'registration' : 'installation',
+      );
+    }
+    const exists = kind === 'registration'
+      ? globalState.registrations.some((registration) => registration.id === targetId)
+      : globalState.installations.some((installation) => installation.id === targetId);
+    if (!exists) {
+      return admissionFinding(
+        CODE.SCOPE_OVERRIDE_TARGET_NOT_FOUND,
+        RULE.SCOPE_OVERRIDE_TARGET_NOT_FOUND,
+        `Suppression target '${targetId}' does not exist in the inherited Global Scope; Scope Overrides suppress inherited records only`,
+        kind === 'registration' ? 'registration' : 'installation',
+      );
+    }
+    return undefined;
+  });
+}
+
+/**
+ * Remove one Scope Override; inheritance is restored by Effective State recomputation without
+ * rewriting the global document.
+ */
+export async function removeScopeOverride(
+  kind: OverrideKind,
+  targetId: string,
+  opts: ScopeOverrideFlowOptions = {},
+): Promise<OverrideOutcome> {
+  return runOverrideOperation('remove', kind, targetId, opts, (projectState) => {
+    if (!projectState.scopeOverrides.some((item) => item.kind === kind && item.targetId === targetId)) {
+      return admissionFinding(
+        CODE.SCOPE_OVERRIDE_TARGET_NOT_FOUND,
+        RULE.SCOPE_OVERRIDE_TARGET_NOT_FOUND,
+        `No ${kind} Scope Override for '${targetId}' exists in Project Scope`,
+        kind === 'registration' ? 'registration' : 'installation',
+      );
+    }
+    return undefined;
+  });
+}

package/src/projection/project.ts

@@ -0,0 +1,359 @@
+/**
+ * Projection — admits Effective State Installations as Projected Plugins and exposes their
+ * surviving skills to Pi through Pi's resource-discovery seam at their original snapshot paths.
+ * See CONTEXT.md: Projected Plugin, Projected Skill, Runtime Skill Collision, Source Drift,
+ * Skill Availability, Runtime Application.
+ *
+ * Whole-Plugin Blocking Findings (Source Drift, Unavailable Entry, failed classification)
+ * deny an entire Plugin; Runtime Skill Collision denies only individual skill candidates and
+ * never changes Plugin classification or Projected Plugin determination. Skills are projected
+ * directly from the retained snapshot tree — never copied or converted — while the Bridge holds
+ * provenance. Only independent host evidence may establish Skill Availability as Available,
+ * and a host-verifiable reload through Bridge re-entry is what makes a Runtime Application
+ * Applied.
+ */
+
+import { loadSkillsFromDir } from '@earendil-works/pi-coding-agent';
+
+import type { BridgeState, Scope } from '../bridge-state/types.js';
+import {
+  computeEffectiveState,
+  type EffectiveInstallation,
+  type EffectiveRegistration,
+} from './effective-state.js';
+import {
+  resolveRuntimeSkillCollisions,
+  type CollisionResolution,
+  type SkillCandidate,
+} from './collision.js';
+import { inspectMarketplaceEntries, type MarketplaceInspection } from '../installation/inspection.js';
+import { CODE, RULE, blocking, sortFindings, type ValidationFinding } from '../registration/findings.js';
+import { createReceipt, type AttemptReceipt } from '../registration/receipt.js';
+import { appendReceipt } from '../journal/journal.js';
+
+export interface ProjectionOptions {
+  cwd?: string;
+  agentDir?: string;
+  projectTrusted?: boolean;
+  /** Exact names already claimed by pre-existing Pi skills (host-owned namespace layer). */
+  piSkillNames?: string[];
+  /** Injection seam for tests; defaults to live local-source inspection. */
+  inspectRegistration?: (registration: EffectiveRegistration) => MarketplaceInspection;
+  /** Independent host evidence establishing Skill Availability as Available. */
+  hostAvailabilityEvidence?: (skillName: string) => boolean;
+}
+
+/** A whole-Plugin blocking denial that must hold a Runtime Application short of Applied. */
+export interface RuntimeApplicationInput {
+  /** Exact State Revision the runtime is expected to re-enter at. */
+  stateRevision?: string;
+  scope?: Scope;
+  /** Whole-Plugin Blocking Findings from projection; any one of them denies Applied. */
+  wholePluginFindings?: ValidationFinding[];
+}
+
+export type SkillAvailability = 'available' | 'snapshot-eligible' | 'unverified' | 'unavailable';
+
+export interface ProjectedSkillView {
+  name: string;
+  skillId: string;
+  pluginId: string;
+  status: 'projected' | 'unavailable-collision';
+  availability: SkillAvailability;
+  /** Original snapshot location of SKILL.md exposed through Pi discovery (no copy). */
+  discoveryPath?: string;
+}
+
+export interface ProjectedPluginView {
+  pluginId: string;
+  manifestName?: string;
+  installationId: string;
+  registrationId?: string;
+  sourceScope: 'global' | 'project';
+  skills: ProjectedSkillView[];
+}
+
+export interface DeniedPluginView {
+  installationId: string;
+  pluginId?: string;
+  /** Whole-Plugin blocking denial; never a skill-granular collision. */
+  reason: ValidationFinding;
+}
+
+export interface ProjectionResult {
+  plugins: ProjectedPluginView[];
+  denied: DeniedPluginView[];
+  /** Skill-granular collision denials only; whole-plugin denials live in `denied`. */
+  findings: ValidationFinding[];
+}
+
+function driftFinding(scope: 'global' | 'project'): ValidationFinding {
+  return blocking({
+    code: CODE.SOURCE_DRIFT,
+    rule: RULE.SOURCE_DRIFT,
+    target: 'registration',
+    pointer: '',
+    outcome: 'Source Drift: the registered Validation Snapshot no longer matches the source tree; affected Installations cannot become Projected Plugins until Marketplace Refresh produces an Update Candidate',
+    scope,
+    phase: 'validation',
+  });
+}
+
+function collisionFinding(scope: 'global' | 'project', skillId: string): ValidationFinding {
+  return blocking({
+    code: CODE.RUNTIME_SKILL_COLLISION,
+    rule: RULE.RUNTIME_SKILL_COLLISION,
+    target: 'skill',
+    pointer: skillId,
+    outcome: `Runtime Skill Collision: skill '${skillId}' is unavailable because another candidate claims this exact Skill Descriptor name`,
+    scope,
+    phase: 'validation',
+  });
+}
+
+/**
+ * Compute the projection of one Effective State. Read-only: it never mutates either Bridge
+ * State document and never persists anything.
+ */
+export function projectEffectiveState(
+  globalState: BridgeState,
+  projectState: BridgeState,
+  opts: ProjectionOptions = {},
+): ProjectionResult {
+  const effective = computeEffectiveState(globalState, projectState, { projectTrusted: opts.projectTrusted });
+  const denied: DeniedPluginView[] = [];
+  const findings: ValidationFinding[] = [];
+
+  const inspections = new Map<string, MarketplaceInspection>();
+  const inspect = opts.inspectRegistration ?? ((registration: EffectiveRegistration) => inspectMarketplaceEntries(registration, registration.sourceScope));
+  const inspectionFor = (registration: EffectiveRegistration): MarketplaceInspection => {
+    const key = `${registration.sourceScope}:${registration.id}`;
+    let value = inspections.get(key);
+    if (!value) {
+      value = inspect(registration);
+      inspections.set(key, value);
+    }
+    return value;
+  };
+
+  interface AdmittedPlugin {
+    pluginId: string;
+    manifestName?: string;
+    installationId: string;
+    registrationId?: string;
+    sourceScope: 'global' | 'project';
+    skills: Array<{ name: string; skillId: string; path: string }>;
+  }
+  const admitted: AdmittedPlugin[] = [];
+
+  for (const installation of effective.installations) {
+    const deny = (pluginId: string | undefined, reason: ValidationFinding): void => {
+      denied.push({ installationId: installation.id, pluginId, reason });
+    };
+    const registration = effective.registrations.find(
+      (item) => item.id === installation.registrationId && item.sourceScope === installation.sourceScope,
+    );
+    if (!installation.registrationId || !registration) {
+      deny(installation.pluginId, blocking({
+        code: CODE.INSTALLATION_NOT_FOUND,
+        rule: RULE.INSTALLATION_NOT_FOUND,
+        target: 'installation',
+        pointer: '',
+        outcome: `Installation '${installation.id}' references Registration '${installation.registrationId ?? '?'}' which is not part of Effective State`,
+        scope: installation.sourceScope,
+        phase: 'validation',
+      }));
+      continue;
+    }
+    const inspection = inspectionFor(registration);
+    // Source Drift: the registered snapshot no longer matches the live tree — fail closed.
+    // Registrations persist the base tree fingerprint from their preflight (buildLocalSnapshot);
+    // drift compares only against the same kind of fingerprint, never the activation-bound one.
+    if (
+      registration.validationSnapshot &&
+      inspection.treeFingerprint !== undefined &&
+      inspection.treeFingerprint !== registration.validationSnapshot
+    ) {
+      deny(installation.pluginId, driftFinding(installation.sourceScope));
+      continue;
+    }
+    const entryPointer = installation.marketplaceEntryId
+      ? installation.marketplaceEntryId.slice(installation.marketplaceEntryId.indexOf('/plugins/'))
+      : undefined;
+    const inspected = inspection.entries.find((item) =>
+      entryPointer !== undefined && `${inspection.marketplaceId}${item.entry.entryId}` === installation.marketplaceEntryId,
+    );
+    if (!inspection.marketplaceId || !inspected) {
+      deny(installation.pluginId, blocking({
+        code: CODE.INSTALLATION_NOT_FOUND,
+        rule: RULE.INSTALLATION_NOT_FOUND,
+        target: 'entry',
+        pointer: installation.marketplaceEntryId ?? '',
+        outcome: `Installed Plugin '${installation.id}' cannot be resolved to its Marketplace Entry in the current snapshot`,
+        scope: installation.sourceScope,
+        phase: 'validation',
+      }));
+      continue;
+    }
+    // Whole-Plugin admission: any Whole-Plugin Blocking Finding denies the entire Plugin.
+    if (inspected.unavailableReason || !inspected.plugin || inspected.findings.some((f) => f.classification === 'blocking')) {
+      deny(installation.pluginId, inspected.findings.find((f) => f.classification === 'blocking') ?? blocking({
+        code: CODE.PLUGIN_MANIFEST_INVALID,
+        rule: RULE.PLUGIN_MANIFEST_INVALID,
+        target: 'plugin',
+        pointer: '',
+        outcome: inspected.unavailableReason ?? 'Plugin is not activatable',
+        scope: installation.sourceScope,
+        phase: 'validation',
+      }));
+      continue;
+    }
+    admitted.push({
+      pluginId: inspected.plugin.id,
+      manifestName: inspected.plugin.manifestName,
+      installationId: installation.id,
+      registrationId: registration.id,
+      sourceScope: installation.sourceScope,
+      skills: inspected.plugin.skills.map((skill) => ({
+        name: skill.name,
+        skillId: `${inspected.plugin!.id}/${skill.name}`,
+        path: joinPath(skill.path, 'SKILL.md'),
+      })),
+    });
+  }
+
+  // Runtime Skill Collision resolution across Pi → Project Scope → Global Scope.
+  const candidates: SkillCandidate[] = [
+    ...(opts.piSkillNames ?? []).map((name): SkillCandidate => ({ layer: 'pi', name, skillId: `pi/${name}`, pluginId: '(pi)' })),
+    ...admitted.flatMap((plugin): SkillCandidate[] => plugin.skills.map((skill) => ({
+      layer: plugin.sourceScope,
+      name: skill.name,
+      skillId: skill.skillId,
+      pluginId: plugin.pluginId,
+    }))),
+  ];
+  const resolution: CollisionResolution = resolveRuntimeSkillCollisions(candidates);
+  const survivedIds = new Set(resolution.survivors.map((s) => s.skillId));
+  for (const info of resolution.findings) {
+    for (const skillId of info.unavailableSkillIds) {
+      const owner = admitted.find((plugin) => plugin.skills.some((skill) => skill.skillId === skillId));
+      if (owner) findings.push(collisionFinding(owner.sourceScope, skillId));
+    }
+  }
+
+  const plugins: ProjectedPluginView[] = admitted.map((plugin) => ({
+    pluginId: plugin.pluginId,
+    manifestName: plugin.manifestName,
+    installationId: plugin.installationId,
+    registrationId: plugin.registrationId,
+    sourceScope: plugin.sourceScope,
+    skills: plugin.skills.map((skill): ProjectedSkillView => {
+      if (!survivedIds.has(skill.skillId)) {
+        return { name: skill.name, skillId: skill.skillId, pluginId: plugin.pluginId, status: 'unavailable-collision', availability: 'unavailable' };
+      }
+      // Pi resource-discovery seam: expose the skill at its original snapshot path.
+      let discoveryPath: string | undefined;
+      try {
+        const loaded = loadSkillsFromDir({ dir: dirnamePath(skill.path), source: `codex-marketplace:${plugin.pluginId}` });
+        const match = loaded.skills.find((item) => item.name === skill.name) ?? loaded.skills[0];
+        discoveryPath = match?.filePath;
+      } catch {
+        discoveryPath = undefined;
+      }
+      if (opts.hostAvailabilityEvidence?.(skill.name)) {
+        return { name: skill.name, skillId: skill.skillId, pluginId: plugin.pluginId, status: 'projected', availability: 'available', discoveryPath };
+      }
+      return {
+        name: skill.name,
+        skillId: skill.skillId,
+        pluginId: plugin.pluginId,
+        status: 'projected',
+        // Snapshot-bound eligibility only: Available requires independent host evidence.
+        availability: discoveryPath ? 'snapshot-eligible' : 'unverified',
+        discoveryPath,
+      };
+    }),
+  }));
+
+  return { plugins, denied, findings: sortFindings(findings) };
+}
+
+function joinPath(directory: string, file: string): string {
+  return directory.endsWith('/') ? `${directory}${file}` : `${directory}/${file}`;
+}
+
+function dirnamePath(filePath: string): string {
+  const index = filePath.lastIndexOf('/');
+  return index > 0 ? filePath.slice(0, index) : filePath;
+}
+
+export interface RuntimeApplicationInput {
+  /** Exact State Revision the runtime is expected to re-enter at. */
+  stateRevision?: string;
+  scope?: Scope;
+  cwd?: string;
+  agentDir?: string;
+  recoversReceiptId?: string;
+  /** Whole-Plugin Blocking Findings from projection; any one of them denies Applied. */
+  wholePluginFindings?: ValidationFinding[];
+}
+
+export interface RuntimeApplicationOutcome {
+  outcome: 'applied' | 'pending-application';
+  receipt: AttemptReceipt;
+}
+
+/**
+ * Runtime Application seam: participation in Pi becomes Applied only through
+ * host-verifiable Bridge re-entry at the expected State Revision with no whole-Plugin
+ * Blocking Finding; anything less leaves Pending Application or stays Blocked.
+ */
+export async function requestRuntimeApplication(
+  verifyReload: () => Promise<boolean> | boolean,
+  input: RuntimeApplicationInput = {},
+): Promise<RuntimeApplicationOutcome> {
+  const scope: Scope = input.scope ?? 'project';
+  const stateRevision = input.stateRevision ?? '-';
+  const opts = { cwd: input.cwd, agentDir: input.agentDir };
+
+  if (input.wholePluginFindings?.some((finding) => finding.classification === 'blocking')) {
+    const receipt = createReceipt({
+      kind: 'Runtime Application',
+      operation: 'Runtime Application',
+      scope,
+      trigger: 'reload projected Effective State',
+      expectedStateRevision: stateRevision,
+      durableOutcome: 'unchanged',
+      runtimeOutcome: 'pending-application',
+      summary: 'Pending Application',
+      findings: input.wholePluginFindings,
+      recoversReceiptId: input.recoversReceiptId,
+    });
+    await appendReceipt(scope, receipt, opts);
+    return {
+      outcome: 'pending-application',
+      receipt,
+    };
+  }
+
+  const applied = await verifyReload();
+  const receipt = createReceipt({
+    kind: 'Runtime Application',
+    operation: 'Runtime Application',
+    scope,
+    trigger: 'reload projected Effective State',
+    expectedStateRevision: stateRevision,
+    observedStateRevision: applied ? stateRevision : undefined,
+    durableOutcome: 'unchanged',
+    runtimeOutcome: applied ? 'applied' : 'pending-application',
+    summary: applied ? 'Completed' : 'Pending Application',
+    recoversReceiptId: input.recoversReceiptId,
+  });
+  await appendReceipt(scope, receipt, opts);
+
+  return {
+    outcome: applied ? 'applied' : 'pending-application',
+    receipt,
+  };
+}
+