om-memory-system 3.6.0-next.37 → 3.6.0-next.39

package/dist/importer/web-import-jobs.js

@@ -33,8 +33,9 @@ export function validateWebImportRequest(value) {
     if (!value || typeof value !== "object" || Array.isArray(value))
         throw new Error("Invalid import request");
     const input = value;
-    if (input.host !== "pi" && input.host !== "opencode")
-        throw new Error("Choose Pi or OpenCode");
+    if (input.host !== "pi" && input.host !== "opencode" && input.host !== "claude-code") {
+        throw new Error("Choose Pi, OpenCode, or Claude Code");
+    }
     if (!input.options || typeof input.options !== "object" || Array.isArray(input.options))
         throw new Error("Invalid import options");
     const options = input.options;
@@ -72,12 +73,18 @@ export function validateWebImportRequest(value) {
         (typeof input.modelChoice !== "string" ||
             (input.modelChoice !== "external" && !/^[^/]+\/.+$/.test(input.modelChoice))))
         throw new Error("Choose a signed-in provider/model or the external API");
+    // Claude Code has no session model: its imports always use the external API.
+    if (input.host === "claude-code" &&
+        input.modelChoice !== undefined &&
+        input.modelChoice !== "external")
+        throw new Error("Claude Code imports use the external API");
+    const modelChoice = input.host === "claude-code" ? "external" : input.modelChoice;
     return {
         host: input.host,
         source: input.source,
         selection: validateImportSelection(input.selection),
         options: options,
-        modelChoice: input.modelChoice,
+        modelChoice,
     };
 }
 /** One in-memory slot per web server, shared by previews and imports. */

package/dist/index.js

@@ -1,13 +1,12 @@
 import { tool } from "@opencode-ai/plugin";
 import { memoryClient } from "./services/client.js";
-import { formatContextForPrompt } from "./services/context.js";
 import { getTags } from "./services/tags.js";
 import { performAutoCapture } from "./services/auto-capture.js";
 import { createOpenCodeAutoCaptureHost } from "./adapters/opencode/auto-capture-host.js";
 import { isInternalPrompt, isStructuredSummaryPromptMessage, recordUserPrompt, } from "./adapters/opencode/user-prompt.js";
 import { executeMemoryOperation } from "./core/memory-operations.js";
 import { OPENCODE_IMPORT_COMMAND, OPENCODE_IMPORT_DESCRIPTION, latestUserMessageModel, runOpencodeImportCommand, } from "./adapters/opencode/import-command.js";
-import { formatMemoriesForCompaction } from "./core/retrieval.js";
+import { buildRecentMemoriesSection, formatMemoriesForCompaction } from "./core/retrieval.js";
 import { performUserProfileLearning } from "./adapters/opencode/profile-learning.js";
 import { userPromptManager } from "./services/user-prompt/user-prompt-manager.js";
 import { startWebServer, WebServer } from "./services/web-server.js";
@@ -489,27 +488,14 @@ export const OmmsPlugin = async (ctx) => {
                             !m.parts.every((p) => p.type !== "text" || p.synthetic === true)).length === 1);
                 if (!shouldInject)
                     return;
-                const listResult = await memoryClient.listMemories(tags.project.tag, CONFIG.chatMessage.maxMemories);
-                let memories = listResult.success ? listResult.memories : [];
-                if (CONFIG.chatMessage.excludeCurrentSession) {
-                    memories = memories.filter((m) => m.metadata?.sessionID !== input.sessionID);
-                }
-                if (CONFIG.chatMessage.maxAgeDays) {
-                    const cutoffDate = Date.now() - CONFIG.chatMessage.maxAgeDays * 86400000;
-                    memories = memories.filter((m) => new Date(m.createdAt).getTime() > cutoffDate);
-                }
-                if (memories.length === 0)
-                    return;
-                const projectMemories = {
-                    results: memories.map((m) => ({
-                        similarity: 1.0,
-                        memory: m.summary,
-                    })),
-                    total: memories.length,
-                    timing: 0,
-                };
-                const userId = tags.user.userEmail || null;
-                const memoryContext = await formatContextForPrompt(userId, projectMemories);
+                const memoryContext = await buildRecentMemoriesSection({
+                    projectTag: tags.project.tag,
+                    userEmail: tags.user.userEmail,
+                    sessionId: input.sessionID,
+                    maxMemories: CONFIG.chatMessage.maxMemories,
+                    excludeCurrentSession: CONFIG.chatMessage.excludeCurrentSession,
+                    maxAgeDays: CONFIG.chatMessage.maxAgeDays,
+                });
                 if (memoryContext) {
                     const contextPart = {
                         id: `prt-memory-context-${Date.now()}`,

package/dist/services/ai/live-model-choice.d.ts

@@ -49,6 +49,11 @@ export declare function resolvePiLiveModel(config: AutoCaptureProviderRuntimeCon
     piProvider?: string;
     piModel?: string;
 }): PiLiveModelChoice;
+/**
+ * Claude Code's live model: the external API only. Its hooks cannot call the
+ * session's model, so there is no host model and no session fallback.
+ */
+export declare function resolveClaudeCodeLiveModel(config: AutoCaptureProviderRuntimeConfig): AutoCaptureProviderStatus;
 /** True when the external API is fully configured and can serve as a fallback. */
 export declare function isExternalModelReady(config: AutoCaptureProviderRuntimeConfig): boolean;
 /** Why the external API cannot be used as a host's chosen model, or an empty list. */

package/dist/services/ai/live-model-choice.js

@@ -93,6 +93,13 @@ export function resolvePiLiveModel(config) {
         return { kind: "session" };
     return { kind: "unready", issues: manual.issues };
 }
+/**
+ * Claude Code's live model: the external API only. Its hooks cannot call the
+ * session's model, so there is no host model and no session fallback.
+ */
+export function resolveClaudeCodeLiveModel(config) {
+    return externalChoiceStatus(config);
+}
 /** True when the external API is fully configured and can serve as a fallback. */
 export function isExternalModelReady(config) {
     return getManualProviderStatus(config).ready;

package/dist/services/backfill-state.d.ts

@@ -1,4 +1,4 @@
-type BackfillHost = "pi" | "opencode";
+type BackfillHost = "pi" | "opencode" | "claude-code";
 export type BackfillStatus = {
     host: BackfillHost;
     cutoff: number;

package/dist/services/capture-retry-queue.js

@@ -179,11 +179,12 @@ export async function deleteCaptureRetry(id, config) {
 export async function countCaptureRetries(config) {
     const db = await database(config);
     const rows = await db.all("SELECT host, COUNT(*) AS count FROM capture_retry_queue GROUP BY host");
-    const counts = { opencode: 0, pi: 0 };
+    const counts = { opencode: 0, pi: 0, "claude-code": 0 };
     for (const row of rows) {
         const host = String(row.host);
-        if (host === "opencode" || host === "pi")
+        if (host === "opencode" || host === "pi" || host === "claude-code") {
             counts[host] = Number(row.count);
+        }
     }
     return counts;
 }

package/dist/services/claude-capture-cursor.d.ts

@@ -0,0 +1,10 @@
+/**
+ * The last Claude Code user entry that live capture handled, per session. It
+ * lives in `user-prompts.db` next to the capture retry queue, so a web app
+ * restart does not capture the last turn again. Callers pass `CONFIG`.
+ */
+export interface ClaudeCaptureCursorConfig {
+    storagePath: string;
+}
+export declare function readClaudeCaptureCursor(sessionId: string, config: ClaudeCaptureCursorConfig): Promise<string | null>;
+export declare function writeClaudeCaptureCursor(sessionId: string, userEntryId: string, config: ClaudeCaptureCursorConfig, now?: number): Promise<void>;

package/dist/services/claude-capture-cursor.js

@@ -0,0 +1,44 @@
+import { join } from "node:path";
+import { tursoConnectionManager } from "./turso/connection-manager.js";
+/** A session with no capture for this long loses its cursor. */
+const CURSOR_RETENTION_MS = 30 * 24 * 60 * 60 * 1000;
+const prepared = new Map();
+async function database(config) {
+    const path = join(config.storagePath, "user-prompts.db");
+    const db = await tursoConnectionManager.getConnection(path);
+    let ready = prepared.get(path);
+    if (!ready) {
+        ready = db
+            .batch([
+            {
+                sql: `CREATE TABLE IF NOT EXISTS claude_capture_cursors (
+          session_id TEXT PRIMARY KEY,
+          last_user_entry_id TEXT NOT NULL,
+          updated_at INTEGER NOT NULL
+        )`,
+            },
+            {
+                sql: "DELETE FROM claude_capture_cursors WHERE updated_at < ?",
+                args: [Date.now() - CURSOR_RETENTION_MS],
+            },
+        ])
+            .then(() => undefined);
+        // A failed preparation is tried again on the next call.
+        ready.catch(() => prepared.delete(path));
+        prepared.set(path, ready);
+    }
+    await ready;
+    return db;
+}
+export async function readClaudeCaptureCursor(sessionId, config) {
+    const db = await database(config);
+    const row = await db.get("SELECT last_user_entry_id FROM claude_capture_cursors WHERE session_id = ?", [sessionId]);
+    return row ? String(row.last_user_entry_id) : null;
+}
+export async function writeClaudeCaptureCursor(sessionId, userEntryId, config, now = Date.now()) {
+    const db = await database(config);
+    await db.run(`INSERT INTO claude_capture_cursors (session_id, last_user_entry_id, updated_at)
+     VALUES (?, ?, ?)
+     ON CONFLICT(session_id) DO UPDATE SET
+       last_user_entry_id = excluded.last_user_entry_id, updated_at = excluded.updated_at`, [sessionId, userEntryId, now]);
+}

package/dist/services/settings-snapshot.d.ts

@@ -27,6 +27,7 @@ export declare function getSettingsSnapshot(directory: string): {
     effective: {
         opencode: import("./ai/live-model-choice.js").AutoCaptureProviderStatus;
         pi: import("./ai/live-model-choice.js").PiLiveModelChoice;
+        "claude-code": import("./ai/live-model-choice.js").AutoCaptureProviderStatus;
     };
 };
 /**

package/dist/services/settings-snapshot.js

@@ -3,7 +3,7 @@ import { join } from "node:path";
 import { parse } from "jsonc-parser";
 import { CONFIG, getGlobalConfigSourcePath } from "../config.js";
 import { readGlobalConfigRevision } from "./global-config-writer.js";
-import { getAutoCaptureProviderStatus, isExternalModelReady, resolvePiLiveModel, } from "./ai/live-model-choice.js";
+import { getAutoCaptureProviderStatus, isExternalModelReady, resolveClaudeCodeLiveModel, resolvePiLiveModel, } from "./ai/live-model-choice.js";
 const editable = [
     "opencodeProvider",
     "opencodeModel",
@@ -92,6 +92,8 @@ export function getSettingsSnapshot(directory) {
         effective: {
             opencode: getAutoCaptureProviderStatus(CONFIG),
             pi: resolvePiLiveModel(CONFIG),
+            // Claude Code capture uses the external API only; `issues` names each missing setting.
+            "claude-code": resolveClaudeCodeLiveModel(CONFIG),
         },
     };
 }

package/dist/services/version-compare.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Compare two versions in SemVer order. Returns a negative number when `a` is older,
+ * a positive number when `a` is newer, `0` when equal, and `null` when either
+ * version cannot be parsed, such as `unknown`.
+ */
+export declare function compareVersions(a: string, b: string): number | null;
+/** True only when `a` is provably older than `b`. An unplaceable version is never older. */
+export declare function isOlderVersion(a: string, b: string): boolean;

package/dist/services/version-compare.js

@@ -0,0 +1,58 @@
+const SEMVER = /^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/;
+function parse(version) {
+    const match = SEMVER.exec(version.trim());
+    if (!match)
+        return null;
+    return {
+        core: [Number(match[1]), Number(match[2]), Number(match[3])],
+        pre: match[4] ? match[4].split(".") : [],
+    };
+}
+function comparePart(a, b) {
+    const aNumeric = /^\d+$/.test(a);
+    const bNumeric = /^\d+$/.test(b);
+    if (aNumeric && bNumeric)
+        return Math.sign(Number(a) - Number(b));
+    // A numeric part is older than a text part.
+    if (aNumeric)
+        return -1;
+    if (bNumeric)
+        return 1;
+    return a < b ? -1 : a > b ? 1 : 0;
+}
+/**
+ * Compare two versions in SemVer order. Returns a negative number when `a` is older,
+ * a positive number when `a` is newer, `0` when equal, and `null` when either
+ * version cannot be parsed, such as `unknown`.
+ */
+export function compareVersions(a, b) {
+    const left = parse(a);
+    const right = parse(b);
+    if (!left || !right)
+        return null;
+    for (let i = 0; i < 3; i++) {
+        const diff = left.core[i] - right.core[i];
+        if (diff)
+            return Math.sign(diff);
+    }
+    // A release is newer than any of its prereleases.
+    if (!left.pre.length || !right.pre.length)
+        return right.pre.length - left.pre.length;
+    for (let i = 0; i < Math.max(left.pre.length, right.pre.length); i++) {
+        const l = left.pre[i];
+        const r = right.pre[i];
+        if (l === undefined)
+            return -1;
+        if (r === undefined)
+            return 1;
+        const diff = comparePart(l, r);
+        if (diff)
+            return diff;
+    }
+    return 0;
+}
+/** True only when `a` is provably older than `b`. An unplaceable version is never older. */
+export function isOlderVersion(a, b) {
+    const order = compareVersions(a, b);
+    return order !== null && order < 0;
+}

package/dist/services/web-api-auth.d.ts

@@ -1,4 +1,6 @@
 export declare function isLoopbackHost(host: string): boolean;
+/** True for a peer socket address on this machine: 127.x.x.x, ::1, or an IPv4-mapped 127.x.x.x. */
+export declare function isLoopbackAddress(address: string | undefined): boolean;
 /** A URL needs brackets around an IPv6 literal such as ::1. */
 export declare function webServerUrl(host: string, port: number): string;
 export declare function assertWebServerNetworkAuth(host: string, apiToken?: string, basicAuthEnabled?: boolean): void;

package/dist/services/web-api-auth.js

@@ -3,6 +3,16 @@ const LOOPBACK_HOSTS = new Set(["127.0.0.1", "localhost", "::1", "[::1]", "0:0:0
 export function isLoopbackHost(host) {
     return LOOPBACK_HOSTS.has(host.trim().toLowerCase());
 }
+/** True for a peer socket address on this machine: 127.x.x.x, ::1, or an IPv4-mapped 127.x.x.x. */
+export function isLoopbackAddress(address) {
+    if (!address)
+        return false;
+    const value = address
+        .trim()
+        .toLowerCase()
+        .replace(/^::ffff:/, "");
+    return value === "::1" || /^127(?:\.\d{1,3}){3}$/.test(value);
+}
 /** A URL needs brackets around an IPv6 literal such as ::1. */
 export function webServerUrl(host, port) {
     const urlHost = host.includes(":") && !host.startsWith("[") ? `[${host}]` : host;

package/dist/services/web-server.d.ts

@@ -23,6 +23,8 @@ interface WebServerConfig {
     enabled: boolean;
     auth?: WebAuth;
     apiToken?: string;
+    /** How long a stepped-aside server waits before it may take the port back. */
+    stepAsideHoldOffMs?: number;
 }
 export declare class WebServer {
     private server;
@@ -32,6 +34,9 @@ export declare class WebServer {
     private healthCheckInterval;
     private onTakeoverCallback;
     private onPortsExhaustedCallback;
+    private onStepAsideCallback;
+    private stepAsideTimer;
+    private holdOffTimer;
     private portsExhaustedNotified;
     private takeoverFailures;
     private readonly maxFallbackPort;
@@ -39,11 +44,17 @@ export declare class WebServer {
     private backfillControlsInstance?;
     /** Run an import-page action; errors carry their own status and never file contents. */
     private importResponse;
+    /** Claude Code hook requests; they reach this point only with a valid API token. */
+    private claudeHookResponse;
     private backfillControls;
     private importJobs;
     constructor(config: WebServerConfig);
     setOnTakeoverCallback(callback: () => Promise<void>): void;
     setOnPortsExhaustedCallback(callback: () => void): void;
+    /** Standalone web apps register this to exit when a newer OMMS asks them to step aside. */
+    setOnStepAside(callback: () => void | Promise<void>): void;
+    private scheduleStepAside;
+    private handleStepAside;
     start(): Promise<void>;
     private _start;
     private startHealthCheckLoop;

package/dist/services/web-server.js

@@ -5,7 +5,9 @@ import { join, dirname, extname, normalize, sep } from "node:path";
 import { fileURLToPath } from "node:url";
 import { log } from "./logger.js";
 import { corsPreflightResponse, disallowedCorsResponse, isAllowedBrowserOrigin } from "./cors.js";
-import { assertWebServerNetworkAuth, authorizeApiRequest, isLoopbackHost, webServerUrl, } from "./web-api-auth.js";
+import { assertWebServerNetworkAuth, authorizeApiRequest, isLoopbackAddress, isLoopbackHost, webServerUrl, } from "./web-api-auth.js";
+import { packageVersion } from "./package-version.js";
+import { isOlderVersion } from "./version-compare.js";
 import { getOrCreateAuthToken, isAuthorizedApiRequest } from "./auth-token.js";
 import { WebAuth } from "./web-auth.js";
 import { NODE_HTTP_IDLE_TIMEOUT_MS } from "./request-timeouts.js";
@@ -34,7 +36,7 @@ function serveFetch(opts) {
         const bunHandle = globalThis.Bun.serve({
             port: opts.port,
             hostname: opts.hostname,
-            fetch: opts.fetch,
+            fetch: (req, server) => opts.fetch(req, server.requestIP(req)?.address),
         });
         return Promise.resolve({ stop: () => bunHandle.stop() });
     }
@@ -67,7 +69,7 @@ function serveFetch(opts) {
                 signal: abortController.signal,
                 ...(hasBody ? { duplex: "half" } : {}),
             });
-            const webRes = await opts.fetch(webReq);
+            const webRes = await opts.fetch(webReq, req.socket.remoteAddress);
             if (destroyed)
                 return;
             res.statusCode = webRes.status;
@@ -138,6 +140,9 @@ export function nextFallbackPort(currentPort, failedTakeovers, maxFallbackPort,
     }
     return currentPort + 1;
 }
+const STEP_ASIDE_HOLD_OFF_MS = 60_000;
+/** Lets the 202 reply reach the caller before the server stops. */
+const STEP_ASIDE_REPLY_GRACE_MS = 100;
 export class WebServer {
     server = null;
     config;
@@ -146,6 +151,9 @@ export class WebServer {
     healthCheckInterval = null;
     onTakeoverCallback = null;
     onPortsExhaustedCallback = null;
+    onStepAsideCallback = null;
+    stepAsideTimer = null;
+    holdOffTimer = null;
     portsExhaustedNotified = false;
     takeoverFailures = 0;
     maxFallbackPort;
@@ -161,6 +169,26 @@ export class WebServer {
             return this.jsonResponse({ error: error instanceof Error ? error.message : "Import request failed" }, typeof code === "number" ? code : 400);
         }
     }
+    /** Claude Code hook requests; they reach this point only with a valid API token. */
+    async claudeHookResponse(req, path) {
+        const api = await import("../importer/claude-hook-api.js");
+        const body = await req.json().catch(() => null);
+        try {
+            if (path === "/api/claude/capture") {
+                return this.jsonResponse(api.handleClaudeCapture(body), 202);
+            }
+            const cwd = this.config.directory ?? process.cwd();
+            return this.jsonResponse(await api.handleClaudeRetrieve(body, {
+                startBackfill: async () => (await this.backfillControls()).startAuto("claude-code", cwd),
+            }));
+        }
+        catch (error) {
+            if (error instanceof api.ClaudeHookRequestError) {
+                return this.jsonResponse({ error: error.message }, error.status);
+            }
+            throw error;
+        }
+    }
     async backfillControls() {
         const { BackfillControls } = await import("../importer/web-import-api.js");
         return (this.backfillControlsInstance ??= new BackfillControls());
@@ -179,6 +207,57 @@ export class WebServer {
     setOnPortsExhaustedCallback(callback) {
         this.onPortsExhaustedCallback = callback;
     }
+    /** Standalone web apps register this to exit when a newer OMMS asks them to step aside. */
+    setOnStepAside(callback) {
+        this.onStepAsideCallback = callback;
+    }
+    scheduleStepAside() {
+        if (this.stepAsideTimer)
+            return;
+        this.stepAsideTimer = setTimeout(async () => {
+            this.stepAsideTimer = null;
+            if (this.onStepAsideCallback) {
+                try {
+                    await this.onStepAsideCallback();
+                }
+                catch (error) {
+                    log("Step-aside callback error", { error: String(error) });
+                }
+                return;
+            }
+            // Inside a host session: stop serving, keep the session alive, and let the
+            // newer web app bind the port before the takeover loop can run again.
+            await this.stop();
+            this.startPromise = null;
+            this.holdOffTimer = setTimeout(() => {
+                this.holdOffTimer = null;
+                this.startHealthCheckLoop();
+            }, this.config.stepAsideHoldOffMs ?? STEP_ASIDE_HOLD_OFF_MS);
+            this.holdOffTimer.unref();
+        }, STEP_ASIDE_REPLY_GRACE_MS);
+        this.stepAsideTimer.unref();
+    }
+    handleStepAside(remoteAddress, body) {
+        const callerVersion = body && typeof body.version === "string"
+            ? body.version.slice(0, 40)
+            : "";
+        const record = (outcome) => log("Web server step-aside request", {
+            outcome,
+            ownVersion: packageVersion(),
+            callerVersion,
+        });
+        if (!isLoopbackAddress(remoteAddress)) {
+            record("refused_auth");
+            return this.jsonResponse({ success: false, error: "Loopback caller required" }, 403);
+        }
+        if (!callerVersion || !isOlderVersion(packageVersion(), callerVersion)) {
+            record("refused_not_newer");
+            return this.jsonResponse({ success: false, error: "Caller is not newer" }, 409);
+        }
+        record("stepped_aside");
+        this.scheduleStepAside();
+        return this.jsonResponse({ success: true }, 202);
+    }
     async start() {
         if (this.startPromise) {
             return this.startPromise;
@@ -202,6 +281,10 @@ export class WebServer {
                 fetch: this.handleRequest.bind(this),
             });
             this.isOwner = true;
+            // This process serves the Claude Code hooks, so it also retries their failed captures.
+            void import("../importer/claude-hook-api.js")
+                .then(({ startClaudeCodeWorker }) => startClaudeCodeWorker())
+                .catch(() => { });
         }
         catch (error) {
             const errorMsg = String(error);
@@ -310,6 +393,11 @@ export class WebServer {
     }
     async stop() {
         this.stopHealthCheckLoop();
+        for (const timer of [this.stepAsideTimer, this.holdOffTimer])
+            if (timer)
+                clearTimeout(timer);
+        this.stepAsideTimer = null;
+        this.holdOffTimer = null;
         if (!this.isOwner || !this.server) {
             return;
         }
@@ -356,7 +444,7 @@ export class WebServer {
         }
     }
     // --- HTTP request handling ---
-    async handleRequest(req) {
+    async handleRequest(req, remoteAddress) {
         const url = new URL(req.url);
         const path = url.pathname;
         const method = req.method;
@@ -382,6 +470,13 @@ export class WebServer {
                 ? authorizeApiRequest(req, this.config.apiToken)
                 : null;
             if (!this.config.apiToken || configuredTokenFailure) {
+                if (path === "/api/web/step-aside") {
+                    log("Web server step-aside request", {
+                        outcome: "refused_auth",
+                        ownVersion: packageVersion(),
+                        callerVersion: "",
+                    });
+                }
                 return (configuredTokenFailure ??
                     this.jsonResponse({ success: false, error: "Unauthorized" }, 401));
             }
@@ -430,12 +525,13 @@ export class WebServer {
                 return this.jsonResponse({
                     pi: await readBackfillStatus("pi"),
                     opencode: await readBackfillStatus("opencode"),
+                    "claude-code": await readBackfillStatus("claude-code"),
                 });
             }
             if (path === "/api/settings/backfill/runs" && method === "GET") {
                 return this.jsonResponse(await (await this.backfillControls()).status());
             }
-            const backfillAction = /^\/api\/settings\/backfill\/(pi|opencode)\/(run|pause|resume)$/.exec(path);
+            const backfillAction = /^\/api\/settings\/backfill\/(pi|opencode|claude-code)\/(run|pause|resume)$/.exec(path);
             if (backfillAction && method === "POST") {
                 const host = backfillAction[1];
                 const controls = await this.backfillControls();
@@ -446,6 +542,10 @@ export class WebServer {
                         ? controls.resume(host, cwd)
                         : controls.runNow(host, cwd));
             }
+            if (path === "/api/web/step-aside" && method === "POST") {
+                const body = await req.json().catch(() => null);
+                return this.handleStepAside(remoteAddress, body);
+            }
             if (path === "/api/settings/version" && method === "GET") {
                 const [{ packageVersion }, { globalCommandVersion }] = await Promise.all([
                     import("./package-version.js"),
@@ -573,7 +673,7 @@ export class WebServer {
                     retryQueue: await countCaptureRetries(CONFIG),
                 });
             }
-            const retryNow = /^\/api\/settings\/capture-retry\/(pi|opencode)\/run$/.exec(path);
+            const retryNow = /^\/api\/settings\/capture-retry\/(pi|opencode|claude-code)\/run$/.exec(path);
             if (retryNow && method === "POST") {
                 const [{ CONFIG }, { requestCaptureRetryNow }] = await Promise.all([
                     import("../config.js"),
@@ -624,16 +724,16 @@ export class WebServer {
                     return this.jsonResponse({ error: "Browsing is available only on a loopback bind; enter a path instead" }, 403);
                 }
                 const body = (await req.json());
-                if (body?.host !== "pi" && body?.host !== "opencode") {
-                    return this.jsonResponse({ error: "Choose Pi or OpenCode" }, 400);
+                if (body?.host !== "pi" && body?.host !== "opencode" && body?.host !== "claude-code") {
+                    return this.jsonResponse({ error: "Choose Pi, OpenCode, or Claude Code" }, 400);
                 }
                 const { browseImportSources } = await import("../importer/web-import-api.js");
                 return this.importResponse(() => browseImportSources(body.host, body.path));
             }
             if (path === "/api/settings/imports/sources/validate" && method === "POST") {
                 const body = (await req.json());
-                if (body?.host !== "pi" && body?.host !== "opencode") {
-                    return this.jsonResponse({ error: "Choose Pi or OpenCode" }, 400);
+                if (body?.host !== "pi" && body?.host !== "opencode" && body?.host !== "claude-code") {
+                    return this.jsonResponse({ error: "Choose Pi, OpenCode, or Claude Code" }, 400);
                 }
                 const { validateImportSource } = await import("../importer/web-import-api.js");
                 return this.importResponse(() => validateImportSource(body.host, body.path));
@@ -722,6 +822,10 @@ export class WebServer {
                 const result = await handleSearch(query, tag, page, pageSize);
                 return this.jsonResponse(result);
             }
+            if ((path === "/api/claude/retrieve" || path === "/api/claude/capture") &&
+                method === "POST") {
+                return this.claudeHookResponse(req, path);
+            }
             if (path === "/api/stats" && method === "GET") {
                 const result = await handleStats();
                 return this.jsonResponse(result);

package/dist/types/host-label.d.ts

@@ -0,0 +1,3 @@
+import type { MemoryHost } from "./index.js";
+/** The host's display name in messages and reports. */
+export declare function hostLabel(host: MemoryHost): string;

package/dist/types/host-label.js

@@ -0,0 +1,9 @@
+const HOST_LABELS = {
+    opencode: "OpenCode",
+    pi: "Pi",
+    "claude-code": "Claude Code",
+};
+/** The host's display name in messages and reports. */
+export function hostLabel(host) {
+    return HOST_LABELS[host];
+}

package/dist/types/index.d.ts

@@ -1,5 +1,5 @@
 export type MemoryType = string;
-export type MemoryHost = "opencode" | "pi";
+export type MemoryHost = "opencode" | "pi" | "claude-code";
 export type MemorySourceType = "live-capture" | "history-import";
 export interface MemoryMetadata {
     type?: MemoryType;