@remnic/core 9.30.1 → 9.31.0

package/src/access-cli.test.ts

@@ -1,5 +1,6 @@
 import assert from "node:assert/strict";
 import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { execFileSync } from "node:child_process";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
@@ -523,6 +524,98 @@ test("access-cli rejects adjacent option-looking values", async () => {
   assert.match(output, /missing required option: --content/);
 });
 
+test("access-cli extraction-flush drains the requested session through the boundary", async () => {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "remnic-access-cli-"));
+  let output = "";
+  const originalStdoutWrite = process.stdout.write;
+  process.stdout.write = ((chunk: string | Uint8Array) => {
+    output += String(chunk);
+    return true;
+  }) as typeof process.stdout.write;
+
+  try {
+    const configPath = path.join(tempDir, "openclaw.json");
+    writeOpenClawConfig(configPath, {
+      memoryDir: path.join(tempDir, "memory"),
+      defaultNamespace: "default",
+    });
+
+    await withPatchedEnv(
+      {
+        OPENCLAW_CONFIG_PATH: configPath,
+        OPENCLAW_ENGRAM_CONFIG_PATH: undefined,
+      },
+      async () => {
+        await main([
+          "extraction-flush",
+          "--session-key",
+          "cli:flush",
+          "--namespace",
+          "default",
+          "--deadline-ms",
+          String(Date.now() + 10_000),
+        ]);
+      },
+    );
+
+    assert.match(output, /"flushed": true/);
+    assert.match(output, /"sessionKey": "cli:flush"/);
+    assert.match(output, /"effectiveNamespace": "default"/);
+  } finally {
+    process.stdout.write = originalStdoutWrite;
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  }
+});
+
+test("access-cli extraction-flush expands tilde in cwd before resolving project scope", async () => {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "remnic-access-cli-"));
+  const repoDir = path.join(tempDir, "repo");
+  fs.mkdirSync(repoDir);
+  execFileSync("git", ["init", "-q"], { cwd: repoDir });
+  let output = "";
+  const originalStdoutWrite = process.stdout.write;
+  process.stdout.write = ((chunk: string | Uint8Array) => {
+    output += String(chunk);
+    return true;
+  }) as typeof process.stdout.write;
+
+  try {
+    const configPath = path.join(tempDir, "openclaw.json");
+    writeOpenClawConfig(configPath, {
+      namespacesEnabled: true,
+      defaultNamespace: "default",
+      agentAccessHttp: { principal: "pi-geek" },
+      principalFromSessionKeyMode: "prefix",
+      principalFromSessionKeyRules: [{ match: "cli:", principal: "pi-geek" }],
+      codingMode: { projectScope: true },
+    });
+
+    await withPatchedEnv(
+      {
+        HOME: tempDir,
+        OPENCLAW_CONFIG_PATH: configPath,
+        OPENCLAW_ENGRAM_CONFIG_PATH: undefined,
+      },
+      async () => {
+        await main([
+          "extraction-flush",
+          "--session-key",
+          "cli:tilde-cwd",
+          "--cwd",
+          "~/repo",
+          "--deadline-ms",
+          String(Date.now() + 10_000),
+        ]);
+      },
+    );
+
+    assert.match(output, /"effectiveNamespace": "default-project-/);
+  } finally {
+    process.stdout.write = originalStdoutWrite;
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  }
+});
+
 // ──────────────────────────────────────────────────────────────────────────
 // architecture command — wired through the boundary operation (#1548 PR3)
 // ──────────────────────────────────────────────────────────────────────────

package/src/access-cli.ts

@@ -15,7 +15,14 @@ import { projectTagProjectId } from "./coding/coding-namespace.js";
 
 const OPENCLAW_REMNIC_PLUGIN_IDS = ["openclaw-remnic", "openclaw-engram"] as const;
 
-type CommandName = "browse" | "store" | "decision" | "architecture" | "delta" | "correct";
+type CommandName =
+  | "browse"
+  | "store"
+  | "extraction-flush"
+  | "decision"
+  | "architecture"
+  | "delta"
+  | "correct";
 
 type ParsedArgs = {
   command: CommandName;
@@ -136,6 +143,7 @@ function usage(): string {
   return [
     "  engram-access browse [options]",
     "  engram-access store [options]",
+    "  engram-access extraction-flush [options]",
     "  engram-access decision [options]",
     "  engram-access architecture [options]",
     "  engram-access delta [options]",
@@ -165,6 +173,14 @@ function usage(): string {
     "  --idempotency-key <key>",
     "  --dry-run",
     "",
+    "Extraction flush options:",
+    "  --session-key <key>",
+    "  --namespace <name>",
+    "  --principal <principal>",
+    "  --cwd <path>",
+    "  --project-tag <tag>",
+    "  --deadline-ms <timestamp>",
+    "",
     "Decision options:",
     "  --subcommand <list|get|record|supersede>",
     "  --namespace <name>",
@@ -233,6 +249,10 @@ const COMMAND_SPECS: Record<CommandName, CommandSpec> = {
     ]),
     flagOptions: new Set(["dry-run"]),
   },
+  "extraction-flush": {
+    valueOptions: new Set(["session-key", "namespace", "principal", "cwd", "project-tag", "deadline-ms"]),
+    flagOptions: new Set(),
+  },
   decision: {
     valueOptions: new Set([
       "subcommand",
@@ -301,7 +321,15 @@ type BrowseSort = (typeof BROWSE_SORT_VALUES)[number];
  * `command: commandRaw` assignment below (codex review P2).
  */
 function isCommandName(value: string): value is CommandName {
-  return value === "browse" || value === "store" || value === "decision" || value === "architecture" || value === "delta" || value === "correct";
+  return (
+    value === "browse" ||
+    value === "store" ||
+    value === "extraction-flush" ||
+    value === "decision" ||
+    value === "architecture" ||
+    value === "delta" ||
+    value === "correct"
+  );
 }
 
 function parseArgs(argv: string[]): ParsedArgs {
@@ -561,6 +589,28 @@ async function runStore(args: ParsedArgs, preferredId?: string): Promise<void> {
   console.log(JSON.stringify(output.result, null, 2));
 }
 
+async function runExtractionFlush(args: ParsedArgs, preferredId?: string): Promise<void> {
+  const { config, service } = buildRuntime(preferredId);
+  const op = getOperation("extraction_force_flush");
+  if (!op) {
+    throw new Error("access-boundary: operation not registered: extraction_force_flush");
+  }
+  const output = (await op.run(
+    {
+      sessionKey: requireOption(args, "session-key"),
+      namespace: getLastOption(args, "namespace"),
+      cwd: expandOptionalPath(getLastOption(args, "cwd")),
+      projectTag: getLastOption(args, "project-tag"),
+      deadlineMs: parseIntegerOption(args, "deadline-ms", { min: 0 }),
+    },
+    {
+      service,
+      authenticatedPrincipal: getLastOption(args, "principal") ?? config.agentAccessHttp.principal,
+    },
+  )) as { result: unknown };
+  console.log(JSON.stringify(output.result, null, 2));
+}
+
 function expandOptionalPath(value: string | undefined): string | undefined {
   return value === undefined ? undefined : expandTildePath(value);
 }
@@ -805,6 +855,10 @@ export async function main(
     await runBrowse(args, options.preferredId);
     return;
   }
+  if (args.command === "extraction-flush") {
+    await runExtractionFlush(args, options.preferredId);
+    return;
+  }
   if (args.command === "decision") {
     await runDecision(args, options.preferredId);
     return;

package/src/access-extraction-force-flush.ts

@@ -0,0 +1,177 @@
+import { isAbortError, throwIfAborted } from "./abort-error.js";
+import { EngramAccessForbiddenError } from "./access-errors.js";
+import type { AccessObserveWriteSurfaceDeps } from "./access-observe-write-surface.js";
+import {
+  type EngramAccessExtractionForceFlushRequest,
+  type EngramAccessExtractionForceFlushResponse,
+  EngramAccessInputError,
+} from "./access-service.js";
+import { resolveNamespaceCapabilities } from "./capabilities.js";
+import { log } from "./logger.js";
+import { resolvePrincipal } from "./namespaces/principal.js";
+import { ExtractionDeadlineError } from "./orchestration/extraction-run.js";
+import { SessionOwnershipError, awaitSessionFlushPhase } from "./orchestration/session-context.js";
+import { pendingObserveScopeHint } from "./access-observe-helpers.js";
+
+type PendingObserveExtractionWaiter = (
+  sessionKey: string,
+  principal: string | undefined,
+  namespace: string | undefined,
+  abortSignal?: AbortSignal,
+  registerCancellation?: (cancel: () => void) => void,
+  scopeHint?: string,
+) => Promise<void>;
+
+export async function extractionForceFlush(
+  deps: AccessObserveWriteSurfaceDeps,
+  request: EngramAccessExtractionForceFlushRequest,
+  waitForPendingObserveExtraction?: PendingObserveExtractionWaiter
+): Promise<EngramAccessExtractionForceFlushResponse> {
+  if (!request.sessionKey || typeof request.sessionKey !== "string" || request.sessionKey.trim().length === 0) {
+    throw new EngramAccessInputError("sessionKey is required and must be a non-empty string");
+  }
+  if (request.deadlineMs !== undefined && (!Number.isFinite(request.deadlineMs) || request.deadlineMs < 0)) {
+    throw new EngramAccessInputError("deadlineMs must be a finite non-negative number");
+  }
+
+  const authenticatedPrincipal = request.authenticatedPrincipal?.trim();
+  throwIfAborted(request.abortSignal, "extraction force-flush aborted");
+
+  const namespacesEnabled = resolveNamespaceCapabilities(deps.orchestrator.config).namespaces === true;
+  const sessionPrincipal = namespacesEnabled
+    ? resolvePrincipal(request.sessionKey, deps.orchestrator.config)
+    : undefined;
+  if (namespacesEnabled) {
+    if (
+      !authenticatedPrincipal ||
+      (sessionPrincipal !== undefined && sessionPrincipal !== "default" && sessionPrincipal !== authenticatedPrincipal)
+    ) {
+      throw new EngramAccessInputError("sessionKey is not owned by authenticated principal");
+    }
+  }
+
+  let committed = false;
+  const markCommitted = (): void => {
+    if (committed) return;
+    committed = true;
+    request.onCommitted?.();
+  };
+  let abortHandler: (() => void) | undefined;
+
+  try {
+    const scope = await deps.resolveMemoryScopePlan(request);
+    const reservationScopeHint = pendingObserveScopeHint(request);
+    const cancelScopedPendingObserveExtractions = (): void => {
+      deps.cancelPendingObserveExtractions?.(
+        request.sessionKey,
+        scope.principal,
+        scope.writeNamespace,
+        reservationScopeHint,
+      );
+    };
+    if (request.abortSignal?.aborted) cancelScopedPendingObserveExtractions();
+    throwIfAborted(request.abortSignal, "extraction force-flush aborted");
+    if (typeof request.deadlineMs === "number" && request.deadlineMs <= Date.now()) {
+      cancelScopedPendingObserveExtractions();
+      throw new EngramAccessInputError("extraction force-flush deadline exceeded before buffer drain");
+    }
+    abortHandler = cancelScopedPendingObserveExtractions;
+    request.abortSignal?.addEventListener("abort", abortHandler, { once: true });
+    await awaitSessionFlushPhase(
+      () =>
+        deps.orchestrator.flushSession(request.sessionKey, {
+          reason: "access_force_flush",
+          abortSignal: request.abortSignal,
+          failOnExtractionFailure: true,
+          extractionDeadlineMs: request.deadlineMs,
+          writeNamespaceOverride: scope.writeNamespace,
+          principalOverride:
+            typeof scope.principal === "string" && scope.principal.length > 0 ? scope.principal : undefined,
+          scopeProfileWritePlan: scope.scopeProfilePlan,
+          onCommitted: markCommitted,
+        }),
+      {
+        abortSignal: request.abortSignal,
+        extractionDeadlineMs: request.deadlineMs,
+        reason: "access_force_flush",
+        deadlineStage: "buffer_drain",
+        onDeadline: cancelScopedPendingObserveExtractions,
+      }
+    );
+    // A flush with no buffered turns still consumes the lifecycle write;
+    // durable drains already invoked this idempotent callback.
+    markCommitted();
+
+    if (waitForPendingObserveExtraction) {
+      let cancelPendingObserveExtraction: (() => void) | undefined;
+      await awaitSessionFlushPhase(
+        () =>
+          waitForPendingObserveExtraction(
+            request.sessionKey,
+            scope.principal,
+            scope.writeNamespace,
+            request.abortSignal,
+            (cancel) => {
+              cancelPendingObserveExtraction = cancel;
+            },
+            reservationScopeHint,
+          ),
+        {
+          abortSignal: request.abortSignal,
+          extractionDeadlineMs: request.deadlineMs,
+          reason: "access_force_flush",
+          deadlineStage: "pending_observe_extraction",
+          onDeadline: () => {
+            cancelScopedPendingObserveExtractions();
+            cancelPendingObserveExtraction?.();
+          },
+        }
+      );
+    }
+
+    const buffer = deps.orchestrator.buffer;
+    if (buffer && typeof buffer.clearRetainedTurnsForSession === "function") {
+      try {
+        await awaitSessionFlushPhase(
+          () =>
+            buffer.clearRetainedTurnsForSession(request.sessionKey, namespacesEnabled ? scope.principal : undefined, {
+              abortSignal: request.abortSignal,
+              deadlineMs: request.deadlineMs,
+            }),
+          {
+            abortSignal: request.abortSignal,
+            extractionDeadlineMs: request.deadlineMs,
+            reason: "access_force_flush",
+            deadlineStage: "retained_turn_cleanup",
+          }
+        );
+      } catch (cleanupError) {
+        if (isAbortError(cleanupError) || cleanupError instanceof ExtractionDeadlineError) {
+          throw cleanupError;
+        }
+        log.warn(
+          `extractionForceFlush: retained-turn cleanup failed after a successful flush, continuing: ${
+            cleanupError instanceof Error ? cleanupError.message : String(cleanupError)
+          }`
+        );
+      }
+    }
+
+    return {
+      flushed: true,
+      sessionKey: request.sessionKey,
+      namespace: deps.legacyResponseNamespaceForScope(scope),
+      effectiveNamespace: scope.writeNamespace,
+    };
+  } catch (error) {
+    if (error instanceof SessionOwnershipError) {
+      throw new EngramAccessForbiddenError(error.message);
+    }
+    if (error instanceof ExtractionDeadlineError) {
+      throw new EngramAccessInputError(error.message);
+    }
+    throw error;
+  } finally {
+    if (abortHandler) request.abortSignal?.removeEventListener("abort", abortHandler);
+  }
+}

package/src/access-http-extraction-force-flush.test.ts

@@ -0,0 +1,132 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { EngramAccessHttpServer } from "./access-http.js";
+import type {
+  EngramAccessExtractionForceFlushRequest,
+  EngramAccessLcmCompactionFlushRequest,
+  EngramAccessService,
+} from "./access-service.js";
+
+test("HTTP extraction force-flush forwards validated scope and deadline to the access service", async () => {
+  const requests: EngramAccessExtractionForceFlushRequest[] = [];
+  const service = {
+    extractionForceFlush: async (request: EngramAccessExtractionForceFlushRequest) => {
+      requests.push(request);
+      return {
+        flushed: true,
+        sessionKey: request.sessionKey,
+        namespace: request.namespace ?? "default",
+        effectiveNamespace: request.namespace ?? "default",
+      };
+    },
+  } as unknown as EngramAccessService;
+  const server = new EngramAccessHttpServer({
+    service,
+    port: 0,
+    authToken: "test-token",
+    adminConsoleEnabled: false,
+  });
+
+  const status = await server.start();
+  try {
+    const response = await fetch(`http://127.0.0.1:${status.port}/engram/v1/extraction/flush`, {
+      method: "POST",
+      headers: {
+        authorization: "Bearer test-token",
+        "content-type": "application/json",
+      },
+      body: JSON.stringify({
+        sessionKey: "pi:session-1",
+        namespace: "team-project",
+        cwd: "/workspace/project",
+        projectTag: "Acme/Webshop",
+        deadlineMs: 1_900_000_000_000,
+      }),
+    });
+
+    assert.equal(response.status, 200);
+    assert.deepEqual(await response.json(), {
+      flushed: true,
+      sessionKey: "pi:session-1",
+      namespace: "team-project",
+      effectiveNamespace: "team-project",
+    });
+    assert.equal(requests.length, 1);
+    const [request] = requests;
+    assert.equal(request.sessionKey, "pi:session-1");
+    assert.equal(request.namespace, "team-project");
+    assert.equal(request.cwd, "/workspace/project");
+    assert.equal(request.projectTag, "Acme/Webshop");
+    assert.equal(request.deadlineMs, 1_900_000_000_000);
+    assert.ok(request.abortSignal instanceof AbortSignal);
+
+    const invalid = await fetch(`http://127.0.0.1:${status.port}/engram/v1/extraction/flush`, {
+      method: "POST",
+      headers: {
+        authorization: "Bearer test-token",
+        "content-type": "application/json",
+      },
+      body: JSON.stringify({ sessionKey: "pi:session-1", deadlineMs: -1 }),
+    });
+    assert.equal(invalid.status, 400);
+    assert.equal(requests.length, 1, "invalid requests must not reach the access service");
+  } finally {
+    await server.stop();
+  }
+});
+
+test("HTTP lifecycle flush preserves the scoped LCM compaction route", async () => {
+  const requests: EngramAccessLcmCompactionFlushRequest[] = [];
+  const service = {
+    lcmCompactionFlush: async (request: EngramAccessLcmCompactionFlushRequest) => {
+      requests.push(request);
+      return {
+        enabled: true,
+        flushed: true,
+        sessionKey: request.sessionKey,
+        namespace: request.namespace ?? "default",
+      };
+    },
+  } as unknown as EngramAccessService;
+  const server = new EngramAccessHttpServer({
+    service,
+    port: 0,
+    authToken: "test-token",
+    adminConsoleEnabled: false,
+  });
+
+  const status = await server.start();
+  try {
+    const response = await fetch(`http://127.0.0.1:${status.port}/remnic/v1/lcm/compaction/flush`, {
+      method: "POST",
+      headers: {
+        authorization: "Bearer test-token",
+        "content-type": "application/json",
+      },
+      body: JSON.stringify({
+        sessionKey: "pi:session-1",
+        namespace: "team-project",
+        cwd: "/workspace/project",
+        projectTag: "Acme/Webshop",
+      }),
+    });
+
+    assert.equal(response.status, 200);
+    assert.deepEqual(await response.json(), {
+      enabled: true,
+      flushed: true,
+      sessionKey: "pi:session-1",
+      namespace: "team-project",
+    });
+    assert.deepEqual(requests, [{
+      sessionKey: "pi:session-1",
+      namespace: "team-project",
+      cwd: "/workspace/project",
+      projectTag: "Acme/Webshop",
+      authenticatedPrincipal: undefined,
+    }]);
+  } finally {
+    await server.stop();
+  }
+});

package/src/access-http-lcm-compaction.ts

@@ -1,9 +1,13 @@
 import type { ServerResponse } from "node:http";
 
-import type { LcmCompactionFlushRequest } from "./access-schema.js";
-import type { EngramAccessLcmCompactionFlushResponse, EngramAccessService } from "./access-service.js";
+import type { LcmCompactionFlushRequest, LcmCompactionRecordRequest } from "./access-schema.js";
+import type {
+  EngramAccessLcmCompactionFlushResponse,
+  EngramAccessLcmCompactionRecordResponse,
+  EngramAccessService,
+} from "./access-service.js";
 
-type LcmCompactionService = Pick<EngramAccessService, "lcmCompactionFlush">;
+type LcmCompactionService = Pick<EngramAccessService, "lcmCompactionFlush" | "lcmCompactionRecord">;
 type JsonResponder = (res: ServerResponse, status: number, payload: unknown) => void;
 
 export interface LcmCompactionFlushHttpOptions {
@@ -24,28 +28,55 @@ export function respondLcmCompactionCapabilitiesHttp(response: ServerResponse):
   response.end(JSON.stringify({ lcmCompactionFlushBatch: true }, null, 2));
 }
 
-export async function handleLcmCompactionFlushHttp({
+export interface LcmCompactionFlushRunnerOptions {
+  body: LcmCompactionFlushRequest;
+  service: LcmCompactionService;
+  ensureWriteRateLimitAvailable: () => void;
+  recordWriteRateLimitHit: () => void;
+  resolveNamespace: (namespace?: string) => string | undefined;
+  defaultNamespace?: string;
+  resolveRequestPrincipal: () => string | undefined;
+}
+
+type LcmCompactionFlushBatchResult =
+  | {
+      namespace: string;
+      status: "fulfilled";
+      result: EngramAccessLcmCompactionFlushResponse;
+    }
+  | { namespace: string; status: "rejected" };
+
+type LcmCompactionFlushHttpResult =
+  | EngramAccessLcmCompactionFlushResponse
+  | {
+      enabled: boolean;
+      flushed: boolean;
+      sessionKey: string;
+      namespaces: string[];
+      results: LcmCompactionFlushBatchResult[];
+    };
+
+export async function runLcmCompactionFlushHttp({
   body,
   service,
-  response,
   ensureWriteRateLimitAvailable,
   recordWriteRateLimitHit,
   resolveNamespace,
   defaultNamespace,
   resolveRequestPrincipal,
-  respondJson,
-}: LcmCompactionFlushHttpOptions): Promise<void> {
+}: LcmCompactionFlushRunnerOptions): Promise<LcmCompactionFlushHttpResult> {
   ensureWriteRateLimitAvailable();
   const requestedNamespaces = body.namespaces;
   if (requestedNamespaces === undefined) {
     const result = await service.lcmCompactionFlush({
       sessionKey: body.sessionKey,
       namespace: resolveNamespace(body.namespace),
+      ...(body.cwd !== undefined ? { cwd: body.cwd } : {}),
+      ...(body.projectTag !== undefined ? { projectTag: body.projectTag } : {}),
       authenticatedPrincipal: resolveRequestPrincipal(),
     });
     recordWriteRateLimitHit();
-    respondJson(response, 200, result);
-    return;
+    return result;
   }
   const resolutionOutcomes = await Promise.allSettled(
     requestedNamespaces.map(async (requestedNamespace) => {
@@ -74,6 +105,8 @@ export async function handleLcmCompactionFlushHttp({
       service.lcmCompactionFlush({
         sessionKey: body.sessionKey,
         namespace,
+        ...(body.cwd !== undefined ? { cwd: body.cwd } : {}),
+        ...(body.projectTag !== undefined ? { projectTag: body.projectTag } : {}),
         authenticatedPrincipal: resolveRequestPrincipal(),
       })
     )
@@ -88,29 +121,73 @@ export async function handleLcmCompactionFlushHttp({
       serviceOutcomesByEffectiveNamespace.set(resolved.effectiveNamespace, serviceOutcome);
     }
   }
-  type BatchResult =
-    | {
-        requestedNamespace: string;
-        status: "fulfilled";
-        result: EngramAccessLcmCompactionFlushResponse;
-      }
-    | { requestedNamespace: string; status: "rejected" };
-  const results: BatchResult[] = resolutionOutcomes.map((outcome, index) => {
+  const results = resolutionOutcomes.map((outcome, index): LcmCompactionFlushBatchResult => {
     const requestedNamespace = requestedNamespaces[index] ?? "";
     if (outcome.status === "rejected") {
-      return { status: "rejected", requestedNamespace };
+      return { status: "rejected", namespace: requestedNamespace };
     }
     const serviceOutcome = serviceOutcomesByEffectiveNamespace.get(outcome.value.effectiveNamespace);
     return serviceOutcome?.status === "fulfilled"
-      ? { status: "fulfilled", requestedNamespace, result: serviceOutcome.value }
-      : { status: "rejected", requestedNamespace };
+      ? { status: "fulfilled", namespace: requestedNamespace, result: serviceOutcome.value }
+      : { status: "rejected", namespace: requestedNamespace };
   });
   recordWriteRateLimitHit();
-  respondJson(response, 200, {
+  return {
     enabled: results.every((result) => result.status === "fulfilled" && result.result.enabled !== false),
     flushed: results.every((result) => result.status === "fulfilled" && result.result.flushed !== false),
     sessionKey: body.sessionKey,
     namespaces: requestedNamespaces,
-    results: results.map(({ requestedNamespace, ...result }) => ({ ...result, namespace: requestedNamespace })),
+    results,
+  };
+}
+export async function handleLcmCompactionFlushHttp({
+  body,
+  service,
+  response,
+  ensureWriteRateLimitAvailable,
+  recordWriteRateLimitHit,
+  resolveNamespace,
+  defaultNamespace,
+  resolveRequestPrincipal,
+  respondJson,
+}: LcmCompactionFlushHttpOptions): Promise<void> {
+  const result = await runLcmCompactionFlushHttp({
+    body,
+    service,
+    ensureWriteRateLimitAvailable,
+    recordWriteRateLimitHit,
+    resolveNamespace,
+    defaultNamespace,
+    resolveRequestPrincipal,
   });
+  respondJson(response, 200, result);
+}
+
+export interface LcmCompactionRecordHttpOptions {
+  body: LcmCompactionRecordRequest;
+  service: LcmCompactionService;
+  ensureWriteRateLimitAvailable: () => void;
+  recordWriteRateLimitHit: () => void;
+  resolveNamespace: (namespace?: string) => string | undefined;
+  resolveRequestPrincipal: () => string | undefined;
+}
+
+export async function runLcmCompactionRecordHttp({
+  body,
+  service,
+  ensureWriteRateLimitAvailable,
+  recordWriteRateLimitHit,
+  resolveNamespace,
+  resolveRequestPrincipal,
+}: LcmCompactionRecordHttpOptions): Promise<EngramAccessLcmCompactionRecordResponse> {
+  ensureWriteRateLimitAvailable();
+  const response = await service.lcmCompactionRecord({
+    sessionKey: body.sessionKey,
+    namespace: resolveNamespace(body.namespace),
+    tokensBefore: body.tokensBefore,
+    tokensAfter: body.tokensAfter,
+    authenticatedPrincipal: resolveRequestPrincipal(),
+  });
+  recordWriteRateLimitHit();
+  return response;
 }