@remnic/core 10.0.92 → 10.0.93

package/dist/chunk-BJRTMNCB.js

@@ -1,1919 +0,0 @@
-import {
-  buildStandup,
-  parseStandupDate
-} from "./chunk-XYKBWTWI.js";
-import {
-  backfillMemoryStorage,
-  runLocationBackfill,
-  runLocationCheck,
-  runLocationDay,
-  runLocationStatus,
-  runLocationSync
-} from "./chunk-SUSW74WU.js";
-import {
-  externalWikiSearchOperation
-} from "./chunk-MB6ZJDN6.js";
-import {
-  DECISION_SUBCOMMANDS,
-  DELTA_SUBCOMMANDS,
-  defineOperation,
-  isCodegraphToolName
-} from "./chunk-ZTTCDQ4I.js";
-import {
-  CorrectionContractError
-} from "./chunk-ETSJD5IV.js";
-import {
-  memoryStoreRequestSchema,
-  retainedCategoryAlias
-} from "./chunk-R2DOFBG4.js";
-import {
-  serializeMutations,
-  withHeldFileLock
-} from "./chunk-EBV6VXKF.js";
-import {
-  EngramAccessInputError
-} from "./chunk-CJCTKL6Y.js";
-
-// src/access-operations.ts
-import { z as z5 } 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 event = RelayMissionEventInputSchema.parse(input.event);
-  const approvalPrincipal = authenticatedPrincipal?.trim() || void 0;
-  if (event.payload.kind === "correction_approved" && event.payload.approvedBy.kind === "human") {
-    if (!approvalPrincipal) {
-      throw new EngramAccessInputError(
-        "Relay human approval requires a server-resolved authenticated principal"
-      );
-    }
-    if (event.payload.approvedBy.id !== approvalPrincipal) {
-      throw new EngramAccessInputError(
-        "Relay human approval identity must match the server-resolved authenticated principal"
-      );
-    }
-  }
-  const resolved = await service.getWritableStorageForNamespace(input.namespace ?? void 0, approvalPrincipal);
-  const store = new RelayMissionStore({
-    rootDir: resolved.storage.dir,
-    namespace: resolved.namespace
-  });
-  return store.append(input.missionId, event, { authenticatedPrincipal: approvalPrincipal, 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/location/access-operations.ts
-import { z as z3 } from "zod";
-var dateField = z3.union([z3.string(), z3.null()]).optional();
-var daysField = z3.union([z3.number(), z3.string(), z3.null()]).optional();
-var dryRunField = z3.union([z3.boolean(), z3.null()]).optional();
-function locationDeps(service) {
-  return {
-    config: service.configRef.location,
-    memoryDir: service.memoryDir,
-    getMemoryStorage: () => backfillMemoryStorage(service.configRef)
-  };
-}
-defineOperation({
-  name: "location_status",
-  description: "Location sync status (gates, providers, last sync, day counts).",
-  fleetWide: true,
-  schema: z3.object({}).passthrough(),
-  handler: async (_input, ctx) => ({
-    result: await runLocationStatus(locationDeps(ctx.service))
-  })
-});
-defineOperation({
-  name: "location_check",
-  description: "Probe every enabled location provider.",
-  fleetWide: true,
-  schema: z3.object({}).passthrough(),
-  handler: async (_input, ctx) => ({
-    result: await runLocationCheck(locationDeps(ctx.service))
-  })
-});
-defineOperation({
-  name: "location_sync",
-  description: "Sync location days (default window: syncDays ending yesterday).",
-  fleetWide: true,
-  schema: z3.object({ date: dateField, days: daysField }).passthrough(),
-  handler: async (input, ctx) => ({
-    result: {
-      days: await runLocationSync(locationDeps(ctx.service), {
-        ...input.date !== void 0 && input.date !== null && input.date !== "" ? { endDate: input.date } : {},
-        ...input.days !== void 0 && input.days !== null && input.days !== "" ? { days: Number(input.days) } : {}
-      })
-    }
-  })
-});
-defineOperation({
-  name: "location_backfill",
-  description: "Sync an explicit historical day range (\u2264 90 days) and re-tag overlapping memories (issue #2046).",
-  fleetWide: true,
-  schema: z3.object({ from: dateField, to: dateField, dryRun: dryRunField }).passthrough(),
-  handler: async (input, ctx) => ({
-    result: await runLocationBackfill(locationDeps(ctx.service), {
-      from: input.from ?? null,
-      to: input.to ?? null,
-      dryRun: input.dryRun === true
-    })
-  })
-});
-defineOperation({
-  name: "location_day",
-  description: "Read one stored location day.",
-  fleetWide: true,
-  schema: z3.object({ date: dateField }).passthrough(),
-  handler: async (input, ctx) => ({
-    result: await runLocationDay(locationDeps(ctx.service).memoryDir, input.date)
-  })
-});
-
-// src/standup/access-operations.ts
-import { z as z4 } from "zod";
-defineOperation({
-  name: "standup",
-  description: "Deterministic yesterday/today/blockers standup brief.",
-  fleetWide: true,
-  schema: z4.object({ date: z4.string().optional() }).strict(),
-  handler: async (input, ctx) => ({
-    result: buildStandup(ctx.service.memoryDir, parseStandupDate(input.date))
-  })
-});
-
-// src/access-operations.ts
-var memoryGetSchema = z5.object({
-  memoryId: z5.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: z5.string().trim().min(1).max(512).nullable().optional(),
-  namespace: z5.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 = z5.object({
-  query: z5.string().trim().min(1, "query is required").max(2048),
-  namespace: z5.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: z5.number().int().min(1).nullable().optional(),
-  collection: z5.string().trim().min(1).max(256).nullable().optional(),
-  // Ranking mode. Mirrors the in-process manager's override so a host that
-  // asks for vector or lexical ranking gets the same semantics whether it
-  // talks to an embedded orchestrator or a standalone daemon (issue #2120).
-  mode: z5.enum(["search", "hybrid", "bm25", "vector"]).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,
-      mode: input.mode ?? void 0,
-      principal: ctx.authenticatedPrincipal
-    });
-    return { result };
-  }
-});
-var memoryStoreOperation = defineOperation({
-  name: "memory_store",
-  description: "Store an explicit memory through the access layer.",
-  // The canonical wire schema (issue #2482): its category transform already
-  // mapped compat aliases to "fact", so `input.category` is finite here. The
-  // raw spelling survives on `ctx.rawInput` for the coercion note (#2829).
-  schema: memoryStoreRequestSchema,
-  handler: async (input, ctx) => {
-    const rawCategory = retainedCategoryAlias(ctx.rawInput);
-    const result = await ctx.service.memoryStore(
-      {
-        ...input,
-        authenticatedPrincipal: ctx.authenticatedPrincipal,
-        ...ctx.sourceConnector ? { sourceConnector: ctx.sourceConnector } : {},
-        ...rawCategory ? { rawCategory } : {}
-      },
-      // 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 = z5.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;
-  },
-  z5.object({
-    subcommand: z5.enum(DECISION_SUBCOMMANDS),
-    sessionKey: z5.string().trim().max(512).optional(),
-    namespace: z5.string().trim().max(256).optional(),
-    id: z5.string().trim().max(512).optional(),
-    title: z5.string().trim().max(512).optional(),
-    status: z5.string().trim().max(64).optional(),
-    context: z5.string().trim().max(8192).optional(),
-    decision: z5.string().trim().max(8192).optional(),
-    consequences: z5.string().trim().max(8192).optional(),
-    entityRefs: z5.array(z5.string().trim().min(1).max(256)).optional(),
-    supersedesId: z5.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 = z5.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;
-  },
-  z5.object({
-    subcommand: z5.enum(["get", "refresh"]),
-    sessionKey: z5.string().optional(),
-    namespace: z5.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 = z5.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;
-  },
-  z5.object({
-    tool: z5.string().refine(isCodegraphToolName, {
-      message: "tool must be one of the codegraph tool names"
-    }),
-    sessionKey: z5.string().max(512).optional(),
-    principal: z5.string().max(256).optional(),
-    project: z5.string().max(256).optional(),
-    query: z5.string().max(2048).optional(),
-    limit: z5.number().int().positive().max(200).optional(),
-    start: z5.string().max(512).optional(),
-    direction: z5.string().max(64).optional(),
-    depth: z5.number().int().positive().max(10).optional(),
-    qualifiedName: z5.string().max(1024).optional(),
-    path: z5.string().max(2048).optional(),
-    structuredQuery: z5.record(z5.string(), z5.unknown()).optional(),
-    head: z5.string().max(256).optional(),
-    repoRoot: z5.string().max(2048).optional(),
-    mode: z5.string().max(64).optional(),
-    confirm: z5.boolean().optional(),
-    subcommand: z5.string().max(64).optional(),
-    id: z5.string().max(512).optional(),
-    title: z5.string().max(512).optional(),
-    status: z5.string().max(64).optional(),
-    context: z5.string().max(8192).optional(),
-    decision: z5.string().max(8192).optional(),
-    consequences: z5.string().max(8192).optional(),
-    entityRefs: z5.array(z5.string().max(256)).optional(),
-    supersedesId: z5.string().max(512).optional(),
-    traces: z5.array(z5.unknown()).optional()
-  })
-);
-var codingDeltaSchema = z5.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;
-  },
-  z5.object({
-    subcommand: z5.enum(DELTA_SUBCOMMANDS),
-    sessionKey: z5.string().trim().max(512).optional(),
-    namespace: z5.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 = z5.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;
-  },
-  z5.object({
-    text: z5.string().trim().min(1).max(1e4),
-    targetIds: z5.array(z5.string().trim().min(1).max(512)).optional(),
-    duplicateOf: z5.string().trim().min(1).max(512).optional(),
-    sessionKey: z5.string().trim().max(512).optional(),
-    namespace: z5.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.duplicateOf ? { duplicateOf: input.duplicateOf } : {},
-          ...input.sessionKey ? { sessionKey: input.sessionKey } : {},
-          ...input.namespace ? { namespace: input.namespace } : {},
-          ...ctx.authenticatedPrincipal ? { principal: ctx.authenticatedPrincipal } : {}
-        },
-        ctx.abortSignal ? { abortSignal: ctx.abortSignal } : void 0
-      );
-      return { result };
-    } catch (err) {
-      if (err instanceof CorrectionContractError) throw new EngramAccessInputError(err.message);
-      throw err;
-    }
-  }
-});
-var memoryCorrectApplySchema = z5.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;
-  },
-  z5.object({
-    planId: z5.string().trim().min(1).max(512),
-    confirm: z5.boolean().optional(),
-    sessionKey: z5.string().trim().max(512).optional(),
-    namespace: z5.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 } : {},
-        ...ctx.abortSignal ? { abortSignal: ctx.abortSignal } : {}
-      });
-      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,
-  externalWikiSearchOperation.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-BJRTMNCB.js.map