@remnic/core 9.7.10 → 9.7.12

package/dist/chunk-TITSEN2M.js

@@ -0,0 +1,1794 @@
+import {
+  memoryStoreRequestSchema
+} from "./chunk-2MR3MFQB.js";
+import {
+  defineOperation
+} from "./chunk-CE3GMHT4.js";
+import {
+  CorrectionContractError,
+  DECISION_SUBCOMMANDS,
+  DELTA_SUBCOMMANDS,
+  EngramAccessInputError,
+  isCodegraphToolName
+} from "./chunk-QPZCAVDC.js";
+import {
+  serializeMutations,
+  withHeldFileLock
+} from "./chunk-LTJAMRGI.js";
+
+// src/access-operations.ts
+import { z as z3 } from "zod";
+
+// src/relay/mission-access.ts
+import { z as z2 } from "zod";
+
+// src/relay/mission.ts
+import { createHash, randomUUID } from "crypto";
+import { promises as fs, constants as fsConstants } from "fs";
+import path from "path";
+import { z } from "zod";
+var RELAY_MISSION_SCHEMA_VERSION = "1";
+var RELAY_MISSION_MAX_FILE_BYTES = 4 * 1024 * 1024;
+var RELAY_MISSION_MAX_LINE_BYTES = 64 * 1024;
+var RELAY_MISSION_MAX_EVENTS = 2e3;
+var RELAY_MISSION_DEFAULT_EVENT_LIMIT = 200;
+var RELAY_MISSION_MAX_EVENT_LIMIT = 500;
+var RelayMissionIdSchema = z.string().min(1).max(64).regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/, {
+  message: "must contain only lowercase letters, numbers, and single hyphens"
+});
+var identifierSchema = z.string().min(1).max(128).regex(/^[A-Za-z0-9](?:[A-Za-z0-9._:@-]{0,126}[A-Za-z0-9])?$/, {
+  message: "must be a bounded identifier"
+});
+var namespaceSchema = z.string().trim().min(1).max(128);
+var authenticatedPrincipalSchema = z.string().trim().min(1).max(256);
+var shortTextSchema = z.string().trim().min(1).max(240);
+var statementSchema = z.string().trim().min(1).max(4e3);
+var uniqueIdentifierListSchema = (minimum, maximum) => z.array(identifierSchema).min(minimum).max(maximum).refine((values) => new Set(values).size === values.length, "must not contain duplicate identifiers");
+var RelayIsoDateTimeSchema = z.string().datetime({ offset: true }).refine((value) => Number.isFinite(Date.parse(value)), "must be a representable timestamp");
+var RelayEvidenceRefSchema = z.object({
+  kind: z.enum(["memory", "recall_audit", "source", "test", "commit", "correction", "agent_output", "approval"]),
+  id: identifierSchema,
+  label: shortTextSchema,
+  locator: z.string().trim().min(1).max(2048).optional(),
+  capture: z.enum(["at_action", "historical_lookup", "fixture"])
+}).strict();
+var evidenceListSchema = z.array(RelayEvidenceRefSchema).max(16);
+var agentIdentityFields = {
+  agentId: identifierSchema,
+  sessionId: identifierSchema
+};
+var RelayMissionPayloadUnionSchema = z.discriminatedUnion("kind", [
+  z.object({
+    kind: z.literal("mission_started"),
+    title: shortTextSchema,
+    objective: statementSchema,
+    runMode: z.enum(["live", "replay", "fixture"]),
+    evidence: evidenceListSchema.default([])
+  }).strict(),
+  z.object({
+    kind: z.literal("agent_status"),
+    ...agentIdentityFields,
+    label: shortTextSchema,
+    role: shortTextSchema,
+    status: z.enum(["idle", "working", "blocked", "complete", "failed"]),
+    detail: statementSchema.optional(),
+    evidence: evidenceListSchema.default([])
+  }).strict(),
+  z.object({
+    kind: z.literal("agent_output"),
+    ...agentIdentityFields,
+    outputId: identifierSchema,
+    summary: statementSchema,
+    evidence: evidenceListSchema.default([])
+  }).strict(),
+  z.object({
+    kind: z.literal("belief_observed"),
+    ...agentIdentityFields,
+    beliefId: identifierSchema,
+    decisionId: identifierSchema,
+    statement: statementSchema,
+    confidence: z.number().finite().min(0).max(1).optional(),
+    evidence: evidenceListSchema.default([])
+  }).strict(),
+  z.object({
+    kind: z.literal("conflict_detected"),
+    conflictId: identifierSchema,
+    decisionIds: uniqueIdentifierListSchema(2, 8),
+    agentIds: uniqueIdentifierListSchema(2, 16),
+    summary: statementSchema,
+    evidence: evidenceListSchema.default([])
+  }).strict(),
+  z.object({
+    kind: z.literal("test_result"),
+    testId: identifierSchema,
+    decisionId: identifierSchema,
+    correctionId: identifierSchema.optional(),
+    command: z.string().trim().min(1).max(1e3),
+    status: z.enum(["passed", "failed", "error"]),
+    summary: statementSchema,
+    durationMs: z.number().int().nonnegative().max(36e5).optional(),
+    evidence: evidenceListSchema.default([])
+  }).strict(),
+  z.object({
+    kind: z.literal("correction_proposed"),
+    correctionId: identifierSchema,
+    conflictId: identifierSchema,
+    proposedDecisionId: identifierSchema,
+    supersedesDecisionIds: uniqueIdentifierListSchema(1, 8),
+    statement: statementSchema,
+    rationale: statementSchema,
+    proposedBy: identifierSchema,
+    evidence: evidenceListSchema.default([])
+  }).strict(),
+  z.object({
+    kind: z.literal("correction_approved"),
+    correctionId: identifierSchema,
+    approvedBy: z.object({
+      kind: z.enum(["human", "agent"]),
+      id: identifierSchema,
+      label: shortTextSchema
+    }).strict(),
+    note: statementSchema.optional(),
+    evidence: evidenceListSchema.default([])
+  }).strict(),
+  z.object({
+    kind: z.literal("decision_superseded"),
+    decisionId: identifierSchema,
+    replacementDecisionId: identifierSchema,
+    correctionId: identifierSchema,
+    evidence: evidenceListSchema.default([])
+  }).strict(),
+  z.object({
+    kind: z.literal("recall_observed"),
+    ...agentIdentityFields,
+    recallReceiptId: identifierSchema,
+    decisionId: identifierSchema,
+    query: statementSchema,
+    capturedAtAction: z.boolean(),
+    evidence: evidenceListSchema.default([])
+  }).strict(),
+  z.object({
+    kind: z.literal("propagation_verified"),
+    ...agentIdentityFields,
+    correctionId: identifierSchema,
+    decisionId: identifierSchema,
+    recallReceiptId: identifierSchema,
+    staleDecisionAbsent: z.boolean(),
+    evidence: evidenceListSchema.default([])
+  }).strict(),
+  z.object({
+    kind: z.literal("mission_completed"),
+    outcome: z.enum(["recovered", "failed", "inconclusive"]),
+    summary: statementSchema,
+    evidence: evidenceListSchema.default([])
+  }).strict()
+]);
+var RelayMissionPayloadSchema = RelayMissionPayloadUnionSchema.superRefine((value, ctx) => {
+  if (value.kind === "decision_superseded" && value.decisionId === value.replacementDecisionId) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: "a decision cannot supersede itself",
+      path: ["replacementDecisionId"]
+    });
+  }
+  if (value.kind === "correction_approved" && !value.evidence.some((item) => item.kind === "approval")) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: "correction approval requires approval evidence",
+      path: ["evidence"]
+    });
+  }
+  if (value.kind === "decision_superseded" && !value.evidence.some((item) => item.kind === "correction" && item.id === value.correctionId)) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: "decision supersession requires matching correction evidence",
+      path: ["evidence"]
+    });
+  }
+  if (value.kind !== "recall_observed" && value.kind !== "propagation_verified") return;
+  const matchingRecallEvidence = value.evidence.find(
+    (item) => item.kind === "recall_audit" && item.id === value.recallReceiptId
+  );
+  if (!matchingRecallEvidence) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: "recall proof requires a matching recall-audit reference",
+      path: ["evidence"]
+    });
+    return;
+  }
+  if (value.kind === "recall_observed") {
+    const expectedCapture = value.capturedAtAction ? "at_action" : "historical_lookup";
+    if (matchingRecallEvidence.capture !== expectedCapture && matchingRecallEvidence.capture !== "fixture") {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: `recall evidence must be labeled ${expectedCapture}`,
+        path: ["evidence", value.evidence.indexOf(matchingRecallEvidence), "capture"]
+      });
+    }
+  }
+});
+var RelayMissionEventInputSchema = z.object({
+  occurredAt: RelayIsoDateTimeSchema.optional(),
+  idempotencyKey: identifierSchema.optional(),
+  payload: RelayMissionPayloadSchema
+}).strict();
+var RelayMissionEventSchema = z.object({
+  schemaVersion: z.literal(RELAY_MISSION_SCHEMA_VERSION),
+  eventId: identifierSchema,
+  missionId: RelayMissionIdSchema,
+  namespace: namespaceSchema,
+  authenticatedPrincipal: authenticatedPrincipalSchema.optional(),
+  recordedAt: RelayIsoDateTimeSchema,
+  occurredAt: RelayIsoDateTimeSchema,
+  idempotencyKey: identifierSchema.optional(),
+  payload: RelayMissionPayloadSchema
+}).strict();
+var RelayMissionReadOptionsSchema = z.object({
+  since: RelayIsoDateTimeSchema.optional(),
+  until: RelayIsoDateTimeSchema.optional(),
+  limit: z.number().int().min(1).max(RELAY_MISSION_MAX_EVENT_LIMIT).default(RELAY_MISSION_DEFAULT_EVENT_LIMIT)
+}).strict().refine(
+  (value) => value.since === void 0 || value.until === void 0 || Date.parse(value.since) < Date.parse(value.until),
+  { message: "since must be earlier than until", path: ["until"] }
+);
+var RelayMissionStoreError = class extends Error {
+  constructor(code, message, options) {
+    super(message, options);
+    this.code = code;
+    this.name = "RelayMissionStoreError";
+  }
+  code;
+};
+var RelayMissionStore = class {
+  rootDir;
+  namespace;
+  now;
+  createEventId;
+  maxFileBytes;
+  maxEvents;
+  lockMaxWaitMs;
+  constructor(options) {
+    if (typeof options.rootDir !== "string" || options.rootDir.trim().length === 0) {
+      throw new TypeError("RelayMissionStore rootDir must be a non-empty string");
+    }
+    this.rootDir = path.resolve(options.rootDir);
+    this.namespace = namespaceSchema.parse(options.namespace);
+    this.now = options.now ?? (() => /* @__PURE__ */ new Date());
+    this.createEventId = options.createEventId ?? (() => `relay-${randomUUID()}`);
+    this.maxFileBytes = positiveIntegerOption(options.maxFileBytes, "maxFileBytes", RELAY_MISSION_MAX_FILE_BYTES);
+    this.maxEvents = positiveIntegerOption(options.maxEvents, "maxEvents", RELAY_MISSION_MAX_EVENTS);
+    this.lockMaxWaitMs = positiveIntegerOption(options.lockMaxWaitMs, "lockMaxWaitMs", 5e3);
+  }
+  async append(missionIdValue, inputValue, hooks = {}) {
+    const missionId = RelayMissionIdSchema.parse(missionIdValue);
+    const input = RelayMissionEventInputSchema.parse(inputValue);
+    const authenticatedPrincipal = hooks.authenticatedPrincipal === void 0 ? void 0 : authenticatedPrincipalSchema.parse(hooks.authenticatedPrincipal);
+    const missionDir = await this.openMissionDirectory(true);
+    const filePath = path.join(missionDir.accessPath, `${missionId}.jsonl`);
+    const logicalFilePath = path.join(missionDir.logicalPath, `${missionId}.jsonl`);
+    const lockPath = `${filePath}.lock`;
+    try {
+      return await serializeMutations(
+        `relay-mission:${logicalFilePath}`,
+        () => withHeldFileLock(
+          lockPath,
+          { staleMs: 3e4, maxWaitMs: this.lockMaxWaitMs, heartbeatMs: 1e4 },
+          async (acquired) => {
+            if (!acquired) {
+              throw new RelayMissionStoreError("lock_unavailable", "could not acquire Relay mission lock");
+            }
+            const existing = await this.readFile(filePath, missionId);
+            if (input.idempotencyKey) {
+              const replay = existing.events.find((event2) => event2.idempotencyKey === input.idempotencyKey);
+              if (replay) {
+                if (!sameIdempotentInput(replay, input, authenticatedPrincipal)) {
+                  throw new RelayMissionStoreError(
+                    "idempotency_conflict",
+                    `idempotency key ${input.idempotencyKey} was already used for different input`
+                  );
+                }
+                return { appended: false, replayed: true, event: replay };
+              }
+            }
+            if (existing.events.length >= this.maxEvents) {
+              throw new RelayMissionStoreError(
+                "limit_exceeded",
+                `mission ${missionId} reached the ${this.maxEvents}-event limit`
+              );
+            }
+            await hooks.beforeAppend?.();
+            const recordedAt = validNow(this.now);
+            const event = RelayMissionEventSchema.parse({
+              schemaVersion: RELAY_MISSION_SCHEMA_VERSION,
+              eventId: this.createEventId(),
+              missionId,
+              namespace: this.namespace,
+              ...authenticatedPrincipal === void 0 ? {} : { authenticatedPrincipal },
+              recordedAt,
+              occurredAt: input.occurredAt ?? recordedAt,
+              ...input.idempotencyKey ? { idempotencyKey: input.idempotencyKey } : {},
+              payload: input.payload
+            });
+            const line = `${JSON.stringify(event)}
+`;
+            const lineBytes = Buffer.byteLength(line, "utf8");
+            if (lineBytes > RELAY_MISSION_MAX_LINE_BYTES) {
+              throw new RelayMissionStoreError(
+                "limit_exceeded",
+                `Relay mission event exceeds ${RELAY_MISSION_MAX_LINE_BYTES} bytes`
+              );
+            }
+            if (existing.rawBytes + lineBytes > this.maxFileBytes) {
+              throw new RelayMissionStoreError(
+                "limit_exceeded",
+                `mission ${missionId} would exceed the ${this.maxFileBytes}-byte limit`
+              );
+            }
+            await this.appendFile(filePath, line);
+            return { appended: true, replayed: false, event };
+          }
+        )
+      );
+    } finally {
+      await missionDir.handle.close().catch(() => void 0);
+    }
+  }
+  async read(missionIdValue, readOptions = {}) {
+    const missionId = RelayMissionIdSchema.parse(missionIdValue);
+    const options = RelayMissionReadOptionsSchema.parse(readOptions);
+    const missionDir = await this.openMissionDirectory(false);
+    if (missionDir === null) {
+      return reduceRelayMission({
+        missionId,
+        namespace: this.namespace,
+        events: [],
+        fileExists: false,
+        options
+      });
+    }
+    const filePath = path.join(missionDir.accessPath, `${missionId}.jsonl`);
+    const logicalFilePath = path.join(missionDir.logicalPath, `${missionId}.jsonl`);
+    try {
+      return await serializeMutations(`relay-mission:${logicalFilePath}`, async () => {
+        const read = await this.readFile(filePath, missionId);
+        return reduceRelayMission({
+          missionId,
+          namespace: this.namespace,
+          events: read.events,
+          corruptLines: read.corruptLines,
+          fileExists: read.exists,
+          options
+        });
+      });
+    } finally {
+      await missionDir.handle.close().catch(() => void 0);
+    }
+  }
+  async openMissionDirectory(create) {
+    let currentHandle;
+    try {
+      currentHandle = await openVerifiedDirectory(this.rootDir, "Relay root must be a real directory");
+      let logicalPath = this.rootDir;
+      for (const segment of ["state", "relay", "missions"]) {
+        let childHandle;
+        try {
+          childHandle = create ? await openOrCreatePinnedChildDirectory(currentHandle, segment) : await openVerifiedDirectory(
+            path.join(pinnedDirectoryPath(currentHandle), segment),
+            "Relay directory symlinks are rejected"
+          );
+        } catch (error) {
+          if (!create && error.code === "ENOENT") {
+            await currentHandle.close();
+            return null;
+          }
+          throw error;
+        }
+        await currentHandle.close();
+        currentHandle = childHandle;
+        logicalPath = path.join(logicalPath, segment);
+      }
+      return {
+        logicalPath,
+        accessPath: pinnedDirectoryPath(currentHandle),
+        handle: currentHandle
+      };
+    } catch (error) {
+      await currentHandle?.close().catch(() => void 0);
+      if (error instanceof RelayMissionStoreError) throw error;
+      throw new RelayMissionStoreError("unsafe_path", "Relay mission directory is unavailable or unsafe", {
+        cause: error
+      });
+    }
+  }
+  async readFile(filePath, missionId) {
+    let handle;
+    try {
+      handle = await fs.open(filePath, fsConstants.O_RDONLY | fsConstants.O_NOFOLLOW);
+      const info = await handle.stat();
+      if (!info.isFile()) {
+        throw new RelayMissionStoreError("unsafe_path", "Relay mission path is not a file");
+      }
+      if (info.nlink !== 1) {
+        throw new RelayMissionStoreError("unsafe_path", "Relay mission hard links are rejected");
+      }
+      if (info.size > this.maxFileBytes) {
+        throw new RelayMissionStoreError(
+          "limit_exceeded",
+          `mission ${missionId} exceeds the ${this.maxFileBytes}-byte read limit`
+        );
+      }
+      const raw = await handle.readFile("utf8");
+      const parsed = parseMissionJsonl(raw, missionId, this.namespace, this.maxEvents);
+      return { exists: true, rawBytes: Buffer.byteLength(raw, "utf8"), ...parsed };
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        return { exists: false, events: [], corruptLines: 0, rawBytes: 0 };
+      }
+      if (error instanceof RelayMissionStoreError) throw error;
+      throw new RelayMissionStoreError("read_failed", "failed to read Relay mission", {
+        cause: error
+      });
+    } finally {
+      await handle?.close().catch(() => void 0);
+    }
+  }
+  async appendFile(filePath, line) {
+    let handle;
+    try {
+      handle = await fs.open(
+        filePath,
+        fsConstants.O_WRONLY | fsConstants.O_CREAT | fsConstants.O_APPEND | fsConstants.O_NOFOLLOW,
+        384
+      );
+      const info = await handle.stat();
+      if (!info.isFile()) {
+        throw new RelayMissionStoreError("unsafe_path", "Relay mission path is not a file");
+      }
+      if (info.nlink !== 1) {
+        throw new RelayMissionStoreError("unsafe_path", "Relay mission hard links are rejected");
+      }
+      await handle.chmod(384);
+      await handle.writeFile(line, "utf8");
+      await handle.sync();
+    } catch (error) {
+      if (error instanceof RelayMissionStoreError) throw error;
+      if (error.code === "ELOOP") {
+        throw new RelayMissionStoreError("unsafe_path", "Relay mission symlink is rejected", {
+          cause: error
+        });
+      }
+      throw new RelayMissionStoreError("write_failed", "failed to append Relay mission", {
+        cause: error
+      });
+    } finally {
+      await handle?.close().catch(() => void 0);
+    }
+  }
+};
+function reduceRelayMission(input) {
+  const missionId = RelayMissionIdSchema.parse(input.missionId);
+  const namespace = namespaceSchema.parse(input.namespace);
+  const options = RelayMissionReadOptionsSchema.parse(input.options ?? {});
+  const corruptLines = input.corruptLines ?? 0;
+  const sinceMs = options.since ? Date.parse(options.since) : void 0;
+  const untilMs = options.until ? Date.parse(options.until) : void 0;
+  const appendPositions = new Map(input.events.map((event, index) => [event, index]));
+  const orderedEvents = [...input.events].sort(compareRelayEvents);
+  const firstStartEvent = input.events.find((event) => event.payload.kind === "mission_started");
+  const firstCompletionEvent = input.events.find((event) => event.payload.kind === "mission_completed");
+  const firstStartPosition = firstStartEvent === void 0 ? -1 : appendPositions.get(firstStartEvent) ?? -1;
+  const firstCompletionPosition = firstCompletionEvent === void 0 ? -1 : appendPositions.get(firstCompletionEvent) ?? -1;
+  const filteredEvents = orderedEvents.filter((event) => {
+    const occurredAt = Date.parse(event.occurredAt);
+    return (sinceMs === void 0 || occurredAt >= sinceMs) && (untilMs === void 0 || occurredAt < untilMs);
+  });
+  const agents = /* @__PURE__ */ new Map();
+  const decisions = /* @__PURE__ */ new Map();
+  const conflicts = /* @__PURE__ */ new Map();
+  const corrections = /* @__PURE__ */ new Map();
+  const tests = [];
+  const propagation = [];
+  const beliefAppendPositions = /* @__PURE__ */ new Map();
+  const conflictAppendPositions = /* @__PURE__ */ new Map();
+  const correctionProposalAppendPositions = /* @__PURE__ */ new Map();
+  const correctionApprovalAppendPositions = /* @__PURE__ */ new Map();
+  const correctionAppliedAppendPositions = /* @__PURE__ */ new Map();
+  const recallAppendPositions = /* @__PURE__ */ new Map();
+  const propagationAppendPositions = /* @__PURE__ */ new Map();
+  const testAppendPositions = /* @__PURE__ */ new Map();
+  const missingEvidence = /* @__PURE__ */ new Set();
+  if (corruptLines > 0) missingEvidence.add("mission:corrupt-events");
+  const substantiveAgentIds = /* @__PURE__ */ new Set();
+  const substantiveSessionIds = /* @__PURE__ */ new Set();
+  const conflictDisagreementIds = /* @__PURE__ */ new Set();
+  const groundedCorrectionIds = /* @__PURE__ */ new Set();
+  let title = null;
+  let objective = null;
+  let runMode = null;
+  let startedAt = null;
+  let completedAt = null;
+  let status = "not_started";
+  let outcome = null;
+  const ensureAgent = (agentId, sessionId, occurredAt) => {
+    const existing = agents.get(agentId);
+    if (existing) {
+      if (!existing.sessionIds.includes(sessionId)) existing.sessionIds.push(sessionId);
+      existing.lastSeenAt = occurredAt;
+      return existing;
+    }
+    const created = {
+      agentId,
+      label: agentId,
+      role: "Codex agent",
+      status: "working",
+      sessionIds: [sessionId],
+      outputs: [],
+      recalls: [],
+      lastSeenAt: occurredAt
+    };
+    agents.set(agentId, created);
+    return created;
+  };
+  const markSubstantiveParticipation = (agentId, sessionId) => {
+    substantiveAgentIds.add(agentId);
+    if (sessionId) substantiveSessionIds.add(sessionId);
+  };
+  for (const event of orderedEvents) {
+    const payload = event.payload;
+    const appendPosition = appendPositions.get(event) ?? -1;
+    if (payload.kind !== "mission_started" && firstStartEvent !== void 0 && (appendPosition < firstStartPosition || compareRelayEvents(event, firstStartEvent) < 0)) {
+      missingEvidence.add(`mission:event-before-start:${event.eventId}`);
+      collectMissingEvidence(missingEvidence, event, payload.evidence);
+      continue;
+    }
+    if (payload.kind !== "mission_completed" && (outcome !== null || firstCompletionPosition >= 0 && appendPosition > firstCompletionPosition)) {
+      missingEvidence.add(`mission:event-after-completion:${event.eventId}`);
+      if (payload.kind === "mission_started") missingEvidence.add("mission:lifecycle-order");
+      collectMissingEvidence(missingEvidence, event, payload.evidence);
+      continue;
+    }
+    switch (payload.kind) {
+      case "mission_started":
+        if (startedAt !== null) {
+          missingEvidence.add("mission:duplicate-start");
+          collectMissingEvidence(missingEvidence, event, payload.evidence);
+          break;
+        }
+        title = payload.title;
+        objective = payload.objective;
+        runMode = payload.runMode;
+        startedAt = event.occurredAt;
+        if (outcome === null) status = "active";
+        collectMissingEvidence(missingEvidence, event, payload.evidence);
+        break;
+      case "agent_status": {
+        const agent = ensureAgent(payload.agentId, payload.sessionId, event.occurredAt);
+        markSubstantiveParticipation(payload.agentId, payload.sessionId);
+        agent.label = payload.label;
+        agent.role = payload.role;
+        agent.status = payload.status;
+        collectMissingEvidence(missingEvidence, event, payload.evidence);
+        break;
+      }
+      case "agent_output": {
+        const agent = ensureAgent(payload.agentId, payload.sessionId, event.occurredAt);
+        markSubstantiveParticipation(payload.agentId, payload.sessionId);
+        agent.outputs.push({
+          outputId: payload.outputId,
+          summary: payload.summary,
+          occurredAt: event.occurredAt,
+          evidence: payload.evidence
+        });
+        collectMissingEvidence(missingEvidence, event, payload.evidence);
+        break;
+      }
+      case "belief_observed": {
+        ensureAgent(payload.agentId, payload.sessionId, event.occurredAt);
+        markSubstantiveParticipation(payload.agentId, payload.sessionId);
+        recordEarliestAppendPosition(
+          beliefAppendPositions,
+          beliefAppendPositionKey(payload.agentId, payload.decisionId),
+          appendPosition
+        );
+        const existing = decisions.get(payload.decisionId);
+        if (existing) {
+          if (!decisionStatementsMatch(existing.statement, payload.statement)) {
+            missingEvidence.add(`decision:${payload.decisionId}:statement-consistency`);
+          }
+          if (!existing.heldByAgentIds.includes(payload.agentId)) {
+            existing.heldByAgentIds.push(payload.agentId);
+          }
+          if (!existing.beliefIds.includes(payload.beliefId)) existing.beliefIds.push(payload.beliefId);
+          existing.evidence.push(...payload.evidence);
+        } else {
+          decisions.set(payload.decisionId, {
+            decisionId: payload.decisionId,
+            statement: payload.statement,
+            status: "active",
+            heldByAgentIds: [payload.agentId],
+            beliefIds: [payload.beliefId],
+            evidence: [...payload.evidence],
+            firstObservedAt: event.occurredAt
+          });
+        }
+        collectMissingEvidence(missingEvidence, event, payload.evidence);
+        break;
+      }
+      case "conflict_detected": {
+        recordEarliestAppendPosition(conflictAppendPositions, payload.conflictId, appendPosition);
+        const normalizedDecisionStatements = payload.decisionIds.map((decisionId) => decisions.get(decisionId)?.statement).filter((statement) => statement !== void 0).map(normalizeDecisionStatement);
+        if (normalizedDecisionStatements.length !== payload.decisionIds.length || new Set(normalizedDecisionStatements).size < 2) {
+          missingEvidence.add(`conflict:${payload.conflictId}:distinct-decision-statements`);
+        } else {
+          conflictDisagreementIds.add(payload.conflictId);
+        }
+        const participantHoldings = payload.agentIds.map((agentId) => ({
+          agentId,
+          decisionIds: uniqueSorted(
+            payload.decisionIds.filter((decisionId) => decisions.get(decisionId)?.heldByAgentIds.includes(agentId))
+          )
+        }));
+        for (const participant of participantHoldings) {
+          if (participant.decisionIds.length === 0) {
+            missingEvidence.add(`conflict:${payload.conflictId}:participant:${participant.agentId}:decision-link`);
+          }
+        }
+        for (const decisionId of payload.decisionIds) {
+          if (!participantHoldings.some((participant) => participant.decisionIds.includes(decisionId))) {
+            missingEvidence.add(`conflict:${payload.conflictId}:decision:${decisionId}:participant-link`);
+          }
+          if (!payload.agentIds.some(
+            (agentId) => (beliefAppendPositions.get(beliefAppendPositionKey(agentId, decisionId)) ?? Number.POSITIVE_INFINITY) < appendPosition
+          )) {
+            missingEvidence.add(`conflict:${payload.conflictId}:decision:${decisionId}:append-order`);
+          }
+        }
+        for (const agentId of payload.agentIds) {
+          if (!payload.decisionIds.some(
+            (decisionId) => (beliefAppendPositions.get(beliefAppendPositionKey(agentId, decisionId)) ?? Number.POSITIVE_INFINITY) < appendPosition
+          )) {
+            missingEvidence.add(`conflict:${payload.conflictId}:participant:${agentId}:append-order`);
+          }
+        }
+        if (participantHoldings.every((participant) => participant.decisionIds.length > 0) && new Set(participantHoldings.map((participant) => participant.decisionIds.join("\0"))).size < 2) {
+          missingEvidence.add(`conflict:${payload.conflictId}:distinct-participant-beliefs`);
+        }
+        if (conflicts.has(payload.conflictId)) {
+          missingEvidence.add(`conflict:${payload.conflictId}:duplicate`);
+        } else {
+          conflicts.set(payload.conflictId, {
+            conflictId: payload.conflictId,
+            decisionIds: uniqueSorted(payload.decisionIds),
+            agentIds: uniqueSorted(payload.agentIds),
+            summary: payload.summary,
+            status: "open",
+            occurredAt: event.occurredAt,
+            evidence: payload.evidence
+          });
+        }
+        for (const agentId of payload.agentIds) substantiveAgentIds.add(agentId);
+        collectMissingEvidence(missingEvidence, event, payload.evidence);
+        break;
+      }
+      case "test_result": {
+        const testSnapshot = {
+          testId: payload.testId,
+          decisionId: payload.decisionId,
+          ...payload.correctionId === void 0 ? {} : { correctionId: payload.correctionId },
+          command: payload.command,
+          status: payload.status,
+          summary: payload.summary,
+          ...payload.durationMs === void 0 ? {} : { durationMs: payload.durationMs },
+          occurredAt: event.occurredAt,
+          evidence: payload.evidence
+        };
+        tests.push(testSnapshot);
+        testAppendPositions.set(testSnapshot, appendPosition);
+        collectMissingEvidence(missingEvidence, event, payload.evidence);
+        break;
+      }
+      case "correction_proposed": {
+        if (corrections.has(payload.correctionId)) {
+          missingEvidence.add(`correction:${payload.correctionId}:duplicate-proposal`);
+          collectMissingEvidence(missingEvidence, event, payload.evidence);
+          break;
+        }
+        substantiveAgentIds.add(payload.proposedBy);
+        const correction = {
+          correctionId: payload.correctionId,
+          conflictId: payload.conflictId,
+          proposedDecisionId: payload.proposedDecisionId,
+          supersedesDecisionIds: uniqueSorted(payload.supersedesDecisionIds),
+          statement: payload.statement,
+          rationale: payload.rationale,
+          proposedBy: payload.proposedBy,
+          status: "proposed",
+          proposedAt: event.occurredAt,
+          evidence: [...payload.evidence]
+        };
+        corrections.set(payload.correctionId, correction);
+        correctionProposalAppendPositions.set(payload.correctionId, appendPosition);
+        const existingProposedDecision = decisions.get(payload.proposedDecisionId);
+        const replacementStatementMatches = existingProposedDecision === void 0 || decisionStatementsMatch(existingProposedDecision.statement, payload.statement);
+        if (!replacementStatementMatches) {
+          missingEvidence.add(`correction:${payload.correctionId}:replacement-statement`);
+        }
+        if (existingProposedDecision === void 0) {
+          decisions.set(payload.proposedDecisionId, {
+            decisionId: payload.proposedDecisionId,
+            statement: payload.statement,
+            status: "proposed",
+            heldByAgentIds: [],
+            beliefIds: [],
+            evidence: [...payload.evidence],
+            firstObservedAt: event.occurredAt
+          });
+        }
+        const conflict = conflicts.get(payload.conflictId);
+        const conflictAppendPosition = conflictAppendPositions.get(payload.conflictId);
+        const conflictPredatesProposal = conflictAppendPosition !== void 0 && conflictAppendPosition < appendPosition;
+        if (!conflictPredatesProposal) {
+          missingEvidence.add(`correction:${payload.correctionId}:conflict-append-order`);
+        }
+        const correctionSourceIds = sourceEvidenceIds(payload.evidence);
+        if (correctionSourceIds.size === 0) {
+          missingEvidence.add(`correction:${payload.correctionId}:source`);
+        }
+        if (conflict) {
+          const conflictSourceIds = sourceEvidenceIds(conflict.evidence);
+          if (conflictSourceIds.size === 0) {
+            missingEvidence.add(`conflict:${payload.conflictId}:source`);
+          }
+          const sourceLinked = [...correctionSourceIds].some((sourceId) => conflictSourceIds.has(sourceId));
+          if (!sourceLinked) {
+            missingEvidence.add(`correction:${payload.correctionId}:source-link`);
+          }
+          if (!correctionCoversConflict(correction, conflict)) {
+            missingEvidence.add(`conflict:${payload.conflictId}:decision-link`);
+          } else if (sourceLinked && conflictPredatesProposal && conflictDisagreementIds.has(payload.conflictId) && replacementStatementMatches) {
+            groundedCorrectionIds.add(payload.correctionId);
+            conflict.status = "proposed";
+            conflict.correctionId = payload.correctionId;
+          }
+        } else {
+          missingEvidence.add(`conflict:${payload.conflictId}:observation`);
+        }
+        status = "awaiting_approval";
+        collectMissingEvidence(missingEvidence, event, payload.evidence);
+        break;
+      }
+      case "correction_approved": {
+        if (payload.approvedBy.kind === "agent") substantiveAgentIds.add(payload.approvedBy.id);
+        const correction = corrections.get(payload.correctionId);
+        if (correction) {
+          const proposalAppendPosition = correctionProposalAppendPositions.get(payload.correctionId);
+          const proposalPredatesApproval = proposalAppendPosition !== void 0 && proposalAppendPosition < appendPosition;
+          const authenticatedHumanApproval = payload.approvedBy.kind !== "human" || runMode !== "live" || event.authenticatedPrincipal === payload.approvedBy.id;
+          if (!proposalPredatesApproval) {
+            missingEvidence.add(`correction:${payload.correctionId}:approval-append-order`);
+          } else if (!authenticatedHumanApproval) {
+            missingEvidence.add(`correction:${payload.correctionId}:authenticated-human-approval`);
+          } else if (correction.approvedAt === void 0) {
+            correction.approvedAt = event.occurredAt;
+            correction.approvedBy = payload.approvedBy;
+            correction.approvalNote = payload.note;
+            if (event.authenticatedPrincipal !== void 0) {
+              correction.approvalPrincipal = event.authenticatedPrincipal;
+            }
+            correctionApprovalAppendPositions.set(payload.correctionId, appendPosition);
+            if (correction.status === "proposed") correction.status = "approved";
+            status = "correcting";
+          } else {
+            missingEvidence.add(`correction:${payload.correctionId}:duplicate-approval`);
+          }
+          correction.evidence.push(...payload.evidence);
+        } else {
+          missingEvidence.add(`correction:${payload.correctionId}:proposal`);
+        }
+        collectMissingEvidence(missingEvidence, event, payload.evidence);
+        break;
+      }
+      case "decision_superseded": {
+        const correction = corrections.get(payload.correctionId);
+        if (!correction) {
+          missingEvidence.add(`correction:${payload.correctionId}:proposal`);
+          collectMissingEvidence(missingEvidence, event, payload.evidence);
+          break;
+        }
+        if (correction.approvedAt === void 0 || correction.approvedBy === void 0) {
+          missingEvidence.add(`correction:${payload.correctionId}:approval`);
+          collectMissingEvidence(missingEvidence, event, payload.evidence);
+          break;
+        }
+        const approvalAppendPosition = correctionApprovalAppendPositions.get(payload.correctionId);
+        if (approvalAppendPosition === void 0 || approvalAppendPosition >= appendPosition) {
+          missingEvidence.add(`correction:${payload.correctionId}:approval-append-order`);
+          collectMissingEvidence(missingEvidence, event, payload.evidence);
+          break;
+        }
+        const conflict = conflicts.get(correction.conflictId);
+        if (!conflict || !correctionCoversConflict(correction, conflict)) {
+          missingEvidence.add(`conflict:${correction.conflictId}:decision-link`);
+          collectMissingEvidence(missingEvidence, event, payload.evidence);
+          break;
+        }
+        if (!groundedCorrectionIds.has(payload.correctionId)) {
+          missingEvidence.add(`correction:${payload.correctionId}:source-link`);
+          collectMissingEvidence(missingEvidence, event, payload.evidence);
+          break;
+        }
+        if (!correction.supersedesDecisionIds.includes(payload.decisionId) || correction.proposedDecisionId !== payload.replacementDecisionId) {
+          missingEvidence.add(`correction:${payload.correctionId}:supersession-link`);
+          collectMissingEvidence(missingEvidence, event, payload.evidence);
+          break;
+        }
+        const stale = decisions.get(payload.decisionId);
+        const replacement = decisions.get(payload.replacementDecisionId);
+        if (!stale) missingEvidence.add(`decision:${payload.decisionId}:observation`);
+        if (!replacement) missingEvidence.add(`decision:${payload.replacementDecisionId}:replacement`);
+        if (!stale || !replacement) {
+          collectMissingEvidence(missingEvidence, event, payload.evidence);
+          break;
+        }
+        stale.status = "superseded";
+        stale.supersededAt = event.occurredAt;
+        stale.supersededBy = payload.replacementDecisionId;
+        stale.correctionId = payload.correctionId;
+        stale.evidence.push(...payload.evidence);
+        replacement.status = "active";
+        replacement.evidence.push(...payload.evidence);
+        correction.evidence.push(...payload.evidence);
+        if (correctionSupersessionComplete(correction, decisions)) {
+          correction.appliedAt ??= event.occurredAt;
+          recordEarliestAppendPosition(correctionAppliedAppendPositions, payload.correctionId, appendPosition);
+          if (correction.status !== "propagated") correction.status = "applied";
+          conflict.status = "resolved";
+        }
+        collectMissingEvidence(missingEvidence, event, payload.evidence);
+        break;
+      }
+      case "recall_observed": {
+        const agent = ensureAgent(payload.agentId, payload.sessionId, event.occurredAt);
+        const coldStart = !substantiveAgentIds.has(payload.agentId) && !substantiveSessionIds.has(payload.sessionId) && agent.recalls.length === 0;
+        const recallSnapshot = {
+          recallReceiptId: payload.recallReceiptId,
+          sessionId: payload.sessionId,
+          decisionId: payload.decisionId,
+          query: payload.query,
+          capturedAtAction: payload.capturedAtAction,
+          coldStart,
+          occurredAt: event.occurredAt,
+          evidence: payload.evidence
+        };
+        agent.recalls.push(recallSnapshot);
+        recallAppendPositions.set(recallSnapshot, appendPosition);
+        markSubstantiveParticipation(payload.agentId, payload.sessionId);
+        const decision = decisions.get(payload.decisionId);
+        if (decision && !decision.heldByAgentIds.includes(payload.agentId)) {
+          decision.heldByAgentIds.push(payload.agentId);
+        }
+        if (!decision) missingEvidence.add(`decision:${payload.decisionId}:recall-target`);
+        collectMissingEvidence(missingEvidence, event, payload.evidence);
+        break;
+      }
+      case "propagation_verified": {
+        const agent = ensureAgent(payload.agentId, payload.sessionId, event.occurredAt);
+        const correction = corrections.get(payload.correctionId);
+        if (!correction) {
+          missingEvidence.add(`correction:${payload.correctionId}:proposal`);
+          collectMissingEvidence(missingEvidence, event, payload.evidence);
+          break;
+        }
+        if (correction.approvedAt === void 0 || correction.approvedBy === void 0) {
+          missingEvidence.add(`correction:${payload.correctionId}:approval`);
+          collectMissingEvidence(missingEvidence, event, payload.evidence);
+          break;
+        }
+        if (correction.status !== "applied" && correction.status !== "propagated" || correction.appliedAt === void 0 || correction.proposedDecisionId !== payload.decisionId) {
+          missingEvidence.add(`correction:${payload.correctionId}:supersession`);
+          collectMissingEvidence(missingEvidence, event, payload.evidence);
+          break;
+        }
+        const recalled = agent.recalls.find(
+          (recall) => recall.recallReceiptId === payload.recallReceiptId && recall.sessionId === payload.sessionId && recall.decisionId === payload.decisionId
+        );
+        if (!recalled) {
+          missingEvidence.add(`recall:${payload.recallReceiptId}:observation`);
+          collectMissingEvidence(missingEvidence, event, payload.evidence);
+          break;
+        }
+        const appliedAppendPosition = correctionAppliedAppendPositions.get(payload.correctionId);
+        const recallAppendPosition = recallAppendPositions.get(recalled);
+        if (appliedAppendPosition === void 0 || recallAppendPosition === void 0 || appliedAppendPosition >= recallAppendPosition) {
+          missingEvidence.add(`recall:${payload.recallReceiptId}:post-application-append-order`);
+          collectMissingEvidence(missingEvidence, event, payload.evidence);
+          break;
+        }
+        if (recallAppendPosition >= appendPosition) {
+          missingEvidence.add(`recall:${payload.recallReceiptId}:propagation-append-order`);
+          collectMissingEvidence(missingEvidence, event, payload.evidence);
+          break;
+        }
+        if (!recalled.capturedAtAction) {
+          missingEvidence.add(`recall:${payload.recallReceiptId}:at-action`);
+          collectMissingEvidence(missingEvidence, event, payload.evidence);
+          break;
+        }
+        if (!recalled.coldStart) {
+          missingEvidence.add(`recall:${payload.recallReceiptId}:cold-start`);
+          collectMissingEvidence(missingEvidence, event, payload.evidence);
+          break;
+        }
+        if (compareInstants(correction.appliedAt, recalled.occurredAt) >= 0) {
+          missingEvidence.add(`recall:${payload.recallReceiptId}:post-application`);
+          collectMissingEvidence(missingEvidence, event, payload.evidence);
+          break;
+        }
+        if (compareInstants(recalled.occurredAt, event.occurredAt) >= 0) {
+          missingEvidence.add(`recall:${payload.recallReceiptId}:propagation-order`);
+          collectMissingEvidence(missingEvidence, event, payload.evidence);
+          break;
+        }
+        const propagationSnapshot = {
+          correctionId: payload.correctionId,
+          agentId: payload.agentId,
+          sessionId: payload.sessionId,
+          decisionId: payload.decisionId,
+          recallReceiptId: payload.recallReceiptId,
+          staleDecisionAbsent: payload.staleDecisionAbsent,
+          occurredAt: event.occurredAt,
+          evidence: payload.evidence
+        };
+        propagation.push(propagationSnapshot);
+        propagationAppendPositions.set(propagationSnapshot, appendPosition);
+        correction.evidence.push(...payload.evidence);
+        if (payload.staleDecisionAbsent) {
+          correction.status = "propagated";
+          correction.propagatedAt = event.occurredAt;
+        }
+        status = payload.staleDecisionAbsent ? "verified" : "correcting";
+        collectMissingEvidence(missingEvidence, event, payload.evidence);
+        break;
+      }
+      case "mission_completed":
+        if (outcome !== null) {
+          missingEvidence.add("mission:duplicate-completion");
+          collectMissingEvidence(missingEvidence, event, payload.evidence);
+          break;
+        }
+        if (startedAt === null) missingEvidence.add("mission:start");
+        outcome = {
+          result: payload.outcome,
+          summary: payload.summary,
+          occurredAt: event.occurredAt,
+          evidence: payload.evidence
+        };
+        completedAt = event.occurredAt;
+        status = payload.outcome === "failed" ? "failed" : "completed";
+        collectMissingEvidence(missingEvidence, event, payload.evidence);
+        break;
+    }
+  }
+  for (const conflict of conflicts.values()) {
+    if (sourceEvidenceIds(conflict.evidence).size === 0) {
+      missingEvidence.add(`conflict:${conflict.conflictId}:source`);
+    }
+    for (const decisionId of conflict.decisionIds) {
+      if (!decisions.has(decisionId)) missingEvidence.add(`decision:${decisionId}:conflict-target`);
+    }
+    for (const agentId of conflict.agentIds) {
+      if (!agents.has(agentId)) missingEvidence.add(`agent:${agentId}:conflict-participant`);
+    }
+  }
+  for (const correction of corrections.values()) {
+    if (sourceEvidenceIds(correction.evidence).size === 0) {
+      missingEvidence.add(`correction:${correction.correctionId}:source`);
+    }
+    if (correction.approvedAt === void 0 || correction.approvedBy === void 0) {
+      missingEvidence.add(`correction:${correction.correctionId}:approval`);
+    } else if (correction.approvedBy.kind !== "human") {
+      missingEvidence.add(`correction:${correction.correctionId}:human-approval`);
+    } else if (runMode === "live" && correction.approvalPrincipal !== correction.approvedBy.id) {
+      missingEvidence.add(`correction:${correction.correctionId}:authenticated-human-approval`);
+    }
+    if (correction.status === "approved" || correction.status === "proposed") {
+      missingEvidence.add(`correction:${correction.correctionId}:supersession`);
+    }
+    if (correction.status === "applied") {
+      missingEvidence.add(`correction:${correction.correctionId}:propagation`);
+    }
+  }
+  const liveFixtureEvidenceEventIds = runMode === "live" ? orderedEvents.filter((event) => event.payload.evidence.some((item) => item.capture === "fixture")).map((event) => event.eventId) : [];
+  for (const eventId of liveFixtureEvidenceEventIds) {
+    missingEvidence.add(`mission:live-fixture-evidence:${eventId}`);
+  }
+  const captureTrustValid = liveFixtureEvidenceEventIds.length === 0;
+  const sortedDecisions = [...decisions.values()].map((decision) => ({
+    ...decision,
+    heldByAgentIds: uniqueSorted(decision.heldByAgentIds),
+    beliefIds: uniqueSorted(decision.beliefIds),
+    evidence: uniqueEvidence(decision.evidence)
+  })).sort((a, b) => compareText(a.decisionId, b.decisionId));
+  const coldStartVerified = captureTrustValid && propagation.some((item) => item.staleDecisionAbsent);
+  const passingOutcomeVerified = captureTrustValid && outcome?.result === "recovered" && tests.some((test) => {
+    const testAppendPosition = testAppendPositions.get(test);
+    if (test.status !== "passed" || test.correctionId === void 0 || testAppendPosition === void 0 || firstCompletionPosition < 0 || testAppendPosition >= firstCompletionPosition || compareInstants(test.occurredAt, outcome.occurredAt) >= 0) {
+      return false;
+    }
+    const correction = corrections.get(test.correctionId);
+    if (correction?.status !== "propagated" || correction.proposedDecisionId !== test.decisionId || !test.evidence.some((item) => item.kind === "correction" && item.id === correction.correctionId) || !test.evidence.some((item) => item.kind === "test")) {
+      return false;
+    }
+    return propagation.some((item) => {
+      const propagationAppendPosition = propagationAppendPositions.get(item);
+      return item.staleDecisionAbsent && item.correctionId === correction.correctionId && item.decisionId === test.decisionId && propagationAppendPosition !== void 0 && propagationAppendPosition < testAppendPosition && compareInstants(item.occurredAt, test.occurredAt) < 0;
+    });
+  });
+  if (outcome && !passingOutcomeVerified) missingEvidence.add("outcome:passing-test");
+  if (outcome?.result === "recovered" && !coldStartVerified) {
+    missingEvidence.add("outcome:cold-start-propagation");
+  }
+  if (input.events.length > 0 && startedAt === null) missingEvidence.add("mission:start");
+  if (startedAt !== null && completedAt !== null && compareInstants(startedAt, completedAt) >= 0) {
+    missingEvidence.add("mission:lifecycle-order");
+  }
+  if (firstStartEvent !== void 0 && firstCompletionEvent !== void 0 && (firstStartPosition >= firstCompletionPosition || compareRelayEvents(firstStartEvent, firstCompletionEvent) >= 0)) {
+    missingEvidence.add("mission:lifecycle-order");
+  }
+  const eventWindow = filteredEvents.slice(Math.max(0, filteredEvents.length - options.limit));
+  const found = input.events.length > 0;
+  return {
+    schemaVersion: RELAY_MISSION_SCHEMA_VERSION,
+    missionId,
+    namespace,
+    found,
+    readHealth: corruptLines > 0 ? "partial" : found || input.fileExists ? "ok" : "empty",
+    status,
+    mission: { title, objective, runMode, startedAt, completedAt },
+    agents: [...agents.values()].map((agent) => ({
+      ...agent,
+      sessionIds: uniqueSorted(agent.sessionIds),
+      outputs: agent.outputs.sort((a, b) => compareTimedIds(a, b, "outputId")),
+      recalls: agent.recalls.sort((a, b) => compareTimedIds(a, b, "recallReceiptId"))
+    })).sort((a, b) => compareText(a.agentId, b.agentId)),
+    decisions: sortedDecisions,
+    conflicts: [...conflicts.values()].sort((a, b) => compareText(a.conflictId, b.conflictId)),
+    corrections: [...corrections.values()].map((correction) => ({ ...correction, evidence: uniqueEvidence(correction.evidence) })).sort((a, b) => compareText(a.correctionId, b.correctionId)),
+    tests: tests.sort((a, b) => compareTimedIds(a, b, "testId")),
+    propagation: propagation.sort((a, b) => {
+      const byTime = compareInstants(a.occurredAt, b.occurredAt);
+      if (byTime !== 0) return byTime;
+      const byAgent = compareText(a.agentId, b.agentId);
+      return byAgent !== 0 ? byAgent : compareText(a.recallReceiptId, b.recallReceiptId);
+    }),
+    outcome,
+    receipt: {
+      complete: status === "completed" && outcome?.result === "recovered" && passingOutcomeVerified && coldStartVerified && missingEvidence.size === 0,
+      missingEvidence: [...missingEvidence].sort(compareText),
+      activeDecisionIds: sortedDecisions.filter((decision) => decision.status === "active").map((decision) => decision.decisionId),
+      supersededDecisionIds: sortedDecisions.filter((decision) => decision.status === "superseded").map((decision) => decision.decisionId),
+      coldStartVerified,
+      passingOutcomeVerified
+    },
+    bounds: {
+      totalEvents: filteredEvents.length,
+      returnedEvents: eventWindow.length,
+      corruptLines,
+      truncated: filteredEvents.length > eventWindow.length,
+      since: options.since ?? null,
+      until: options.until ?? null
+    },
+    events: eventWindow
+  };
+}
+function compareRelayEvents(a, b) {
+  const byOccurrence = compareInstants(a.occurredAt, b.occurredAt);
+  if (byOccurrence !== 0) return byOccurrence;
+  const byRecord = compareInstants(a.recordedAt, b.recordedAt);
+  if (byRecord !== 0) return byRecord;
+  return compareText(a.eventId, b.eventId);
+}
+function parseMissionJsonl(raw, missionId, namespace, maxEvents) {
+  const events = [];
+  let corruptLines = 0;
+  for (const line of raw.split("\n")) {
+    if (line.trim().length === 0) continue;
+    if (Buffer.byteLength(line, "utf8") > RELAY_MISSION_MAX_LINE_BYTES) {
+      corruptLines += 1;
+      continue;
+    }
+    let candidate;
+    try {
+      candidate = JSON.parse(line);
+    } catch {
+      corruptLines += 1;
+      continue;
+    }
+    const parsed = RelayMissionEventSchema.safeParse(candidate);
+    if (!parsed.success || parsed.data.missionId !== missionId || parsed.data.namespace !== namespace) {
+      corruptLines += 1;
+      continue;
+    }
+    if (events.length >= maxEvents) {
+      throw new RelayMissionStoreError(
+        "limit_exceeded",
+        `mission ${missionId} exceeds the ${maxEvents}-event read limit`
+      );
+    }
+    events.push(parsed.data);
+  }
+  return { events, corruptLines };
+}
+function collectMissingEvidence(missing, event, evidence) {
+  if (evidence.length === 0) missing.add(`event:${event.eventId}:evidence`);
+}
+function sameIdempotentInput(event, input, authenticatedPrincipal) {
+  if (event.authenticatedPrincipal !== authenticatedPrincipal) return false;
+  if (input.occurredAt !== void 0 && event.occurredAt !== input.occurredAt) return false;
+  return stableJson(event.payload) === stableJson(input.payload);
+}
+function stableJson(value) {
+  if (Array.isArray(value)) return `[${value.map(stableJson).join(",")}]`;
+  if (value && typeof value === "object") {
+    const entries = Object.entries(value).sort(([a], [b]) => compareText(a, b)).map(([key, child]) => `${JSON.stringify(key)}:${stableJson(child)}`);
+    return `{${entries.join(",")}}`;
+  }
+  return JSON.stringify(value) ?? "null";
+}
+function uniqueEvidence(evidence) {
+  const byKey = /* @__PURE__ */ new Map();
+  for (const item of evidence) byKey.set(`${item.kind}\0${item.id}`, item);
+  return [...byKey.values()].sort((a, b) => {
+    const byKind = compareText(a.kind, b.kind);
+    return byKind !== 0 ? byKind : compareText(a.id, b.id);
+  });
+}
+function uniqueSorted(values) {
+  return [...new Set(values)].sort(compareText);
+}
+function compareText(a, b) {
+  if (a < b) return -1;
+  if (a > b) return 1;
+  return 0;
+}
+function compareInstants(a, b) {
+  const aMs = Date.parse(a);
+  const bMs = Date.parse(b);
+  if (aMs < bMs) return -1;
+  if (aMs > bMs) return 1;
+  return 0;
+}
+function compareTimedIds(a, b, idKey) {
+  const byTime = compareInstants(a.occurredAt, b.occurredAt);
+  if (byTime !== 0) return byTime;
+  return compareText(String(a[idKey]), String(b[idKey]));
+}
+function beliefAppendPositionKey(agentId, decisionId) {
+  return `${agentId}\0${decisionId}`;
+}
+function normalizeDecisionStatement(statement) {
+  return statement.normalize("NFKC").trim().toLowerCase().replace(/\s+/g, " ").replace(/[.!?]+$/, "");
+}
+function decisionStatementsMatch(left, right) {
+  return normalizeDecisionStatement(left) === normalizeDecisionStatement(right);
+}
+function recordEarliestAppendPosition(positions, key, position) {
+  const current = positions.get(key);
+  if (current === void 0 || position < current) positions.set(key, position);
+}
+function correctionSupersessionComplete(correction, decisions) {
+  return correction.supersedesDecisionIds.every((decisionId) => {
+    const decision = decisions.get(decisionId);
+    return decision?.status === "superseded" && decision.supersededBy === correction.proposedDecisionId && decision.correctionId === correction.correctionId;
+  });
+}
+function correctionCoversConflict(correction, conflict) {
+  const expectedSuperseded = uniqueSorted(
+    conflict.decisionIds.filter((decisionId) => decisionId !== correction.proposedDecisionId)
+  );
+  const declaredSuperseded = uniqueSorted(correction.supersedesDecisionIds);
+  return expectedSuperseded.length === declaredSuperseded.length && expectedSuperseded.every((decisionId, index) => decisionId === declaredSuperseded[index]);
+}
+function sourceEvidenceIds(evidence) {
+  return new Set(evidence.filter((item) => item.kind === "source").map((item) => item.id));
+}
+function positiveIntegerOption(value, name, fallback) {
+  if (value === void 0) return fallback;
+  if (!Number.isInteger(value) || value <= 0) {
+    throw new TypeError(`RelayMissionStore ${name} must be a positive integer`);
+  }
+  return value;
+}
+function validNow(now) {
+  const value = now();
+  if (!(value instanceof Date) || !Number.isFinite(value.getTime())) {
+    throw new TypeError("RelayMissionStore now() must return a valid Date");
+  }
+  return value.toISOString();
+}
+async function openOrCreatePinnedChildDirectory(parentHandle, segment) {
+  const directory = path.join(pinnedDirectoryPath(parentHandle), segment);
+  try {
+    await fs.mkdir(directory, { mode: 448 });
+  } catch (error) {
+    if (error.code !== "EEXIST") throw error;
+  }
+  return openVerifiedDirectory(directory, "Relay directory symlinks are rejected");
+}
+async function openVerifiedDirectory(directory, unsafeMessage) {
+  const before = await fs.lstat(directory);
+  if (before.isSymbolicLink() || !before.isDirectory()) {
+    throw new RelayMissionStoreError("unsafe_path", unsafeMessage);
+  }
+  const handle = await fs.open(directory, fsConstants.O_RDONLY | fsConstants.O_DIRECTORY | fsConstants.O_NOFOLLOW);
+  try {
+    const openInfo = await handle.stat();
+    const after = await fs.lstat(directory);
+    if (after.isSymbolicLink() || !after.isDirectory() || before.dev !== openInfo.dev || before.ino !== openInfo.ino || after.dev !== openInfo.dev || after.ino !== openInfo.ino) {
+      throw new RelayMissionStoreError("unsafe_path", "Relay directory changed during validation");
+    }
+    return handle;
+  } catch (error) {
+    await handle.close().catch(() => void 0);
+    throw error;
+  }
+}
+function pinnedDirectoryPath(handle) {
+  if (process.platform === "linux") return `/proc/self/fd/${handle.fd}`;
+  if (process.platform === "darwin" || process.platform === "freebsd" || process.platform === "openbsd") {
+    return `/dev/fd/${handle.fd}`;
+  }
+  throw new RelayMissionStoreError(
+    "unsafe_path",
+    `Relay pinned directory access is unsupported on ${process.platform}`
+  );
+}
+function relayMissionReceiptDigest(snapshot) {
+  const receipt = {
+    schemaVersion: snapshot.schemaVersion,
+    missionId: snapshot.missionId,
+    namespace: snapshot.namespace,
+    status: snapshot.status,
+    decisions: snapshot.decisions,
+    corrections: snapshot.corrections,
+    propagation: snapshot.propagation,
+    tests: snapshot.tests,
+    outcome: snapshot.outcome,
+    receipt: snapshot.receipt
+  };
+  return createHash("sha256").update(stableJson(receipt)).digest("hex");
+}
+
+// src/relay/mission-access.ts
+var namespaceSchema2 = z2.string().trim().min(1).max(128).nullable().optional();
+var RelayMissionAppendAccessSchema = z2.object({
+  missionId: RelayMissionIdSchema,
+  namespace: namespaceSchema2,
+  event: RelayMissionEventInputSchema
+}).strict();
+var optionalLimitSchema = z2.preprocess((value) => {
+  if (value === void 0 || value === null) return void 0;
+  if (typeof value === "string" && /^(?:0|[1-9]\d*)$/.test(value)) return Number(value);
+  return value;
+}, z2.number().int().min(1).max(RELAY_MISSION_MAX_EVENT_LIMIT).optional());
+var RelayMissionReadAccessSchema = z2.object({
+  missionId: RelayMissionIdSchema,
+  namespace: namespaceSchema2,
+  since: RelayIsoDateTimeSchema.optional(),
+  until: RelayIsoDateTimeSchema.optional(),
+  limit: optionalLimitSchema
+}).strict().refine(
+  (value) => value.since === void 0 || value.until === void 0 || Date.parse(value.since) < Date.parse(value.until),
+  { message: "since must be earlier than until", path: ["until"] }
+);
+async function appendRelayMissionEvent(service, input, authenticatedPrincipal, beforeAppend) {
+  const resolved = await service.getWritableStorageForNamespace(input.namespace ?? void 0, authenticatedPrincipal);
+  const store = new RelayMissionStore({
+    rootDir: resolved.storage.dir,
+    namespace: resolved.namespace
+  });
+  return store.append(input.missionId, input.event, { authenticatedPrincipal, beforeAppend });
+}
+async function readRelayMission(service, input, authenticatedPrincipal) {
+  const resolved = await service.getReadableStorageForNamespace(input.namespace ?? void 0, authenticatedPrincipal);
+  const store = new RelayMissionStore({
+    rootDir: resolved.storage.dir,
+    namespace: resolved.namespace
+  });
+  const options = RelayMissionReadOptionsSchema.parse({
+    ...input.since === void 0 ? {} : { since: input.since },
+    ...input.until === void 0 ? {} : { until: input.until },
+    ...input.limit === void 0 ? {} : { limit: input.limit }
+  });
+  return store.read(input.missionId, options);
+}
+var relayMissionAppendOperation = defineOperation({
+  name: "relay_mission_append",
+  description: "Append one evidence-backed event to an isolated Relay mission.",
+  schema: RelayMissionAppendAccessSchema,
+  handler: async (input, ctx) => ({
+    result: await appendRelayMissionEvent(ctx.service, input, ctx.authenticatedPrincipal, ctx.hooks?.enforceWriteQuota)
+  })
+});
+var relayMissionReadOperation = defineOperation({
+  name: "relay_mission_read",
+  description: "Read one bounded, browser-ready Relay mission receipt.",
+  schema: RelayMissionReadAccessSchema,
+  handler: async (input, ctx) => ({
+    result: await readRelayMission(ctx.service, input, ctx.authenticatedPrincipal)
+  })
+});
+
+// src/access-operations.ts
+var memoryGetSchema = z3.object({
+  memoryId: z3.string().trim().min(1, "memoryId is required").max(512),
+  // Issue #1582 — when memoryId is a `[m:xxxx]` handle, sessionKey scopes the
+  // resolution to this session's recent recall history.
+  sessionKey: z3.string().trim().min(1).max(512).nullable().optional(),
+  namespace: z3.string().trim().max(256).nullable().optional()
+});
+var memoryGetOperation = defineOperation({
+  name: "memory_get",
+  description: "Fetch one memory by id.",
+  schema: memoryGetSchema,
+  handler: async (input, ctx) => {
+    const result = await ctx.service.memoryGet(
+      input.memoryId,
+      input.namespace ?? void 0,
+      ctx.authenticatedPrincipal,
+      input.sessionKey ?? void 0
+    );
+    return { result };
+  }
+});
+var memorySearchSchema = z3.object({
+  query: z3.string().trim().min(1, "query is required").max(2048),
+  namespace: z3.string().trim().max(256).nullable().optional(),
+  // No upper cap: the pre-boundary MCP handler forwarded any finite number to
+  // memorySearch, and the QMD/search backends honor large limits. Capping at
+  // 100 would reject existing clients that request larger result sets.
+  maxResults: z3.number().int().min(1).nullable().optional(),
+  collection: z3.string().trim().min(1).max(256).nullable().optional()
+});
+var memorySearchOperation = defineOperation({
+  name: "memory_search",
+  description: "Search memories across readable namespaces.",
+  schema: memorySearchSchema,
+  handler: async (input, ctx) => {
+    const result = await ctx.service.memorySearch({
+      query: input.query,
+      namespace: input.namespace ?? void 0,
+      maxResults: input.maxResults ?? void 0,
+      collection: input.collection ?? void 0,
+      principal: ctx.authenticatedPrincipal
+    });
+    return { result };
+  }
+});
+var memoryStoreOperation = defineOperation({
+  name: "memory_store",
+  description: "Store an explicit memory through the access layer.",
+  // Reuse the existing schema verbatim — the migration is behavior-preserving;
+  // the schema's external contract is NOT changing in this PR (per the issue's
+  // pitfall note).
+  schema: memoryStoreRequestSchema,
+  handler: async (input, ctx) => {
+    const result = await ctx.service.memoryStore(
+      {
+        ...input,
+        authenticatedPrincipal: ctx.authenticatedPrincipal,
+        ...ctx.sourceConnector ? { sourceConnector: ctx.sourceConnector } : {}
+      },
+      // Forward transport-level hooks (e.g. HTTP's atomic write-quota gate)
+      // so the hook still fires inside the service's idempotent-write lock —
+      // never before, never on a replay (#1434 invariant preserved by the
+      // boundary migration).
+      ctx.hooks
+    );
+    return { result };
+  }
+});
+var codingDecisionSchema = z3.preprocess(
+  (data) => {
+    if (data && typeof data === "object" && !Array.isArray(data)) {
+      const out = {};
+      for (const [k, v] of Object.entries(data)) {
+        if (v !== null) out[k] = v;
+      }
+      return out;
+    }
+    return data;
+  },
+  z3.object({
+    subcommand: z3.enum(DECISION_SUBCOMMANDS),
+    sessionKey: z3.string().trim().max(512).optional(),
+    namespace: z3.string().trim().max(256).optional(),
+    id: z3.string().trim().max(512).optional(),
+    title: z3.string().trim().max(512).optional(),
+    status: z3.string().trim().max(64).optional(),
+    context: z3.string().trim().max(8192).optional(),
+    decision: z3.string().trim().max(8192).optional(),
+    consequences: z3.string().trim().max(8192).optional(),
+    entityRefs: z3.array(z3.string().trim().min(1).max(256)).optional(),
+    supersedesId: z3.string().trim().max(512).optional()
+  })
+);
+var codingDecisionOperation = defineOperation({
+  name: "coding_decision",
+  description: "List, get, record, or supersede decision records in the session's coding namespace (issue #1548 Track A).",
+  schema: codingDecisionSchema,
+  handler: async (input, ctx) => {
+    const result = await ctx.service.codingDecision(input, ctx.authenticatedPrincipal, ctx.sourceConnector);
+    return { result };
+  }
+});
+var codingArchitectureSchema = z3.preprocess(
+  (data) => {
+    if (data !== null && typeof data === "object" && !Array.isArray(data)) {
+      const obj = data;
+      const cleaned = {};
+      for (const [key, value] of Object.entries(obj)) {
+        if (value !== null) cleaned[key] = value;
+      }
+      return cleaned;
+    }
+    return data;
+  },
+  z3.object({
+    subcommand: z3.enum(["get", "refresh"]),
+    sessionKey: z3.string().optional(),
+    namespace: z3.string().optional()
+  })
+);
+var codingArchitectureOperation = defineOperation({
+  name: "coding_architecture",
+  description: "Get or refresh the architecture card for the session's coding namespace (issue #1548 Track A PR 3).",
+  schema: codingArchitectureSchema,
+  handler: async (input, ctx) => {
+    const result = await ctx.service.codingArchitecture(input, ctx.authenticatedPrincipal, ctx.sourceConnector);
+    return { result };
+  }
+});
+var codegraphSurfaceSchema = z3.preprocess(
+  (data) => {
+    if (data !== null && typeof data === "object" && !Array.isArray(data)) {
+      const obj = data;
+      const cleaned = {};
+      for (const [key, value] of Object.entries(obj)) {
+        if (value !== null) cleaned[key] = value;
+      }
+      return cleaned;
+    }
+    return data;
+  },
+  z3.object({
+    tool: z3.string().refine(isCodegraphToolName, {
+      message: "tool must be one of the codegraph tool names"
+    }),
+    sessionKey: z3.string().max(512).optional(),
+    principal: z3.string().max(256).optional(),
+    project: z3.string().max(256).optional(),
+    query: z3.string().max(2048).optional(),
+    limit: z3.number().int().positive().max(200).optional(),
+    start: z3.string().max(512).optional(),
+    direction: z3.string().max(64).optional(),
+    depth: z3.number().int().positive().max(10).optional(),
+    qualifiedName: z3.string().max(1024).optional(),
+    path: z3.string().max(2048).optional(),
+    structuredQuery: z3.record(z3.string(), z3.unknown()).optional(),
+    head: z3.string().max(256).optional(),
+    repoRoot: z3.string().max(2048).optional(),
+    mode: z3.string().max(64).optional(),
+    confirm: z3.boolean().optional(),
+    subcommand: z3.string().max(64).optional(),
+    id: z3.string().max(512).optional(),
+    title: z3.string().max(512).optional(),
+    status: z3.string().max(64).optional(),
+    context: z3.string().max(8192).optional(),
+    decision: z3.string().max(8192).optional(),
+    consequences: z3.string().max(8192).optional(),
+    entityRefs: z3.array(z3.string().max(256)).optional(),
+    supersedesId: z3.string().max(512).optional(),
+    traces: z3.array(z3.unknown()).optional()
+  })
+);
+var codingDeltaSchema = z3.preprocess(
+  (data) => {
+    if (data !== null && typeof data === "object" && !Array.isArray(data)) {
+      const obj = data;
+      const cleaned = {};
+      for (const [key, value] of Object.entries(obj)) {
+        if (value !== null) cleaned[key] = value;
+      }
+      return cleaned;
+    }
+    return data;
+  },
+  z3.object({
+    subcommand: z3.enum(DELTA_SUBCOMMANDS),
+    sessionKey: z3.string().trim().max(512).optional(),
+    namespace: z3.string().trim().max(256).optional()
+  })
+);
+var codingDeltaOperation = defineOperation({
+  name: "coding_delta",
+  description: "Get the session delta (commits + touched files since last seen) for the session's coding namespace (issue #1548 Track A PR 4).",
+  schema: codingDeltaSchema,
+  handler: async (input, ctx) => {
+    const result = await ctx.service.codingDelta(input, ctx.authenticatedPrincipal);
+    return { result };
+  }
+});
+var memoryCorrectPlanSchema = z3.preprocess(
+  (data) => {
+    if (data && typeof data === "object" && !Array.isArray(data)) {
+      const out = {};
+      for (const [k, v] of Object.entries(data)) {
+        if (v !== null) out[k] = v;
+      }
+      return out;
+    }
+    return data;
+  },
+  z3.object({
+    text: z3.string().trim().min(1).max(1e4),
+    targetIds: z3.array(z3.string().trim().min(1).max(512)).optional(),
+    sessionKey: z3.string().trim().max(512).optional(),
+    namespace: z3.string().trim().max(256).optional()
+  })
+);
+var memoryCorrectPlanOperation = defineOperation({
+  name: "memory_correct_plan",
+  description: "Plan a memory correction from a plain-language statement (issue #1580). Returns a CorrectionPlan with a diff preview; apply via memory_correct_apply.",
+  schema: memoryCorrectPlanSchema,
+  handler: async (input, ctx) => {
+    try {
+      const result = await ctx.service.correctionPlan({
+        text: input.text,
+        ...input.targetIds ? { targetIds: input.targetIds } : {},
+        ...input.sessionKey ? { sessionKey: input.sessionKey } : {},
+        ...input.namespace ? { namespace: input.namespace } : {},
+        ...ctx.authenticatedPrincipal ? { principal: ctx.authenticatedPrincipal } : {}
+      });
+      return { result };
+    } catch (err) {
+      if (err instanceof CorrectionContractError) throw new EngramAccessInputError(err.message);
+      throw err;
+    }
+  }
+});
+var memoryCorrectApplySchema = z3.preprocess(
+  (data) => {
+    if (data && typeof data === "object" && !Array.isArray(data)) {
+      const out = {};
+      for (const [k, v] of Object.entries(data)) {
+        if (v !== null) out[k] = v;
+      }
+      return out;
+    }
+    return data;
+  },
+  z3.object({
+    planId: z3.string().trim().min(1).max(512),
+    confirm: z3.boolean().optional(),
+    sessionKey: z3.string().trim().max(512).optional(),
+    namespace: z3.string().trim().max(256).optional()
+  })
+);
+var memoryCorrectApplyOperation = defineOperation({
+  name: "memory_correct_apply",
+  description: "Apply a planned memory correction by planId (issue #1580). Requires confirm: true when correction.applyRequiresConfirm is on (default).",
+  schema: memoryCorrectApplySchema,
+  handler: async (input, ctx) => {
+    try {
+      const result = await ctx.service.correctionApply(input.planId, {
+        confirm: input.confirm === true,
+        ...input.sessionKey ? { sessionKey: input.sessionKey } : {},
+        ...input.namespace ? { namespace: input.namespace } : {},
+        ...ctx.authenticatedPrincipal ? { principal: ctx.authenticatedPrincipal } : {}
+      });
+      return { result };
+    } catch (err) {
+      if (err instanceof CorrectionContractError) throw new EngramAccessInputError(err.message);
+      throw err;
+    }
+  }
+});
+var codegraphIndexOperation = defineOperation({
+  name: "codegraph_index",
+  description: "Codegraph parity tool (issue #1554): index. Delegates to the shared codegraph surface handler.",
+  schema: codegraphSurfaceSchema,
+  handler: async (input, ctx) => {
+    const result = await ctx.service.codegraphTool(input, ctx.authenticatedPrincipal, ctx.sourceConnector);
+    return { result };
+  }
+});
+var codegraphListProjectsOperation = defineOperation({
+  name: "codegraph_list_projects",
+  description: "Codegraph parity tool (issue #1554): list_projects. Delegates to the shared codegraph surface handler.",
+  schema: codegraphSurfaceSchema,
+  handler: async (input, ctx) => {
+    const result = await ctx.service.codegraphTool(input, ctx.authenticatedPrincipal, ctx.sourceConnector);
+    return { result };
+  }
+});
+var codegraphDeleteProjectOperation = defineOperation({
+  name: "codegraph_delete_project",
+  description: "Codegraph parity tool (issue #1554): delete_project. Delegates to the shared codegraph surface handler.",
+  schema: codegraphSurfaceSchema,
+  handler: async (input, ctx) => {
+    const result = await ctx.service.codegraphTool(input, ctx.authenticatedPrincipal, ctx.sourceConnector);
+    return { result };
+  }
+});
+var codegraphIndexStatusOperation = defineOperation({
+  name: "codegraph_index_status",
+  description: "Codegraph parity tool (issue #1554): index_status. Delegates to the shared codegraph surface handler.",
+  schema: codegraphSurfaceSchema,
+  handler: async (input, ctx) => {
+    const result = await ctx.service.codegraphTool(input, ctx.authenticatedPrincipal, ctx.sourceConnector);
+    return { result };
+  }
+});
+var codegraphSearchGraphOperation = defineOperation({
+  name: "codegraph_search_graph",
+  description: "Codegraph parity tool (issue #1554): search_graph. Delegates to the shared codegraph surface handler.",
+  schema: codegraphSurfaceSchema,
+  handler: async (input, ctx) => {
+    const result = await ctx.service.codegraphTool(input, ctx.authenticatedPrincipal, ctx.sourceConnector);
+    return { result };
+  }
+});
+var codegraphTracePathOperation = defineOperation({
+  name: "codegraph_trace_path",
+  description: "Codegraph parity tool (issue #1554): trace_path. Delegates to the shared codegraph surface handler.",
+  schema: codegraphSurfaceSchema,
+  handler: async (input, ctx) => {
+    const result = await ctx.service.codegraphTool(input, ctx.authenticatedPrincipal, ctx.sourceConnector);
+    return { result };
+  }
+});
+var codegraphDetectChangesOperation = defineOperation({
+  name: "codegraph_detect_changes",
+  description: "Codegraph parity tool (issue #1554): detect_changes. Delegates to the shared codegraph surface handler.",
+  schema: codegraphSurfaceSchema,
+  handler: async (input, ctx) => {
+    const result = await ctx.service.codegraphTool(input, ctx.authenticatedPrincipal, ctx.sourceConnector);
+    return { result };
+  }
+});
+var codegraphQueryGraphOperation = defineOperation({
+  name: "codegraph_query_graph",
+  description: "Codegraph parity tool (issue #1554): query_graph. Delegates to the shared codegraph surface handler.",
+  schema: codegraphSurfaceSchema,
+  handler: async (input, ctx) => {
+    const result = await ctx.service.codegraphTool(input, ctx.authenticatedPrincipal, ctx.sourceConnector);
+    return { result };
+  }
+});
+var codegraphGetSchemaOperation = defineOperation({
+  name: "codegraph_get_schema",
+  description: "Codegraph parity tool (issue #1554): get_schema. Delegates to the shared codegraph surface handler.",
+  schema: codegraphSurfaceSchema,
+  handler: async (input, ctx) => {
+    const result = await ctx.service.codegraphTool(input, ctx.authenticatedPrincipal, ctx.sourceConnector);
+    return { result };
+  }
+});
+var codegraphGetSnippetOperation = defineOperation({
+  name: "codegraph_get_snippet",
+  description: "Codegraph parity tool (issue #1554): get_snippet. Delegates to the shared codegraph surface handler.",
+  schema: codegraphSurfaceSchema,
+  handler: async (input, ctx) => {
+    const result = await ctx.service.codegraphTool(input, ctx.authenticatedPrincipal, ctx.sourceConnector);
+    return { result };
+  }
+});
+var codegraphGetArchitectureOperation = defineOperation({
+  name: "codegraph_get_architecture",
+  description: "Codegraph parity tool (issue #1554): get_architecture. Delegates to the shared codegraph surface handler.",
+  schema: codegraphSurfaceSchema,
+  handler: async (input, ctx) => {
+    const result = await ctx.service.codegraphTool(input, ctx.authenticatedPrincipal, ctx.sourceConnector);
+    return { result };
+  }
+});
+var codegraphSearchCodeOperation = defineOperation({
+  name: "codegraph_search_code",
+  description: "Codegraph parity tool (issue #1554): search_code. Delegates to the shared codegraph surface handler.",
+  schema: codegraphSurfaceSchema,
+  handler: async (input, ctx) => {
+    const result = await ctx.service.codegraphTool(input, ctx.authenticatedPrincipal, ctx.sourceConnector);
+    return { result };
+  }
+});
+var codegraphManageAdrOperation = defineOperation({
+  name: "codegraph_manage_adr",
+  description: "Codegraph parity tool (issue #1554): manage_adr. Delegates to the shared codegraph surface handler.",
+  schema: codegraphSurfaceSchema,
+  handler: async (input, ctx) => {
+    const result = await ctx.service.codegraphTool(input, ctx.authenticatedPrincipal, ctx.sourceConnector);
+    return { result };
+  }
+});
+var codegraphIngestTracesOperation = defineOperation({
+  name: "codegraph_ingest_traces",
+  description: "Codegraph parity tool (issue #1554): ingest_traces. Delegates to the shared codegraph surface handler.",
+  schema: codegraphSurfaceSchema,
+  handler: async (input, ctx) => {
+    const result = await ctx.service.codegraphTool(input, ctx.authenticatedPrincipal, ctx.sourceConnector);
+    return { result };
+  }
+});
+var REGISTERED_OPERATIONS = [
+  memoryGetOperation.spec.name,
+  memorySearchOperation.spec.name,
+  memoryStoreOperation.spec.name,
+  codingDecisionOperation.spec.name,
+  codingArchitectureOperation.spec.name,
+  codegraphIndexOperation.spec.name,
+  codegraphListProjectsOperation.spec.name,
+  codegraphDeleteProjectOperation.spec.name,
+  codegraphIndexStatusOperation.spec.name,
+  codegraphSearchGraphOperation.spec.name,
+  codegraphTracePathOperation.spec.name,
+  codegraphDetectChangesOperation.spec.name,
+  codegraphQueryGraphOperation.spec.name,
+  codegraphGetSchemaOperation.spec.name,
+  codegraphGetSnippetOperation.spec.name,
+  codegraphGetArchitectureOperation.spec.name,
+  codegraphSearchCodeOperation.spec.name,
+  codegraphManageAdrOperation.spec.name,
+  codegraphIngestTracesOperation.spec.name,
+  codingDeltaOperation.spec.name,
+  memoryCorrectPlanOperation.spec.name,
+  memoryCorrectApplyOperation.spec.name
+];
+
+export {
+  RELAY_MISSION_SCHEMA_VERSION,
+  RELAY_MISSION_MAX_FILE_BYTES,
+  RELAY_MISSION_MAX_LINE_BYTES,
+  RELAY_MISSION_MAX_EVENTS,
+  RELAY_MISSION_DEFAULT_EVENT_LIMIT,
+  RELAY_MISSION_MAX_EVENT_LIMIT,
+  RelayEvidenceRefSchema,
+  RelayMissionPayloadSchema,
+  RelayMissionEventInputSchema,
+  RelayMissionEventSchema,
+  RelayMissionReadOptionsSchema,
+  RelayMissionStoreError,
+  RelayMissionStore,
+  reduceRelayMission,
+  compareRelayEvents,
+  relayMissionReceiptDigest,
+  appendRelayMissionEvent,
+  readRelayMission,
+  relayMissionAppendOperation,
+  relayMissionReadOperation,
+  memoryGetOperation,
+  memorySearchOperation,
+  memoryStoreOperation,
+  codingDecisionOperation,
+  codingArchitectureOperation,
+  codingDeltaOperation,
+  memoryCorrectPlanOperation,
+  memoryCorrectApplyOperation,
+  codegraphIndexOperation,
+  codegraphListProjectsOperation,
+  codegraphDeleteProjectOperation,
+  codegraphIndexStatusOperation,
+  codegraphSearchGraphOperation,
+  codegraphTracePathOperation,
+  codegraphDetectChangesOperation,
+  codegraphQueryGraphOperation,
+  codegraphGetSchemaOperation,
+  codegraphGetSnippetOperation,
+  codegraphGetArchitectureOperation,
+  codegraphSearchCodeOperation,
+  codegraphManageAdrOperation,
+  codegraphIngestTracesOperation,
+  REGISTERED_OPERATIONS
+};
+//# sourceMappingURL=chunk-TITSEN2M.js.map