dsh-supermemory 0.1.0

package/lib/index.mjs

@@ -0,0 +1,1282 @@
+import { a as getIncludeTools, c as loadSettings, d as getGitRoot, f as AUTH_BASE_URL, h as startAuthFlow, i as getBaseUrl, l as shouldIncludeTool, m as loadCredentials, n as debugLog, o as getRecallConfig, p as CREDENTIALS_FILE, r as getApiKey, s as getSignalConfig, t as SETTINGS_FILE, u as loadProjectConfig } from "./settings-BysiYjKM.mjs";
+import { fileURLToPath } from "node:url";
+import * as McpClient from "@deepseek-ai/dsh-mcp-client";
+import z from "@deepseek-ai/schemastery";
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import { execSync } from "node:child_process";
+import crypto from "node:crypto";
+import { createUserMessage } from "@deepseek-ai/dsh-llm";
+//#region src/config.ts
+const PluginConfig = z.object({
+	injectProfile: z.boolean().default(true),
+	recall: z.boolean().default(true),
+	capture: z.boolean().default(true),
+	autoApprove: z.boolean().default(true),
+	browserLogin: z.boolean().default(true),
+	mcp: z.boolean().default(true),
+	mcpServerName: z.string().default("supermemory"),
+	command: z.boolean().default(true),
+	contextGatherer: z.boolean().default(true),
+	includeSubagents: z.boolean().default(false)
+});
+//#endregion
+//#region src/lib/statusline-state.ts
+const SCHEMA_VERSION = 1;
+const STATE_DIR_NAME = "statusline-state";
+const EVENT_NAMES = /* @__PURE__ */ new Set([
+	"context",
+	"capture",
+	"search"
+]);
+const SESSION_RETENTION_MS = 6048e5;
+function resolveStatuslineDataDir(explicitDir) {
+	return explicitDir || path.join(os.homedir(), ".supermemory-claude", "statusline");
+}
+function hashValue(value) {
+	return crypto.createHash("sha256").update(String(value)).digest("hex");
+}
+function normalizeCount(value) {
+	const count = Number(value);
+	if (!Number.isFinite(count)) return 0;
+	return Math.max(0, Math.floor(count));
+}
+function getStateRoot(dataDir) {
+	return path.join(resolveStatuslineDataDir(dataDir), STATE_DIR_NAME);
+}
+function getSessionDir(sessionId, dataDir) {
+	if (typeof sessionId !== "string" || !sessionId.trim()) return null;
+	return path.join(getStateRoot(dataDir), hashValue(sessionId.trim()));
+}
+function ensurePrivateDir(dir) {
+	fs.mkdirSync(dir, {
+		recursive: true,
+		mode: 448
+	});
+	try {
+		fs.chmodSync(dir, 448);
+	} catch {}
+}
+function atomicWriteJson(file, value) {
+	const dir = path.dirname(file);
+	ensurePrivateDir(dir);
+	const temporary = path.join(dir, `.${path.basename(file)}.${process.pid}.${crypto.randomUUID()}.tmp`);
+	try {
+		fs.writeFileSync(temporary, JSON.stringify(value), {
+			encoding: "utf8",
+			flag: "wx",
+			mode: 384
+		});
+		fs.renameSync(temporary, file);
+		try {
+			fs.chmodSync(file, 384);
+		} catch {}
+	} finally {
+		try {
+			fs.unlinkSync(temporary);
+		} catch {}
+	}
+}
+function sanitizeEvent(event, data) {
+	if (event === "context") return {
+		status: [
+			"loading",
+			"ready",
+			"error"
+		].includes(data.status) ? data.status : "ready",
+		memoryItemsLoaded: normalizeCount(data.memoryItemsLoaded)
+	};
+	if (event === "capture") return {
+		status: [
+			"saving",
+			"saved",
+			"error"
+		].includes(data.status) ? data.status : "error",
+		count: normalizeCount(data.count)
+	};
+	return {
+		results: normalizeCount(data.results),
+		count: normalizeCount(data.count),
+		memories: normalizeCount(data.memories)
+	};
+}
+function writeState(sessionId, event, data = {}, options = {}) {
+	if (!EVENT_NAMES.has(event)) return false;
+	const sessionDir = getSessionDir(sessionId, options.dataDir);
+	if (!sessionDir) return false;
+	try {
+		const record = {
+			version: SCHEMA_VERSION,
+			event,
+			updatedAt: options.now ?? Date.now(),
+			...sanitizeEvent(event, data)
+		};
+		atomicWriteJson(path.join(sessionDir, `${event}.json`), record);
+		return true;
+	} catch {
+		return false;
+	}
+}
+function readEvent(sessionDir, event) {
+	try {
+		const record = JSON.parse(fs.readFileSync(path.join(sessionDir, `${event}.json`), "utf8"));
+		if (record?.version !== SCHEMA_VERSION || record?.event !== event || !Number.isFinite(record?.updatedAt)) return null;
+		return record;
+	} catch {
+		return null;
+	}
+}
+function readState(sessionId, options = {}) {
+	const sessionDir = getSessionDir(sessionId, options.dataDir);
+	if (!sessionDir) return {};
+	return {
+		context: readEvent(sessionDir, "context"),
+		capture: readEvent(sessionDir, "capture"),
+		search: readEvent(sessionDir, "search")
+	};
+}
+function pruneState(options = {}) {
+	const root = getStateRoot(options.dataDir);
+	const cutoff = (options.now ?? Date.now()) - SESSION_RETENTION_MS;
+	try {
+		for (const entry of fs.readdirSync(root, { withFileTypes: true })) {
+			if (!entry.isDirectory() || !/^[a-f0-9]{64}$/.test(entry.name)) continue;
+			const sessionDir = path.join(root, entry.name);
+			let newest = 0;
+			try {
+				newest = fs.statSync(sessionDir).mtimeMs;
+				for (const file of fs.readdirSync(sessionDir)) newest = Math.max(newest, fs.statSync(path.join(sessionDir, file)).mtimeMs);
+			} catch {
+				continue;
+			}
+			if (newest < cutoff) fs.rmSync(sessionDir, {
+				recursive: true,
+				force: true
+			});
+		}
+	} catch {}
+}
+//#endregion
+//#region src/lib/colors.ts
+const enabled = !process.env.NO_COLOR;
+const wrap = (code) => (s) => enabled ? `\x1b[${code}m${s}\x1b[0m` : s;
+const blue = wrap("38;2;124;120;250");
+const bold = wrap("1");
+const gray = wrap("38;5;245");
+const red = wrap("31");
+const MARK = blue(bold("◪"));
+const BRAND = `${MARK} ${bold("supermemory")}`;
+//#endregion
+//#region src/runtime.ts
+/** The `{kind:'plugin'}` source stamped on every context this plugin injects. */
+const PLUGIN_SOURCE = {
+	kind: "plugin",
+	plugin: "supermemory"
+};
+function createRuntime(ctx) {
+	const logger = ctx.logger("supermemory");
+	return {
+		ctx,
+		bootstraps: /* @__PURE__ */ new Map(),
+		delivered: /* @__PURE__ */ new Set(),
+		notify(text) {
+			logger.info(`${BRAND} ${gray("·")} ${text}`);
+		},
+		warn(text) {
+			logger.warn(`${BRAND} ${gray("·")} ${text}`);
+		}
+	};
+}
+/** The session workspace an agent runs in, matching every other DSH plugin. */
+function cwdOf(agent) {
+	return agent?.session.header.cwd ?? process.cwd();
+}
+function sessionIdOf(agent) {
+	return String(agent?.session.header.id ?? "");
+}
+/**
+* Claude Code fires SessionStart, UserPromptSubmit, and Stop for the main
+* session only — a Task subagent gets SubagentStart/SubagentStop, which this
+* plugin does not hook. DSH dispatches the same extension points to every
+* agent, so delegated sessions are filtered out to keep the behavior identical.
+*/
+function isSubagent(agent) {
+	return agent?.session.header.origin === "subagent";
+}
+//#endregion
+//#region src/approve.ts
+const TOOL_NAME_RE = /^mcp__(?:plugin_supermemory_|claude_ai_)?supermemory__(.+)$/;
+const READ_ONLY_TOOLS = /* @__PURE__ */ new Set([
+	"search_memory",
+	"listSpaces",
+	"listMemories",
+	"listDocuments",
+	"getDocument",
+	"whoAmI",
+	"memory-graph",
+	"fetch-graph-data"
+]);
+/** The read-only tool name behind a supermemory MCP call, or null. */
+function readOnlyToolOf(toolName, serverName) {
+	const escaped = serverName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+	const tool = new RegExp(`^mcp__${escaped}__(.+)$`).exec(toolName)?.[1] ?? TOOL_NAME_RE.exec(toolName)?.[1];
+	return tool && READ_ONLY_TOOLS.has(tool) ? tool : null;
+}
+/**
+* Registered with `prepend: true` so it sits outermost in the waterfall and
+* returns without delegating: no later listener — including a composed Claude
+* Code hooks bridge that would answer `ask` — can turn a read-only recall into
+* an approval prompt. Monotonic guards still apply, by design.
+*/
+function registerApprove(ctx, rt, config) {
+	const serverName = config.mcpServerName ?? "supermemory";
+	ctx.on("tools/pre-execute", async (exec, next) => {
+		const settings = loadSettings();
+		try {
+			const tool = readOnlyToolOf(exec.name, serverName);
+			if (!tool) return next();
+			debugLog(settings, "Auto-approving supermemory recall", { tool });
+			const sessionId = sessionIdOf(exec.agent);
+			const query = typeof exec.arguments?.query === "string" ? exec.arguments.query : null;
+			if (tool === "search_memory" && sessionId) {
+				const prev = readState(sessionId).search;
+				writeState(sessionId, "search", {
+					results: 0,
+					count: (prev?.count ?? 0) + 1,
+					memories: prev?.memories ?? 0
+				});
+			}
+			rt.notify(query ? `recalling: ${query}` : "recalling memories");
+			return { kind: "allow" };
+		} catch (err) {
+			debugLog(settings, "Recall approve error", { error: err.message });
+			return next();
+		}
+	}, { prepend: true });
+}
+//#endregion
+//#region src/lib/api.ts
+const AGENT_ENTITY_CONTEXT = `Shared coding-agent memory for one software repository.
+
+RULES:
+- Try to remember things that a human would remember — a teammate recalls decisions and lessons, not what state the working tree was in
+- Preserve durable context that helps a coding agent continue the work
+- Condense assistant responses into decisions, outcomes, and reusable knowledge
+- Keep user preferences and project facts concise and independently understandable
+
+EXTRACT:
+- User preferences, accepted decisions, durable workflows, actions, and learnings
+- Architecture: "uses monorepo with turborepo", "API in /apps/api"
+- Conventions: "components in PascalCase", "hooks prefixed with use"
+- Patterns: "all API routes use withAuth wrapper", "errors thrown as ApiError"
+- Setup: "requires .env with DATABASE_URL", "run pnpm db:migrate first"
+- Decisions: "chose Drizzle over Prisma for performance", "using RSC for data fetching"
+
+SKIP:
+- Transient repo state git already tracks: uncommitted file lists, current branch position, in-flight commit/push status
+- Generic assistant suggestions the user did not accept
+- Transient command output and low-value implementation chatter
+- Granular details that do not help future work`;
+const REQUEST_TIMEOUT_MS = 3e3;
+async function post(baseUrl, apiKey, path, body, timeoutMs = REQUEST_TIMEOUT_MS) {
+	const response = await fetch(`${baseUrl.replace(/\/+$/, "")}${path}`, {
+		method: "POST",
+		headers: {
+			Authorization: `Bearer ${apiKey}`,
+			"Content-Type": "application/json",
+			"x-sm-source": "claude-code"
+		},
+		body: JSON.stringify(body),
+		signal: AbortSignal.timeout(timeoutMs)
+	});
+	if (!response.ok) {
+		const text = await response.text().catch(() => "");
+		throw Object.assign(/* @__PURE__ */ new Error(`Supermemory API ${response.status}: ${text.slice(0, 200)}`), { status: response.status });
+	}
+	return await response.json();
+}
+function getProfile(baseUrl, apiKey, containerTag, query, options = {}) {
+	return post(baseUrl, apiKey, "/v4/profile", {
+		containerTag,
+		q: query
+	}, options.timeoutMs);
+}
+function addMemory(baseUrl, apiKey, content, containerTag, metadata, options = {}) {
+	const body = {
+		content,
+		containerTag,
+		metadata: {
+			sm_source: "claude-code",
+			...metadata
+		}
+	};
+	if (options.customId) body.customId = options.customId;
+	if (options.entityContext) body.entityContext = options.entityContext;
+	return post(baseUrl, apiKey, "/v3/documents", body, options.timeoutMs);
+}
+//#endregion
+//#region src/lib/container-tag.ts
+function sha256(input) {
+	return crypto.createHash("sha256").update(input).digest("hex").slice(0, 16);
+}
+const repoInfoCache = /* @__PURE__ */ new Map();
+function normalizeGitRemote(remoteUrl) {
+	const raw = remoteUrl.trim();
+	if (!raw) return null;
+	let normalized;
+	if (/^[a-z][a-z\d+.-]*:\/\//i.test(raw)) try {
+		const parsed = new URL(raw);
+		if (parsed.protocol === "file:") normalized = `file:${decodeURIComponent(parsed.pathname)}`;
+		else normalized = `${parsed.hostname.toLowerCase()}${parsed.port ? `:${parsed.port}` : ""}/${parsed.pathname.replace(/^\/+/, "")}`;
+	} catch {
+		normalized = raw;
+	}
+	else {
+		const scpStyle = raw.match(/^(?:[^@/]+@)?([^:]+):(.+)$/);
+		normalized = scpStyle ? `${scpStyle[1].toLowerCase()}/${scpStyle[2]}` : `file:${path.resolve(raw)}`;
+	}
+	return normalized.replace(/[?#].*$/, "").replace(/\/+$/, "").replace(/\.git$/i, "").replace(/\/{2,}/g, "/").toLowerCase();
+}
+function getGitRepoInfo(cwd) {
+	const cached = repoInfoCache.get(cwd);
+	if (cached) return cached;
+	try {
+		const remoteUrl = execSync("git remote get-url origin", {
+			cwd,
+			encoding: "utf-8",
+			stdio: [
+				"pipe",
+				"pipe",
+				"pipe"
+			]
+		}).trim();
+		const normalizedRemote = normalizeGitRemote(remoteUrl);
+		const displayRemote = remoteUrl.replace(/\/+$/, "").replace(/\.git$/i, "");
+		const separator = Math.max(displayRemote.lastIndexOf("/"), displayRemote.lastIndexOf(":"));
+		const result = {
+			name: displayRemote.slice(separator + 1) || null,
+			normalizedRemote
+		};
+		repoInfoCache.set(cwd, result);
+		return result;
+	} catch {
+		const result = {
+			name: null,
+			normalizedRemote: null
+		};
+		repoInfoCache.set(cwd, result);
+		return result;
+	}
+}
+function getGitRepoName(cwd) {
+	return getGitRepoInfo(cwd).name;
+}
+function getProjectBasePath(cwd) {
+	return getGitRoot(cwd) || path.resolve(cwd);
+}
+function sanitizeRepoName(name) {
+	return (name.toLowerCase().replace(/[^a-z0-9]/g, "_").replace(/_+/g, "_").replace(/^_|_$/g, "") || "unknown").slice(0, 95).replace(/_+$/g, "") || "unknown";
+}
+function getProjectIdentity(cwd) {
+	const basePath = getProjectBasePath(cwd);
+	const { normalizedRemote } = getGitRepoInfo(basePath);
+	const isolateWorktrees = process.env.SUPERMEMORY_ISOLATE_WORKTREES === "true";
+	let localIdentity = basePath;
+	try {
+		localIdentity = fs.realpathSync.native(basePath);
+	} catch {}
+	return sha256(!isolateWorktrees && normalizedRemote ? normalizedRemote : `path:${localIdentity}`);
+}
+function getGeneratedContainerTag(cwd) {
+	const basePath = getProjectBasePath(cwd);
+	return `repo_${sanitizeRepoName(getGitRepoName(basePath) || path.basename(basePath) || "unknown").slice(0, 72).replace(/_+$/g, "") || "unknown"}__${getProjectIdentity(cwd)}`;
+}
+function getContainerTag(cwd) {
+	return loadProjectConfig(cwd)?.repoContainerTag || process.env.SUPERMEMORY_REPO_TAG || getGeneratedContainerTag(cwd);
+}
+function getProjectName(cwd) {
+	const basePath = getProjectBasePath(cwd);
+	return getGitRepoName(basePath) || path.basename(basePath) || "unknown";
+}
+//#endregion
+//#region src/lib/error-helpers.ts
+/** Map an API error (or any Error) to a concise, actionable message. */
+function getUserFriendlyError(err) {
+	const error = err ?? {};
+	const status = error.status;
+	if (error.name === "TimeoutError" || error.name === "AbortError" || error.message === "fetch failed") return "Supermemory unreachable (network) — continuing without memory.";
+	if (status === 400) return "Bad request — your API key or request format may be invalid. Check your key at https://console.supermemory.ai";
+	if (status === 401) return "Authentication failed — your API key may be expired or revoked. Re-authenticate with the supermemory login command or check https://console.supermemory.ai";
+	if (status === 403) return "Permission denied — this feature may require a different Supermemory plan. Check https://supermemory.ai/pricing";
+	if (status === 429) return "Rate limited — too many requests. Will retry next session.";
+	if (typeof status === "number" && status >= 500) return "Supermemory service is temporarily unavailable. Will retry next session.";
+	return error.message || "Unknown error";
+}
+//#endregion
+//#region src/lib/last-session.ts
+const SETTINGS_DIR = path.join(os.homedir(), ".supermemory-claude");
+const LAST_SESSION_FILE = path.join(SETTINGS_DIR, "last-session.json");
+const OLD_PLAIN_ID_FILE = path.join(SETTINGS_DIR, "last-session-document-id");
+function ensureDir() {
+	if (!fs.existsSync(SETTINGS_DIR)) fs.mkdirSync(SETTINGS_DIR, { recursive: true });
+}
+/** Save the current session's Supermemory document info for deep links. */
+function saveLastSession({ id, containerTag }) {
+	if (!id) return;
+	ensureDir();
+	const data = {
+		id,
+		containerTag: containerTag || null,
+		savedAt: (/* @__PURE__ */ new Date()).toISOString()
+	};
+	fs.writeFileSync(LAST_SESSION_FILE, JSON.stringify(data, null, 2));
+	try {
+		if (fs.existsSync(OLD_PLAIN_ID_FILE)) fs.unlinkSync(OLD_PLAIN_ID_FILE);
+	} catch {}
+}
+//#endregion
+//#region src/transcript.ts
+/**
+* Turn-delta extraction, ported from the Claude Code plugin's transcript
+* reader. Claude Code parses a JSONL transcript file; DSH exposes no artifact
+* path, so the same delta is read from the durable session log instead. The
+* emitted text — the `<|start|>role<|message|>…<|end|>` lines inside a
+* `<|turn_start|>`/`<|turn_end|>` envelope — is byte-identical to what the
+* Claude Code plugin sends, so both harnesses write memories in one shape.
+*
+* The cursor is a `SessionSeq` rather than a message uuid, stored in the same
+* tracker directory the Claude Code plugin uses.
+*/
+const MAX_TOOL_RESULT_LENGTH = 500;
+const TRACKER_DIR = path.join(os.homedir(), ".supermemory-claude", "trackers");
+let toolUseMap = /* @__PURE__ */ new Map();
+let currentIncludeList = [];
+function ensureTrackerDir() {
+	if (!fs.existsSync(TRACKER_DIR)) fs.mkdirSync(TRACKER_DIR, { recursive: true });
+}
+/** The last captured sequence number for a session, or null before the first capture. */
+function getLastCapturedSeq(sessionId) {
+	ensureTrackerDir();
+	const trackerFile = path.join(TRACKER_DIR, `${sessionId}.txt`);
+	if (fs.existsSync(trackerFile)) {
+		const raw = fs.readFileSync(trackerFile, "utf-8").trim();
+		const seq = Number.parseInt(raw, 10);
+		return Number.isFinite(seq) ? seq : null;
+	}
+	return null;
+}
+function setLastCapturedSeq(sessionId, seq) {
+	ensureTrackerDir();
+	const trackerFile = path.join(TRACKER_DIR, `${sessionId}.txt`);
+	fs.writeFileSync(trackerFile, String(seq));
+}
+function blocksOf(value) {
+	const content = value?.content;
+	return Array.isArray(content) ? content : [];
+}
+/**
+* Project session-log events onto the user/assistant entry list the Claude
+* Code formatter expects. A `tool/result` event becomes a user entry carrying
+* one tool-result block, exactly where Claude Code's transcript puts it.
+*/
+function entriesFromEvents(events) {
+	const entries = [];
+	for (const event of events) {
+		const timestamp = new Date(event.time ?? Date.now()).toISOString();
+		if (event.type === "user/message") entries.push({
+			type: "user",
+			seq: event.seq,
+			timestamp,
+			content: blocksOf(event.data)
+		});
+		else if (event.type === "assistant/message") {
+			const message = event.data?.message;
+			entries.push({
+				type: "assistant",
+				seq: event.seq,
+				timestamp,
+				content: blocksOf(message)
+			});
+		} else if (event.type === "tool/result") {
+			const message = event.data?.message;
+			entries.push({
+				type: "user",
+				seq: event.seq,
+				timestamp,
+				content: blocksOf(message)
+			});
+		}
+	}
+	return entries;
+}
+function textOfBlocks(blocks) {
+	if (!Array.isArray(blocks)) return "";
+	return blocks.filter((block) => block.type === "text").map((block) => block.text ?? "").join("");
+}
+function formatUserEntry(entry) {
+	const parts = [];
+	for (const block of entry.content) if (block.type === "text") {
+		const cleaned = cleanContent(block.text ?? "");
+		if (cleaned) parts.push(`<|start|>user<|message|>${cleaned}<|end|>`);
+	} else if (block.type === "tool-result") {
+		const result = block;
+		const toolName = toolUseMap.get(result.toolCallId ?? "") || "Unknown";
+		if (!shouldIncludeTool(toolName, currentIncludeList)) continue;
+		const resultContent = truncate(cleanContent(textOfBlocks(result.content)), MAX_TOOL_RESULT_LENGTH);
+		const status = result.isError ? "error" : "success";
+		if (resultContent) parts.push(`<|start|>assistant:tool_result<|message|>${toolName}(${status}): ${resultContent}<|end|>`);
+	}
+	return parts.length > 0 ? parts.join("\n") : null;
+}
+function formatAssistantEntry(entry) {
+	const parts = [];
+	for (const block of entry.content) {
+		if (block.type === "reasoning") continue;
+		if (block.type === "text") {
+			const cleaned = cleanContent(block.text ?? "");
+			if (cleaned) parts.push(`<|start|>assistant<|message|>${cleaned}<|end|>`);
+		} else if (block.type === "tool-call") {
+			const call = block;
+			const toolName = call.name || "Unknown";
+			const toolId = call.id || "";
+			if (toolId) toolUseMap.set(toolId, toolName);
+			if (!shouldIncludeTool(toolName, currentIncludeList)) continue;
+			parts.push(`<|start|>assistant:tool<|message|>${toolName}: ${formatToolInputCompact(call.arguments)}<|end|>`);
+		}
+	}
+	return parts.length > 0 ? parts.join("\n") : null;
+}
+function formatEntry(entry) {
+	return (entry.type === "user" ? formatUserEntry(entry) : formatAssistantEntry(entry)) ?? "";
+}
+function formatToolInputCompact(rawArguments) {
+	let input = {};
+	try {
+		const parsed = JSON.parse(rawArguments ?? "{}");
+		if (parsed && typeof parsed === "object") input = parsed;
+	} catch {
+		return truncate(rawArguments ?? "", 100) ?? "";
+	}
+	const parts = [];
+	for (const [key, value] of Object.entries(input)) {
+		let valueStr = typeof value === "string" ? value : JSON.stringify(value);
+		valueStr = truncate(valueStr, 100) ?? "";
+		parts.push(`${key}="${valueStr}"`);
+	}
+	return parts.join(" ");
+}
+function cleanContent(text) {
+	if (!text || typeof text !== "string") return "";
+	return text.replace(/<system-reminder>[\s\S]*?<\/system-reminder>/g, "").replace(/<supermemory-context>[\s\S]*?<\/supermemory-context>/g, "").replace(/<supermemory-recall>[\s\S]*?<\/supermemory-recall>/g, "").replace(/<supermemory-status>[\s\S]*?<\/supermemory-status>/g, "").trim();
+}
+function truncate(text, maxLength) {
+	if (!text || text.length <= maxLength) return text;
+	return `${text.slice(0, maxLength)}...`;
+}
+function getTextFromEntry(entry) {
+	return cleanContent(textOfBlocks(entry.content));
+}
+function hasTextContent(entry) {
+	return getTextFromEntry(entry).length > 0;
+}
+function groupEntriesIntoTurns(entries) {
+	const turns = [];
+	let currentTurn = {
+		userEntries: [],
+		assistantEntries: [],
+		allEntries: []
+	};
+	for (const entry of entries) if (entry.type === "user") {
+		if (currentTurn.assistantEntries.length > 0) {
+			turns.push(currentTurn);
+			currentTurn = {
+				userEntries: [],
+				assistantEntries: [],
+				allEntries: []
+			};
+		}
+		currentTurn.userEntries.push(entry);
+		currentTurn.allEntries.push(entry);
+	} else {
+		currentTurn.assistantEntries.push(entry);
+		currentTurn.allEntries.push(entry);
+	}
+	if (currentTurn.allEntries.length > 0) turns.push(currentTurn);
+	return turns;
+}
+function groupEntriesIntoSignalTurns(entries) {
+	const turns = [];
+	let currentTurn = { userEntries: [] };
+	let lastAssistantEntry = null;
+	const pushTurn = () => {
+		if (currentTurn.userEntries.length === 0 && !lastAssistantEntry) return;
+		const assistantEntries = lastAssistantEntry ? [lastAssistantEntry] : [];
+		const allEntries = [...currentTurn.userEntries, ...assistantEntries];
+		turns.push({
+			userEntries: currentTurn.userEntries,
+			assistantEntries,
+			allEntries
+		});
+		currentTurn = { userEntries: [] };
+		lastAssistantEntry = null;
+	};
+	for (const entry of entries) {
+		if (!hasTextContent(entry)) continue;
+		if (entry.type === "user") {
+			if (lastAssistantEntry) pushTurn();
+			currentTurn.userEntries.push(entry);
+		} else lastAssistantEntry = entry;
+	}
+	pushTurn();
+	return turns;
+}
+function getTurnUserText(turn) {
+	const texts = [];
+	for (const entry of turn.userEntries) {
+		const text = getTextFromEntry(entry);
+		if (text) texts.push(text);
+	}
+	return texts.join(" ").toLowerCase();
+}
+function findSignalTurnIndices(turns, keywords) {
+	const signalIndices = [];
+	for (let i = 0; i < turns.length; i++) {
+		const userText = getTurnUserText(turns[i]);
+		for (const keyword of keywords) if (userText.includes(keyword)) {
+			signalIndices.push(i);
+			break;
+		}
+	}
+	return signalIndices;
+}
+function getTurnsAroundSignals(turns, signalIndices, turnCount) {
+	if (signalIndices.length === 0) return [];
+	const includeSet = /* @__PURE__ */ new Set();
+	for (const signalIdx of signalIndices) {
+		const startIdx = Math.max(0, signalIdx - (turnCount - 1));
+		for (let i = startIdx; i <= signalIdx; i++) includeSet.add(i);
+	}
+	return Array.from(includeSet).sort((a, b) => a - b).map((idx) => turns[idx]);
+}
+function formatEntryTextOnly(entry) {
+	const role = entry.type;
+	const parts = [];
+	for (const block of entry.content) {
+		if (block.type !== "text") continue;
+		const cleaned = cleanContent(block.text ?? "");
+		if (cleaned) parts.push(`<|start|>${role}<|message|>${cleaned}<|end|>`);
+	}
+	return parts.length > 0 ? parts.join("\n") : null;
+}
+function envelope(entries, format) {
+	const formattedParts = [`<|turn_start|>${entries[0]?.timestamp || (/* @__PURE__ */ new Date()).toISOString()}`];
+	for (const entry of entries) {
+		const formatted = format(entry);
+		if (formatted) formattedParts.push(formatted);
+	}
+	formattedParts.push("<|turn_end|>");
+	return formattedParts.join("\n\n");
+}
+function newEntries(session, sessionId) {
+	const lastSeq = getLastCapturedSeq(sessionId);
+	return entriesFromEvents(session.snapshotEvents(lastSeq === null ? void 0 : lastSeq + 1));
+}
+/** Signal-extraction mode: only the turns around keyword-bearing prompts. */
+function formatSignalEntries(session, sessionId, cwd) {
+	toolUseMap = /* @__PURE__ */ new Map();
+	currentIncludeList = getIncludeTools(cwd);
+	const { keywords, turnsBefore } = getSignalConfig(cwd);
+	const entries = newEntries(session, sessionId);
+	if (entries.length === 0) return null;
+	const turns = groupEntriesIntoSignalTurns(entries);
+	if (turns.length === 0) return null;
+	const signalIndices = findSignalTurnIndices(turns, keywords);
+	if (signalIndices.length === 0) return null;
+	const turnsToFormat = getTurnsAroundSignals(turns, signalIndices, turnsBefore);
+	if (turnsToFormat.length === 0) return null;
+	const allEntriesToFormat = turnsToFormat.flatMap((turn) => turn.allEntries);
+	if (allEntriesToFormat.length === 0) return null;
+	const result = envelope(allEntriesToFormat, formatEntryTextOnly);
+	if (result.length < 100) return null;
+	return {
+		formatted: result,
+		lastSeq: entries[entries.length - 1].seq
+	};
+}
+/** Default mode: every new user and assistant entry since the last capture. */
+function formatNewEntries(session, sessionId, cwd) {
+	toolUseMap = /* @__PURE__ */ new Map();
+	currentIncludeList = getIncludeTools(cwd);
+	const entries = newEntries(session, sessionId);
+	if (entries.length === 0) return null;
+	const result = envelope(entries, (entry) => formatEntry(entry) || null);
+	if (result.length < 100) return null;
+	return {
+		formatted: result,
+		lastSeq: entries[entries.length - 1].seq
+	};
+}
+//#endregion
+//#region src/capture.ts
+/**
+* `agent/turn-stopping` is serial and awaited, so the save completes before the
+* turn commits. Claude Code runs the same work in an async `Stop` hook; here it
+* is a first-class part of closing the turn.
+*/
+function registerCapture(ctx, rt, config) {
+	ctx.on("agent/turn-stopping", async ({ agent }) => {
+		if (isSubagent(agent) && !config.includeSubagents) return;
+		const settings = loadSettings();
+		const sessionId = sessionIdOf(agent);
+		try {
+			const cwd = cwdOf(agent);
+			const projectConfig = loadProjectConfig(cwd);
+			if (!sessionId) return;
+			let apiKey;
+			try {
+				apiKey = getApiKey(cwd, projectConfig);
+			} catch {
+				return;
+			}
+			const session = agent.session;
+			const delta = getSignalConfig(cwd).enabled ? formatSignalEntries(session, sessionId, cwd) : formatNewEntries(session, sessionId, cwd);
+			if (!delta) {
+				debugLog(settings, "No new content to save");
+				return;
+			}
+			const baseUrl = getBaseUrl(cwd, projectConfig);
+			const containerTag = getContainerTag(cwd);
+			const captured = readState(sessionId).capture?.count || 0;
+			writeState(sessionId, "capture", {
+				status: "saving",
+				count: captured
+			});
+			const result = await addMemory(baseUrl, apiKey, delta.formatted, containerTag, {
+				type: "session_turn",
+				project: getProjectName(cwd),
+				sm_project_id: getProjectIdentity(cwd),
+				sm_scope: "personal",
+				sm_capture_mode: "automatic",
+				timestamp: (/* @__PURE__ */ new Date()).toISOString()
+			}, {
+				customId: sessionId,
+				entityContext: AGENT_ENTITY_CONTEXT
+			});
+			setLastCapturedSeq(sessionId, delta.lastSeq);
+			writeState(sessionId, "capture", {
+				status: "saved",
+				count: captured + 1
+			});
+			if (result?.id) try {
+				saveLastSession({
+					id: result.id,
+					containerTag
+				});
+			} catch {}
+			debugLog(settings, "Session turn saved", { length: delta.formatted.length });
+		} catch (err) {
+			const friendly = getUserFriendlyError(err);
+			debugLog(settings, "Capture error", { error: friendly });
+			rt.warn(friendly);
+			writeState(sessionId, "capture", { status: "error" });
+		}
+	});
+}
+//#endregion
+//#region src/context-gatherer.ts
+const SKILL_NAME = "supermemory-context-gatherer";
+/**
+* The skill ships at the package root; the built bundle sits one level down
+* and the sources one as well, so both candidates are probed.
+*/
+function resolveSkillDir() {
+	const candidates = [`../skills/${SKILL_NAME}/`, `../../skills/${SKILL_NAME}/`].map((relative) => fileURLToPath(new URL(relative, import.meta.url)));
+	return candidates.find((dir) => fs.existsSync(path.join(dir, "SKILL.md"))) ?? candidates[0];
+}
+/** Strip the YAML frontmatter block a filesystem skill provider would parse. */
+function splitFrontmatter(source) {
+	const match = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/.exec(source);
+	if (!match) return {
+		data: {},
+		body: source.trim()
+	};
+	const data = {};
+	for (const line of (match[1] ?? "").split(/\r?\n/)) {
+		const separator = line.indexOf(":");
+		if (separator === -1) continue;
+		data[line.slice(0, separator).trim()] = line.slice(separator + 1).trim();
+	}
+	return {
+		data,
+		body: source.slice(match[0].length).trim()
+	};
+}
+/**
+* The Claude Code plugin ships this as a subagent definition under `agents/`.
+* DSH has no markdown agent loader, so the same instructions ship as a skill:
+* one file, discovered by name, invocable by the model or by the user.
+*/
+function registerContextGatherer(ctx, rt) {
+	const skillDir = resolveSkillDir();
+	const skillFile = path.join(skillDir, "SKILL.md");
+	let source;
+	try {
+		source = fs.readFileSync(skillFile, "utf-8");
+	} catch (err) {
+		rt.warn(`context-gatherer skill not registered — ${skillFile} is unreadable: ${err.message}`);
+		return;
+	}
+	const { data, body } = splitFrontmatter(source);
+	const description = data.description;
+	if (!description || !body) {
+		rt.warn(`context-gatherer skill not registered — ${skillFile} is missing a description or body`);
+		return;
+	}
+	ctx.inject(["skills"], (skillCtx) => {
+		skillCtx.skills.register({
+			name: SKILL_NAME,
+			description,
+			content: body,
+			source: "runtime",
+			path: skillFile,
+			resourceBase: {
+				kind: "directory",
+				path: skillDir
+			}
+		});
+	});
+}
+//#endregion
+//#region src/recall.ts
+const MIN_PROMPT_LENGTH = 12;
+const MAX_QUERY_LENGTH = 500;
+const MAX_RESULTS = 5;
+const MAX_RESULT_CHARS = 300;
+const MIN_SIMILARITY = .55;
+const SEARCH_TIMEOUT_MS = 3e3;
+function shouldSkip(prompt) {
+	if (prompt.length < MIN_PROMPT_LENGTH) return true;
+	return [
+		"/",
+		"!",
+		"#"
+	].includes(prompt[0] ?? "");
+}
+function resultText(r) {
+	return [
+		r?.memory,
+		r?.chunk,
+		r?.content,
+		r?.text
+	].find((v) => typeof v === "string" && v.trim().length > 0) || null;
+}
+function hashText(text) {
+	return crypto.createHash("sha256").update(text.replace(/\s+/g, " ").trim()).digest("hex").slice(0, 16);
+}
+function readSeenHashes(sessionDir) {
+	try {
+		const list = JSON.parse(fs.readFileSync(path.join(sessionDir, "recalled.json"), "utf8"));
+		return Array.isArray(list) ? list.filter((h) => typeof h === "string") : [];
+	} catch {
+		return [];
+	}
+}
+function formatRecall(results, containerTag) {
+	return `<supermemory-recall>
+◪ Recalled from supermemory for this prompt (relevance-ranked):
+${results.map((r) => {
+		const text = (resultText(r) ?? "").replace(/\s+/g, " ").slice(0, MAX_RESULT_CHARS);
+		const title = typeof r.title === "string" && r.title.trim() ? r.title.trim() : null;
+		return `- ◪ ${title && !text.startsWith(title) ? `${title} — ` : ""}${text}${typeof r.filepath === "string" && r.filepath ? ` (${r.filepath})` : ""}`;
+	}).join("\n")}
+
+When one of these shapes your answer, credit it naturally with the ◪ prefix (e.g. "◪ earlier you decided X"); if you name the source, say "from supermemory" — never "from memory". For deeper history, call the supermemory search_memory tool (containerTag: "${containerTag}") or launch the supermemory-context-gatherer skill.
+</supermemory-recall>`;
+}
+/** Memory is material lifted out of earlier sessions, which is exactly `form: 'recall'`. */
+function contextMessage(text) {
+	return createUserMessage({
+		content: [{
+			type: "text",
+			text
+		}],
+		source: {
+			...PLUGIN_SOURCE,
+			form: "recall"
+		}
+	});
+}
+/** Flatten the direct human prompt out of the messages claimed for this step. */
+function promptFrom(messages) {
+	return messages.filter((message) => message.source.kind === "user").flatMap((message) => message.content).filter((block) => block.type === "text").map((block) => block.text).join("").trim();
+}
+async function recallFor(rt, cwd, sessionId, prompt) {
+	const settings = loadSettings();
+	try {
+		const { directive } = getRecallConfig(cwd);
+		if (directive) return directive;
+		if (shouldSkip(prompt)) return null;
+		const projectConfig = loadProjectConfig(cwd);
+		let apiKey;
+		try {
+			apiKey = getApiKey(cwd, projectConfig);
+		} catch {
+			return null;
+		}
+		const containerTag = getContainerTag(cwd);
+		const results = ((await getProfile(getBaseUrl(cwd, projectConfig), apiKey, containerTag, prompt.slice(0, MAX_QUERY_LENGTH), { timeoutMs: SEARCH_TIMEOUT_MS }))?.searchResults?.results || []).filter((r) => resultText(r)).filter((r) => !Number.isFinite(r.similarity) || r.similarity >= MIN_SIMILARITY).slice(0, MAX_RESULTS);
+		const sessionDir = getSessionDir(sessionId);
+		const seen = sessionDir ? readSeenHashes(sessionDir) : [];
+		const seenSet = new Set(seen);
+		const fresh = results.filter((r) => !seenSet.has(hashText(resultText(r))));
+		const repeats = results.length - fresh.length;
+		if (sessionId) {
+			const prev = readState(sessionId).search;
+			writeState(sessionId, "search", {
+				results: fresh.length,
+				count: (prev?.count ?? 0) + 1,
+				memories: (prev?.memories ?? 0) + fresh.length
+			});
+		}
+		debugLog(settings, "Prompt recall", {
+			query: prompt.slice(0, 80),
+			hits: results.length,
+			fresh: fresh.length
+		});
+		if (fresh.length === 0) return null;
+		if (sessionDir) try {
+			atomicWriteJson(path.join(sessionDir, "recalled.json"), [...seen, ...fresh.map((r) => hashText(resultText(r)))].slice(-500));
+		} catch {}
+		const context = formatRecall(fresh, containerTag);
+		const tok = gray(`(${Math.round(context.length / 4)} tok)`);
+		rt.notify(repeats ? `recalled ${fresh.length} new ${tok}${gray(` · ${repeats} already in context`)}` : `recalled ${fresh.length} ${fresh.length === 1 ? "memory" : "memories"} ${tok}`);
+		return context;
+	} catch (err) {
+		debugLog(settings, "Recall directive error", { error: err.message });
+		rt.notify(red(`recall failed: ${getUserFriendlyError(err).slice(0, 80)}`));
+		return null;
+	}
+}
+/**
+* One `agent/pre-step` listener owns both injections. It delegates first so a
+* later listener may still reject or rewrite the step, then folds the session
+* bootstrap (once) and this prompt's recall onto the resulting `enter`.
+*/
+function registerRecall(ctx, rt, config) {
+	ctx.on("agent/pre-step", async ({ agent, messages }, next) => {
+		if (isSubagent(agent) && !config.includeSubagents) return next();
+		const sessionId = sessionIdOf(agent);
+		const cwd = cwdOf(agent);
+		const prompt = promptFrom(messages);
+		const pending = config.injectProfile !== false && !rt.delivered.has(sessionId) ? rt.bootstraps.get(sessionId) : void 0;
+		const bootstrapText = pending ? await pending : null;
+		const recallText = config.recall !== false && prompt.length > 0 ? await recallFor(rt, cwd, sessionId, prompt) : null;
+		const downstream = await next();
+		if (downstream.kind !== "enter") return downstream;
+		const additions = [];
+		if (bootstrapText) {
+			rt.delivered.add(sessionId);
+			additions.push(contextMessage(bootstrapText));
+		}
+		if (recallText) additions.push(contextMessage(recallText));
+		if (additions.length === 0) return downstream;
+		return {
+			...downstream,
+			messages: [...downstream.messages, ...additions]
+		};
+	});
+}
+//#endregion
+//#region src/session-start.ts
+const STATUSLINE_TIP_FILE = path.join(os.homedir(), ".supermemory-claude", "statusline-tip-shown");
+const MARK_TIP_FILE = path.join(os.homedir(), ".supermemory-claude", "mark-tip-shown");
+/**
+* DSH owns its status line, so there is nothing to install into a setting the
+* way the Claude Code plugin installs one. The per-session state files are
+* written all the same, and this one-time tip points at the renderer that
+* turns them into the identical line.
+*/
+function statuslineTip() {
+	try {
+		if (fs.existsSync(STATUSLINE_TIP_FILE)) return null;
+		fs.mkdirSync(path.dirname(STATUSLINE_TIP_FILE), { recursive: true });
+		fs.writeFileSync(STATUSLINE_TIP_FILE, (/* @__PURE__ */ new Date()).toISOString());
+		return `${MARK} supermemory status is live — render it anywhere with \`node -e "require('dsh-supermemory/statusline')" <<< '{"session_id":"…"}'\`, or read ~/.supermemory-claude/statusline.`;
+	} catch {
+		return null;
+	}
+}
+function markTip() {
+	try {
+		if (fs.existsSync(MARK_TIP_FILE)) return null;
+		fs.mkdirSync(path.dirname(MARK_TIP_FILE), { recursive: true });
+		fs.writeFileSync(MARK_TIP_FILE, (/* @__PURE__ */ new Date()).toISOString());
+		return `${MARK} is the supermemory mark — whenever you see it (status, notices, the assistant's answers), that information came from supermemory.`;
+	} catch {
+		return null;
+	}
+}
+function welcomeBackNotice(containerTag) {
+	try {
+		const last = JSON.parse(fs.readFileSync(LAST_SESSION_FILE, "utf-8"));
+		if (!last.savedAt || last.containerTag !== containerTag) return null;
+		const hours = (Date.now() - new Date(last.savedAt).getTime()) / 36e5;
+		if (hours < 6) return null;
+		return `welcome back — last session here ${hours < 48 ? `${Math.round(hours)}h ago` : `${Math.round(hours / 24)}d ago`}`;
+	} catch {
+		return null;
+	}
+}
+function formatContext(profileResult, maxItems, containerTag, projectName) {
+	const statics = (profileResult?.profile?.static || []).slice(0, maxItems);
+	const dynamics = (profileResult?.profile?.dynamic || []).slice(0, maxItems);
+	if (statics.length === 0 && dynamics.length === 0) return null;
+	const sections = [];
+	if (statics.length > 0) sections.push(`## User Profile (Persistent)\n${statics.map((f) => `- ◪ ${f}`).join("\n")}`);
+	if (dynamics.length > 0) sections.push(`## Recent Context\n${dynamics.map((f) => `- ◪ ${f}`).join("\n")}`);
+	return `<supermemory-context>
+Recalled memory for this project (${projectName}). Every line marked ◪ comes from supermemory — when citing one, keep the mark and phrase it naturally (e.g. "◪ last week you told me about X"). If you name the source, say "from supermemory" — never "from memory".
+This project's memory container: ${containerTag}
+
+${sections.join("\n\n")}
+</supermemory-context>`;
+}
+/**
+* Resolve the memory context for one session. Returns the exact text the
+* Claude Code plugin's SessionStart hook would have produced as
+* `additionalContext`, or null when there is nothing to say.
+*/
+async function bootstrap(rt, config, cwd, sessionId) {
+	const settings = loadSettings();
+	try {
+		pruneState({ dataDir: resolveStatuslineDataDir() });
+		writeState(sessionId, "context", {
+			status: "loading",
+			memoryItemsLoaded: 0
+		});
+		const projectConfig = loadProjectConfig(cwd);
+		const projectName = getProjectName(cwd);
+		const containerTag = getContainerTag(cwd);
+		debugLog(settings, "SessionStart", {
+			cwd,
+			projectName,
+			containerTag
+		});
+		let apiKey;
+		try {
+			apiKey = getApiKey(cwd, projectConfig);
+		} catch {
+			if (!config.browserLogin) {
+				writeState(sessionId, "context", {
+					status: "error",
+					memoryItemsLoaded: 0
+				});
+				return `<supermemory-status>
+Supermemory is not authenticated and browser login is disabled for this deployment.
+Set the SUPERMEMORY_CC_API_KEY environment variable, or authenticate at: ${AUTH_BASE_URL}
+</supermemory-status>`;
+			}
+			try {
+				apiKey = await startAuthFlow();
+			} catch (authErr) {
+				writeState(sessionId, "context", {
+					status: "error",
+					memoryItemsLoaded: 0
+				});
+				return `<supermemory-status>
+${authErr.message === "AUTH_TIMEOUT" ? "Authentication timed out. Please complete login in the browser window." : "Authentication failed."}
+If the browser did not open, visit: ${AUTH_BASE_URL}
+Or set the SUPERMEMORY_CC_API_KEY environment variable.
+</supermemory-status>`;
+			}
+		}
+		const baseUrl = getBaseUrl(cwd, projectConfig);
+		let profileResult = null;
+		let apiError = null;
+		try {
+			profileResult = await getProfile(baseUrl, apiKey, containerTag, projectName);
+		} catch (err) {
+			if (err?.status !== 404) apiError = getUserFriendlyError(err);
+			debugLog(settings, "Profile fetch failed", { error: err.message });
+		}
+		const context = formatContext(profileResult, settings.maxProfileItems, containerTag, projectName);
+		const loaded = Math.min(profileResult?.profile?.static?.length || 0, settings.maxProfileItems) + Math.min(profileResult?.profile?.dynamic?.length || 0, settings.maxProfileItems);
+		writeState(sessionId, "context", {
+			status: apiError ? "error" : "ready",
+			memoryItemsLoaded: loaded
+		});
+		const banner = [loaded > 0 ? `${loaded} ${loaded === 1 ? "memory" : "memories"} loaded for ${bold(projectName)}` : null, welcomeBackNotice(containerTag)].filter(Boolean).join(gray(" · "));
+		if (banner) rt.notify(banner);
+		for (const tip of [markTip(), statuslineTip()]) if (tip) rt.notify(tip);
+		return (apiError ? `<supermemory-status>\n${apiError}\n</supermemory-status>\n` : "") + (context || (apiError ? `<supermemory-context>
+Memory could not be loaded this session — do not assume this project has no memories.
+</supermemory-context>` : `<supermemory-context>
+No previous memories found for this project (container: ${containerTag}).
+Memories will be saved as you work.
+</supermemory-context>`));
+	} catch (err) {
+		const friendly = getUserFriendlyError(err);
+		rt.warn(friendly);
+		writeState(sessionId, "context", {
+			status: "error",
+			memoryItemsLoaded: 0
+		});
+		return `<supermemory-status>
+Failed to load memories: ${friendly}
+Session will continue without memory context.
+</supermemory-status>`;
+	}
+}
+function registerSessionStart(ctx, rt, config) {
+	ctx.on("agent/session-start", ({ agent }) => {
+		const sessionId = sessionIdOf(agent);
+		if (!sessionId || rt.bootstraps.has(sessionId)) return;
+		if (isSubagent(agent) && !config.includeSubagents) return;
+		rt.bootstraps.set(sessionId, bootstrap(rt, config, cwdOf(agent), sessionId).catch((err) => {
+			rt.warn(`session bootstrap failed: ${getUserFriendlyError(err)}`);
+			return null;
+		}));
+	});
+	ctx.on("agent/disposed", ({ agent }) => {
+		const sessionId = sessionIdOf(agent);
+		rt.bootstraps.delete(sessionId);
+		rt.delivered.delete(sessionId);
+	});
+}
+//#endregion
+//#region src/status.ts
+const PROBE_TIMEOUT_MS = 8e3;
+/** Never print a full key: at most the first 6 and last 4 characters. */
+function maskKey(key) {
+	if (key.length <= 10) return `${key.slice(0, 2)}…`;
+	return `${key.slice(0, 6)}…${key.slice(-4)}`;
+}
+function resolveKey(cwd) {
+	if (process.env.SUPERMEMORY_CC_API_KEY) return {
+		key: process.env.SUPERMEMORY_CC_API_KEY,
+		source: "env SUPERMEMORY_CC_API_KEY"
+	};
+	const projectConfig = loadProjectConfig(cwd);
+	if (projectConfig?.apiKey) return {
+		key: projectConfig.apiKey,
+		source: ".claude/.supermemory-claude/config.json"
+	};
+	const credentials = loadCredentials();
+	if (credentials?.apiKey) return {
+		key: credentials.apiKey,
+		source: CREDENTIALS_FILE
+	};
+	return null;
+}
+/**
+* A stored key proves nothing by itself, so the report always probes the API.
+* Interpret loudly: 401/403 is the silent-failure case the probe exists to
+* catch.
+*/
+async function probe(baseUrl, key, containerTag) {
+	try {
+		const response = await fetch(`${baseUrl.replace(/\/+$/, "")}/v4/profile`, {
+			method: "POST",
+			headers: {
+				Authorization: `Bearer ${key}`,
+				"Content-Type": "application/json",
+				"x-sm-source": "claude-code"
+			},
+			body: JSON.stringify({
+				containerTag,
+				q: "connectivity probe"
+			}),
+			signal: AbortSignal.timeout(PROBE_TIMEOUT_MS)
+		});
+		if (response.status === 200) return "reachable — 200, the key works";
+		if (response.status === 401 || response.status === 403) return `reachable, but the key is invalid or revoked — ${response.status}. Re-authenticate at ${AUTH_BASE_URL}`;
+		if (response.status >= 500) return `API error — ${response.status}, service temporarily unavailable`;
+		return `unexpected response — ${response.status}`;
+	} catch (err) {
+		const error = err;
+		return `UNREACHABLE — ${error.name === "TimeoutError" ? `timed out after ${PROBE_TIMEOUT_MS}ms` : error.message}`;
+	}
+}
+function registerStatusCommand(ctx, config) {
+	ctx.inject(["commands"], (commandCtx) => {
+		commandCtx.commands.register({
+			name: "supermemory-status",
+			description: "Show Supermemory authentication and connection status",
+			recordInput: false,
+			handler: async ({ agent }) => {
+				const cwd = cwdOf(agent);
+				const projectName = getProjectName(cwd);
+				const containerTag = getContainerTag(cwd);
+				const resolved = resolveKey(cwd);
+				const prefix = `mcp__${config.mcpServerName ?? "supermemory"}__`;
+				const mcpTools = (ctx.get("tools")?.schemas(agent.id) ?? []).map((schema) => schema.name).filter((name) => name.startsWith(prefix));
+				const lines = [
+					`${MARK} supermemory`,
+					"",
+					`project        ${projectName}`,
+					`container tag  ${containerTag}`,
+					`settings       ${SETTINGS_FILE}`
+				];
+				if (!resolved) {
+					lines.push("authenticated  NO", "", `Start a new session to open the browser login automatically, or set SUPERMEMORY_CC_API_KEY. Login page: ${AUTH_BASE_URL}`);
+					return {
+						kind: "success",
+						text: lines.join("\n")
+					};
+				}
+				const baseUrl = getBaseUrl(cwd);
+				lines.push("authenticated  yes", `key            ${maskKey(resolved.key)} (from ${resolved.source})`, `api            ${baseUrl}`, `api probe      ${await probe(baseUrl, resolved.key, containerTag)}`, `mcp            ${mcpTools.length > 0 ? `${mcpTools.length} tool${mcpTools.length === 1 ? "" : "s"} under ${prefix}` : `no ${prefix}* tools registered`}`);
+				return {
+					kind: "success",
+					text: lines.join("\n")
+				};
+			}
+		});
+	});
+}
+//#endregion
+//#region src/index.ts
+/**
+* Persistent memory across DeepSeek Harness sessions using Supermemory.
+*
+* A native port of the Claude Code `supermemory` plugin v0.1.6. The four
+* behaviors its `hooks.json` wires — session-start memory injection, per-prompt
+* recall, auto-approved read-only memory tools, and turn capture — are mapped
+* onto DSH's typed extension points instead of command hooks, and the hosted
+* MCP server is mounted through the same stdio proxy. Credentials, settings,
+* container tags, and the wire format are shared byte-for-byte with the Claude
+* Code plugin, so one login and one memory container serve both harnesses.
+*
+* @module dsh-supermemory
+*/
+const name = "supermemory";
+/** The bundled stdio bridge to the hosted Supermemory MCP server. */
+const MCP_PROXY = fileURLToPath(new URL("./mcp-proxy.mjs", import.meta.url));
+function apply(ctx, config) {
+	const rt = createRuntime(ctx);
+	if (config.injectProfile !== false) registerSessionStart(ctx, rt, config);
+	if (config.injectProfile !== false || config.recall !== false) registerRecall(ctx, rt, config);
+	if (config.autoApprove !== false) registerApprove(ctx, rt, config);
+	if (config.capture !== false) registerCapture(ctx, rt, config);
+	if (config.command !== false) registerStatusCommand(ctx, config);
+	if (config.contextGatherer !== false) registerContextGatherer(ctx, rt);
+	if (config.mcp !== false) ctx.plugin(McpClient, {
+		transport: "stdio",
+		serverName: config.mcpServerName ?? "supermemory",
+		command: process.execPath,
+		args: [MCP_PROXY],
+		env: {},
+		cwd: "",
+		toolCallTimeoutMs: 6e4,
+		failOnStartupError: false,
+		reconnect: {
+			enabled: true,
+			initialDelayMs: 500,
+			maxDelayMs: 3e4,
+			maxAttempts: 10
+		}
+	});
+}
+//#endregion
+export { PluginConfig as Config, PluginConfig, PLUGIN_SOURCE, apply, cleanContent, createRuntime, cwdOf, entriesFromEvents, findSignalTurnIndices, formatContext, formatEntry, formatNewEntries, formatRecall, formatSignalEntries, formatToolInputCompact, getLastCapturedSeq, getTextFromEntry, getTurnsAroundSignals, groupEntriesIntoTurns, hashText, isSubagent, maskKey, name, promptFrom, readOnlyToolOf, resolveSkillDir, resultText, sessionIdOf, setLastCapturedSeq, shouldSkip, splitFrontmatter, truncate };