relay-dsh-plugin-claude 0.1.2 → 0.1.4

package/lib/host-plugin.js

@@ -1,14 +1,14 @@
 import { fileURLToPath } from "node:url";
 import assert from "node:assert/strict";
 import { spawn } from "node:child_process";
-import { randomUUID } from "node:crypto";
+import { createHash, randomUUID, timingSafeEqual } from "node:crypto";
 import { EventEmitter } from "node:events";
 import readline from "node:readline";
 import { z } from "zod";
 import { homedir } from "node:os";
 import { basename, dirname, extname, isAbsolute, join, relative, resolve, sep } from "node:path";
-import { KNOWN_SESSION_EVENT_TYPES } from "@deepseek-ai/dsh-session";
-import { LlmAdapter } from "@deepseek-ai/dsh-llm";
+import { KNOWN_SESSION_EVENT_TYPES, SessionId } from "@deepseek-ai/dsh-session";
+import { CallId, LlmAdapter, MessageId, freezeMessage } from "@deepseek-ai/dsh-llm";
 import { cp, mkdir, open, realpath, stat } from "node:fs/promises";
 import sharp from "sharp";
 import { mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
@@ -326,6 +326,7 @@ var ClaudeCliClient = class extends EventEmitter {
 		return DEFAULT_MODELS$2;
 	}
 	async createSession(config = {}) {
+		assertSdkOnlyPluginsAbsent(config);
 		const id = config.sessionId ?? randomUUID();
 		const session = {
 			id,
@@ -341,6 +342,7 @@ var ClaudeCliClient = class extends EventEmitter {
 		};
 	}
 	async resumeSession(sessionId, config = {}) {
+		assertSdkOnlyPluginsAbsent(config);
 		const existing = this.sessions.get(sessionId) ?? {
 			id: sessionId,
 			created: true
@@ -361,6 +363,7 @@ var ClaudeCliClient = class extends EventEmitter {
 		};
 	}
 	async sendMessage(sessionId, message = {}) {
+		assertSdkOnlyPluginsAbsent(message);
 		if (message.content?.some((block) => block?.type === "image")) throw new Error("The Claude CLI backend cannot accept image input; use the Claude Agent SDK backend");
 		if (Array.isArray(message.dshTools) && message.dshTools.length > 0) throw new Error("The Claude CLI backend cannot expose DSH tools; use the Claude Agent SDK backend");
 		const session = this.sessions.get(sessionId) ?? await this.resumeSession(sessionId, message);
@@ -486,6 +489,10 @@ var ClaudeCliClient = class extends EventEmitter {
 		});
 	}
 };
+function assertSdkOnlyPluginsAbsent(config) {
+	if (Array.isArray(config.plugins) && config.plugins.length === 0) return;
+	if (config.plugins !== void 0) throw Object.assign(/* @__PURE__ */ new Error("Local Claude plugins require the Claude Agent SDK backend"), { code: "CLAUDE_LOCAL_PLUGINS_REQUIRE_SDK" });
+}
 function normalizeClaudeStreamMessage(message, state) {
 	const events = [];
 	const content = message.message?.content ?? message.content ?? [];
@@ -579,6 +586,30 @@ function systemPromptArguments(value) {
 	return [];
 }
 //#endregion
+//#region claude-plugin-config.mjs
+const CLAUDE_PLUGIN_KEYS = /* @__PURE__ */ new Set([
+	"type",
+	"path",
+	"skipMcpDiscovery"
+]);
+function normalizeClaudePlugins(value, label = "Claude plugins") {
+	if (value === void 0) return void 0;
+	if (!Array.isArray(value)) throw new TypeError(`${label} must be an array`);
+	return value.map((plugin, index) => {
+		const entryLabel = `${label}[${index}]`;
+		if (!plugin || typeof plugin !== "object" || Array.isArray(plugin)) throw new TypeError(`${entryLabel} must be an object`);
+		for (const key of Object.keys(plugin)) if (!CLAUDE_PLUGIN_KEYS.has(key)) throw new TypeError(`${entryLabel}.${key} is not supported`);
+		if (plugin.type !== "local") throw new TypeError(`${entryLabel}.type must be "local"`);
+		if (typeof plugin.path !== "string" || !plugin.path.trim()) throw new TypeError(`${entryLabel}.path must be a non-empty string`);
+		if (plugin.skipMcpDiscovery !== void 0 && typeof plugin.skipMcpDiscovery !== "boolean") throw new TypeError(`${entryLabel}.skipMcpDiscovery must be a boolean`);
+		return {
+			type: "local",
+			path: plugin.path,
+			...plugin.skipMcpDiscovery === void 0 ? {} : { skipMcpDiscovery: plugin.skipMcpDiscovery }
+		};
+	});
+}
+//#endregion
 //#region sdk-client.mjs
 const DEFAULT_MODELS$1 = [
 	{
@@ -606,6 +637,8 @@ const DEFAULT_MODELS$1 = [
 		inputModalities: ["text", "image"]
 	}
 ];
+const CLAUDE_SEARCH_TOOLS = ["Glob", "Grep"];
+const SENSITIVE_ENV_NAME = /(?:^|_)(?:API_?KEY|ACCESS_?KEY|SECRET(?:_ACCESS_?KEY)?|TOKEN|PASSWORD|PASSWD|CREDENTIALS?|PRIVATE_?KEY)(?:$|_)/i;
 function reasoningEfforts() {
 	return [
 		"low",
@@ -632,7 +665,29 @@ var ClaudeSdkClient = class extends EventEmitter {
 	async listModels() {
 		return DEFAULT_MODELS$1;
 	}
+	supportsSessionImport() {
+		return typeof this.sdk?.listSessions === "function" && typeof this.sdk?.getSessionInfo === "function" && typeof this.sdk?.getSessionMessages === "function";
+	}
+	async listWorkspaceSessions({ cwd }) {
+		if (!this.supportsSessionImport()) throw sessionImportUnavailable$1();
+		return this.sdk.listSessions({
+			dir: cwd,
+			includeWorktrees: false,
+			includeProgrammatic: false
+		});
+	}
+	async readSession(sessionId, { cwd }) {
+		if (!this.supportsSessionImport()) throw sessionImportUnavailable$1();
+		const info = await this.sdk.getSessionInfo(sessionId, { dir: cwd });
+		if (!info) return null;
+		const messages = await this.sdk.getSessionMessages(sessionId, { dir: cwd });
+		return {
+			...info,
+			messages
+		};
+	}
 	async createSession(config = {}) {
+		config = normalizedSessionConfig(config);
 		const id = config.sessionId ?? randomUUID();
 		this.sessions.set(id, {
 			id,
@@ -647,6 +702,7 @@ var ClaudeSdkClient = class extends EventEmitter {
 		};
 	}
 	async resumeSession(sessionId, config = {}) {
+		config = normalizedSessionConfig(config);
 		const existing = this.sessions.get(sessionId) ?? {
 			id: sessionId,
 			created: true,
@@ -667,10 +723,11 @@ var ClaudeSdkClient = class extends EventEmitter {
 		};
 	}
 	async sendMessage(sessionId, message = {}) {
+		if (message.plugins !== void 0) throw new TypeError("Claude plugins must be configured when the Session is created or resumed");
 		const session = this.sessions.get(sessionId) ?? await this.resumeSession(sessionId, message);
 		const turnId = randomUUID();
 		const abortController = new AbortController();
-		const options = this.queryOptions(session, message, abortController);
+		const options = await this.queryOptions(session, message, abortController);
 		const query = this.sdk.query({
 			prompt: claudePrompt(message),
 			options
@@ -734,10 +791,19 @@ var ClaudeSdkClient = class extends EventEmitter {
 			message: error?.message ?? String(error)
 		});
 	}
-	queryOptions(session, message, abortController) {
+	async queryOptions(session, message, abortController) {
+		const plugins = normalizeClaudePlugins(session.config?.plugins);
+		const cwd = message.cwd ?? session.cwd ?? process.cwd();
+		const settingSources = message.settingSources ?? session.config?.settingSources ?? [
+			"user",
+			"project",
+			"local"
+		];
+		const dshOptions = dshMcpOptions(this.sdk, message.dshTools, message.executeDshTool, abortController.signal);
+		const redactions = await sensitiveEnvironmentRedactions(this.sdk, cwd, settingSources);
 		return {
 			abortController,
-			cwd: message.cwd ?? session.cwd ?? process.cwd(),
+			cwd,
 			model: message.model ?? session.config?.model,
 			effort: message.effort ?? session.config?.effort,
 			thinking: {
@@ -745,17 +811,16 @@ var ClaudeSdkClient = class extends EventEmitter {
 				display: "summarized"
 			},
 			permissionMode: sdkPermissionMode(message),
-			settingSources: message.settingSources ?? session.config?.settingSources ?? [
-				"user",
-				"project",
-				"local"
-			],
+			settingSources,
 			systemPrompt: message.systemPrompt ?? session.config?.systemPrompt,
 			pathToClaudeCodeExecutable: this.pathToClaudeCodeExecutable,
 			includePartialMessages: true,
+			...plugins === void 0 ? {} : { plugins },
 			...session.created ? { resume: session.id } : { sessionId: session.id },
 			canUseTool: (toolName, input, options) => this.requestPermission(session.id, toolName, input, options),
-			...dshMcpOptions(this.sdk, message.dshTools, message.executeDshTool, abortController.signal)
+			...redactions.length === 0 ? {} : { hooks: sensitiveOutputHooks(redactions) },
+			...dshOptions,
+			allowedTools: [...CLAUDE_SEARCH_TOOLS, ...dshOptions.allowedTools ?? []]
 		};
 	}
 	requestPermission(sessionId, toolName, input, options = {}) {
@@ -831,6 +896,87 @@ var ClaudeSdkClient = class extends EventEmitter {
 		});
 	}
 };
+async function sensitiveEnvironmentRedactions(sdk, cwd, settingSources) {
+	const environment = { ...process.env };
+	const explicitSensitiveNames = /* @__PURE__ */ new Set();
+	if (typeof sdk.resolveSettings === "function") {
+		const resolved = await sdk.resolveSettings({
+			cwd,
+			settingSources
+		});
+		Object.assign(environment, resolved?.effective?.env ?? {});
+		for (const entry of resolved?.effective?.sandbox?.credentials?.envVars ?? []) if (typeof entry?.name === "string") explicitSensitiveNames.add(entry.name);
+	}
+	const byValue = /* @__PURE__ */ new Map();
+	for (const [name, value] of Object.entries(environment)) {
+		if (!SENSITIVE_ENV_NAME.test(name) && !explicitSensitiveNames.has(name)) continue;
+		if (typeof value !== "string" || value.length === 0) continue;
+		const current = byValue.get(value);
+		if (current === void 0 || name < current) byValue.set(value, name);
+	}
+	return [...byValue].map(([value, name]) => ({
+		value,
+		replacement: `[REDACTED_ENV:${name}]`
+	})).sort((left, right) => right.value.length - left.value.length || left.replacement.localeCompare(right.replacement));
+}
+function sensitiveOutputHooks(redactions) {
+	return { PostToolUse: [{ hooks: [async (input) => {
+		const redacted = redactSensitiveToolOutput(input.tool_response, redactions);
+		if (!redacted.changed) return { continue: true };
+		return {
+			continue: true,
+			hookSpecificOutput: {
+				hookEventName: "PostToolUse",
+				updatedToolOutput: redacted.value
+			}
+		};
+	}] }] };
+}
+function redactSensitiveToolOutput(value, redactions) {
+	if (typeof value === "string") {
+		let redacted = value;
+		for (const entry of redactions) redacted = redacted.replaceAll(entry.value, entry.replacement);
+		return {
+			value: redacted,
+			changed: redacted !== value
+		};
+	}
+	if (Array.isArray(value)) {
+		let changed = false;
+		const redacted = value.map((item) => {
+			const result = redactSensitiveToolOutput(item, redactions);
+			changed ||= result.changed;
+			return result.value;
+		});
+		return {
+			value: changed ? redacted : value,
+			changed
+		};
+	}
+	if (!value || typeof value !== "object") return {
+		value,
+		changed: false
+	};
+	let changed = false;
+	const entries = Object.entries(value).map(([key, item]) => {
+		const result = redactSensitiveToolOutput(item, redactions);
+		changed ||= result.changed;
+		return [key, result.value];
+	});
+	return {
+		value: changed ? Object.fromEntries(entries) : value,
+		changed
+	};
+}
+function normalizedSessionConfig(config) {
+	const plugins = normalizeClaudePlugins(config.plugins);
+	const normalized = {
+		...config,
+		...plugins === void 0 ? {} : { plugins }
+	};
+	if (plugins === void 0) delete normalized.plugins;
+	return normalized;
+}
 function claudePrompt(message) {
 	const content = Array.isArray(message.content) ? message.content : [];
 	if (!content.some((block) => block?.type === "image")) return message.text;
@@ -1109,6 +1255,9 @@ function resultError(message) {
 	if (!message?.is_error) return null;
 	return new Error(message.errors?.join("\n") || message.subtype || "Claude SDK turn failed");
 }
+function sessionImportUnavailable$1() {
+	return Object.assign(/* @__PURE__ */ new Error("The active Claude Agent SDK does not support native Session discovery and history import"), { code: "CLAUDE_SESSION_IMPORT_UNAVAILABLE" });
+}
 function sdkPermissionMode(message) {
 	if (message.permissionMode) return message.permissionMode;
 	if (message.approvalPolicy === "never") return "dontAsk";
@@ -1148,10 +1297,11 @@ const DEFAULT_MODELS = [
 	}
 ];
 var ClaudeSessionRuntime = class extends EventEmitter {
-	constructor({ client = new ClaudeCliClient(), cwd = process.cwd() } = {}) {
+	constructor({ client = new ClaudeCliClient(), cwd = process.cwd(), plugins = void 0 } = {}) {
 		super();
 		this.client = client;
 		this.cwd = cwd;
+		this.plugins = normalizeClaudePlugins(plugins);
 		this.sessions = /* @__PURE__ */ new Map();
 		this.models = DEFAULT_MODELS;
 		this.selectedSessionId = null;
@@ -1182,9 +1332,10 @@ var ClaudeSessionRuntime = class extends EventEmitter {
 	], systemPrompt = {
 		type: "preset",
 		preset: "claude_code"
-	} } = {}) {
+	}, plugins = this.plugins } = {}) {
 		const selectedModel = model ?? this.models.find((candidate) => candidate.isDefault)?.id ?? "sonnet";
 		const selectedEffort = effort ?? this.models.find((candidate) => candidate.id === selectedModel)?.defaultReasoningEffort ?? "medium";
+		const normalizedPlugins = normalizeClaudePlugins(plugins);
 		const created = await this.client.createSession?.({
 			model: selectedModel,
 			effort: selectedEffort,
@@ -1193,7 +1344,8 @@ var ClaudeSessionRuntime = class extends EventEmitter {
 			cwd,
 			ephemeral,
 			settingSources,
-			systemPrompt
+			systemPrompt,
+			...normalizedPlugins === void 0 ? {} : { plugins: normalizedPlugins }
 		});
 		const session = this.upsertSession(created ?? {}, {
 			id: created?.id,
@@ -1202,21 +1354,38 @@ var ClaudeSessionRuntime = class extends EventEmitter {
 			sandbox,
 			approvalPolicy,
 			cwd,
-			ephemeral
+			ephemeral,
+			plugins: normalizedPlugins
 		});
 		if (!session.ephemeral) this.selectedSessionId = session.id;
 		this.emitChange();
 		return publicSession(session);
 	}
+	supportsSessionImport() {
+		return this.client.supportsSessionImport?.() === true;
+	}
+	async listWorkspaceSessions({ cwd }) {
+		if (!this.supportsSessionImport() || typeof this.client.listWorkspaceSessions !== "function") throw sessionImportUnavailable();
+		return structuredClone(await this.client.listWorkspaceSessions({ cwd }));
+	}
+	async readSession(sessionId, { cwd }) {
+		if (!this.supportsSessionImport() || typeof this.client.readSession !== "function") throw sessionImportUnavailable();
+		const source = await this.client.readSession(sessionId, { cwd });
+		return source === null ? null : structuredClone(source);
+	}
 	async resumeSession(sessionId, defaults = {}) {
 		if (!sessionId?.trim()) throw new Error("sessionId is required");
-		const resumed = await this.client.resumeSession?.(sessionId, {
+		const normalizedPlugins = normalizeClaudePlugins(defaults.plugins === void 0 ? this.plugins : defaults.plugins);
+		const resumeConfig = {
 			cwd: defaults.cwd ?? this.cwd,
-			...defaults
-		});
+			...defaults,
+			...normalizedPlugins === void 0 ? {} : { plugins: normalizedPlugins }
+		};
+		if (normalizedPlugins === void 0) delete resumeConfig.plugins;
+		const resumed = await this.client.resumeSession?.(sessionId, resumeConfig);
 		const session = this.upsertSession(resumed ?? {}, {
 			id: sessionId,
-			...defaults
+			...resumeConfig
 		});
 		if (Array.isArray(resumed?.turns) && resumed.turns.length > 0) session.turns = structuredClone(resumed.turns);
 		if (!session.ephemeral) this.selectedSessionId = sessionId;
@@ -1228,6 +1397,7 @@ var ClaudeSessionRuntime = class extends EventEmitter {
 		const session = this.requireSession(sessionId);
 		const hasContent = Array.isArray(content) && content.some((block) => block?.type === "image" || block?.type === "text" && String(block.text ?? "").trim());
 		if (!text?.trim() && !hasContent) throw new Error("message content is required");
+		if (message.plugins !== void 0) throw new TypeError("Claude plugins must be configured when the Session is created or resumed");
 		const next = {
 			model: model ?? session.model,
 			effort: effort ?? session.effort,
@@ -1310,6 +1480,7 @@ var ClaudeSessionRuntime = class extends EventEmitter {
 			approvalPolicy: defaults.approvalPolicy ?? input.approvalPolicy ?? existing.approvalPolicy ?? "on-request",
 			cwd: defaults.cwd ?? input.cwd ?? existing.cwd ?? this.cwd,
 			ephemeral: Boolean(defaults.ephemeral ?? input.ephemeral ?? existing.ephemeral),
+			plugins: defaults.plugins ?? input.plugins ?? existing.plugins,
 			updatedAt: input.updatedAt ?? nowSeconds()
 		});
 		if (Array.isArray(input.turns) && input.turns.length > 0) existing.turns = structuredClone(input.turns);
@@ -1353,6 +1524,9 @@ function publicSession(session) {
 function nowSeconds() {
 	return Date.now() / 1e3;
 }
+function sessionImportUnavailable() {
+	return Object.assign(/* @__PURE__ */ new Error("Native Claude Session import requires the Claude Agent SDK backend"), { code: "CLAUDE_SESSION_IMPORT_UNAVAILABLE" });
+}
 //#endregion
 //#region plugin.mjs
 const CLAUDE_EXECUTION_CAPABILITY = "relay.execution.claude.v1";
@@ -1369,7 +1543,8 @@ function createClaudeExecutionPlugin(config = {}) {
 			const logger = capabilities.optional("relay.logging.v1") ?? console;
 			const runtime = new ClaudeSessionRuntime({
 				client: config.client ?? createClaudeClient(config),
-				cwd: config.cwd ?? process.cwd()
+				cwd: config.cwd ?? process.cwd(),
+				plugins: config.plugins
 			});
 			defer(() => runtime.close());
 			const ready = runtime.initialize();
@@ -1384,6 +1559,9 @@ function executionCapability(runtime, ready) {
 	return Object.freeze({
 		whenReady: () => ready,
 		listModels: () => structuredClone(runtime.models),
+		supportsSessionImport: () => runtime.supportsSessionImport(),
+		listWorkspaceSessions: runtime.listWorkspaceSessions.bind(runtime),
+		readSession: runtime.readSession.bind(runtime),
 		hasSession: (sessionId) => runtime.sessions.has(sessionId),
 		getSession: runtime.getSession.bind(runtime),
 		patchSession(sessionId, patch) {
@@ -1451,6 +1629,15 @@ var FallbackClaudeClient = class extends ClaudeCliClient {
 	listModels(...args) {
 		return this.active.listModels(...args);
 	}
+	supportsSessionImport(...args) {
+		return this.active.supportsSessionImport?.(...args) === true;
+	}
+	listWorkspaceSessions(...args) {
+		return this.active.listWorkspaceSessions?.(...args);
+	}
+	readSession(...args) {
+		return this.active.readSession?.(...args);
+	}
 	createSession(...args) {
 		return this.active.createSession(...args);
 	}
@@ -1498,6 +1685,15 @@ const MEDIA_TYPES = /* @__PURE__ */ new Map([
 	[".webp", "image/webp"]
 ]);
 const IMAGE_SUFFIX = String.raw`\.(?:png|jpe?g|webp|gif|bmp|svg|tiff?|avif|heic)`;
+const IMAGE_PATH_END = new RegExp(`${IMAGE_SUFFIX}$`, "i");
+const BARE_PATH_BOUNDARY = String.raw`[\s(\[{:*=~（【《「『“‘，。；：！？、]`;
+const BARE_PATH_END_CHAR = String.raw`[\s)\]}>,;:!?*~，。；：！？、）】》」』”’]`;
+const BARE_PATH_END = String.raw`(?:${BARE_PATH_END_CHAR}|\.(?=$|${BARE_PATH_END_CHAR}))`;
+const BARE_PATH_CONTENT = String.raw`[^\s<>"'“”‘’「」『』*~()\[\]{}=:,;!?，。；：！？、（）【】《》]+?`;
+const MARKDOWN_PATH = new RegExp(String.raw`!?\[[^\]\r\n]*\]\(\s*(?:<([^>]+)>|([^\s)]+))(?:\s+["'][^"']*["'])?\s*\)`, "gi");
+const INLINE_CODE_PATH = new RegExp("`([^`\\r\\n]+" + IMAGE_SUFFIX + ")`", "gi");
+const QUOTED_PATH = new RegExp("[\"']([^\"'\\r\\n]+" + IMAGE_SUFFIX + ")[\"']", "gi");
+const URI_REFERENCE = /(?!(?:[a-z]:[\\/]))(?:[a-z][a-z0-9+.-]*:\/\/|data:|file:|blob:|mailto:|\/\/)[^\s<>"'“”‘’]+/gi;
 const SVG_EXTENSION = ".svg";
 const SVG_SOURCE_MAX_BYTES = 2 * 1024 * 1024;
 const SVG_RASTER_DENSITY = 72;
@@ -1507,15 +1703,15 @@ const DEFAULT_MAX_IMAGE_DIMENSION = 8192;
 function extractFinalAnswerImagePaths(text) {
 	const visible = withoutFencedCode(String(text ?? ""));
 	const matches = [];
-	collectMatches(matches, visible, new RegExp(String.raw`!?\[[^\]\r\n]*\]\(\s*(?:<([^>]+)>|([^\s)]+))(?:\s+["'][^"']*["'])?\s*\)`, "gi"), 1, 2);
-	collectMatches(matches, visible, new RegExp("`([^`\\r\\n]+" + IMAGE_SUFFIX + ")`", "gi"), 1);
-	collectMatches(matches, visible, new RegExp("[\"']([^\"'\\r\\n]+" + IMAGE_SUFFIX + ")[\"']", "gi"), 1);
-	collectMatches(matches, visible, new RegExp("(?:^|[\\s(\\[])((?:\\.{0,2}/|/)[^\\s<>\"'`]+?" + IMAGE_SUFFIX + ")(?=$|[\\s)\\],.;:!?])", "gi"), 1);
+	collectMatches(matches, visible, MARKDOWN_PATH, 1, 2);
+	collectMatches(matches, visible, INLINE_CODE_PATH, 1);
+	collectMatches(matches, visible, QUOTED_PATH, 1);
+	collectMatches(matches, maskMatches(visible, MARKDOWN_PATH, INLINE_CODE_PATH, QUOTED_PATH, URI_REFERENCE), new RegExp(String.raw`(?:^|${BARE_PATH_BOUNDARY})((?:[a-z]:[\\/])?${BARE_PATH_CONTENT}${IMAGE_SUFFIX})(?=$|${BARE_PATH_END})`, "gi"), 1);
 	matches.sort((left, right) => left.index - right.index);
 	const seen = /* @__PURE__ */ new Set();
 	return matches.flatMap(({ path }) => {
 		const normalized = normalizeMention(path);
-		if (!normalized || isRemoteReference(normalized) || seen.has(normalized)) return [];
+		if (!normalized || !IMAGE_PATH_END.test(normalized) || isRemoteReference(normalized) || seen.has(normalized)) return [];
 		seen.add(normalized);
 		return [normalized];
 	});
@@ -1707,11 +1903,15 @@ function collectMatches(matches, text, expression, ...groups) {
 function withoutFencedCode(text) {
 	return text.replace(/(^|\n)[ \t]*(```|~~~)[^\n]*\n[\s\S]*?(?:\n[ \t]*\2(?=\n|$)|$)/g, (match) => match.replace(/[^\n]/g, " "));
 }
+function maskMatches(text, ...expressions) {
+	return expressions.reduce((masked, expression) => masked.replace(expression, (match) => match.replace(/[^\n]/g, " ")), text);
+}
 function normalizeMention(path) {
 	return String(path ?? "").trim().replace(/^<|>$/g, "");
 }
 function isRemoteReference(path) {
-	return /^(?:https?:|data:|file:)/i.test(path);
+	if (/^[a-z]:[\\/]/i.test(path)) return false;
+	return /^(?:[a-z][a-z0-9+.-]*:|\/\/)/i.test(path);
 }
 function deduplicateAttachments(images) {
 	const seen = /* @__PURE__ */ new Set();
@@ -1786,6 +1986,13 @@ function outputImageError(message, code) {
 const CLAUDE_PRESET = "relay-claude";
 const CLAUDE_PROVIDER = "relay-claude";
 const CLAUDE_ACTIVITY_EVENT = "relay-claude/activity";
+const IMPORT_STATES = Object.freeze([
+	"reserved",
+	"session-created",
+	"hydrated",
+	"attached",
+	"committed"
+]);
 var ClaudeDshAdapter = class extends LlmAdapter {
 	constructor({ runtime, ready, linkStore = null, attachments = null, logger = console }) {
 		super();
@@ -1796,12 +2003,16 @@ var ClaudeDshAdapter = class extends LlmAdapter {
 		this.attachments = attachments;
 		this.links = /* @__PURE__ */ new Map();
 		this.settings = /* @__PURE__ */ new Map();
+		this.bindingModes = /* @__PURE__ */ new Map();
+		this.importStates = /* @__PURE__ */ new Map();
 		this.pendingSessions = /* @__PURE__ */ new Map();
 		this.agents = /* @__PURE__ */ new Map();
 		for (const [sessionId, record] of linkStore?.entries() ?? []) {
 			const claudeSessionId = record.claudeSessionId ?? record.sessionId ?? record.threadId;
 			if (claudeSessionId) this.links.set(sessionId, claudeSessionId);
 			this.settings.set(sessionId, record.config);
+			this.bindingModes.set(sessionId, record.bindingMode === "imported" ? "imported" : "native");
+			if (record.bindingMode === "imported" && IMPORT_STATES.includes(record.importState)) this.importStates.set(sessionId, record.importState);
 		}
 	}
 	providerInfo() {
@@ -1905,18 +2116,25 @@ var ClaudeDshAdapter = class extends LlmAdapter {
 			await this.runtime.resumeSession(linked, settings);
 			return linked;
 		} catch (error) {
+			if (this.bindingModes.get(sessionId) === "imported") throw Object.assign(new Error(`Relay could not resume imported Claude Session ${linked}`, { cause: error }), {
+				code: "CLAUDE_IMPORTED_SESSION_RESUME_FAILED",
+				claudeSessionId: linked
+			});
 			this.logger.warn(`Relay could not resume Claude session ${linked}; creating a replacement: ${error.message}`);
 			this.links.delete(sessionId);
 		}
 		const created = await this.runtime.createSession(settings);
 		this.links.set(sessionId, created.id);
+		this.bindingModes.set(sessionId, "native");
 		this.persistLink(sessionId);
 		return created.id;
 	}
 	persistLink(sessionId) {
 		this.linkStore?.set(sessionId, {
 			claudeSessionId: this.links.get(sessionId) ?? null,
-			config: this.configuration(sessionId)
+			config: this.configuration(sessionId),
+			bindingMode: this.bindingModes.get(sessionId) ?? "native",
+			...this.importStates.has(sessionId) ? { importState: this.importStates.get(sessionId) } : {}
 		});
 	}
 	sessionFor(sessionId) {
@@ -1926,6 +2144,47 @@ var ClaudeDshAdapter = class extends LlmAdapter {
 		for (const [sessionId, candidate] of this.links) if (candidate === claudeSessionId) return sessionId;
 		return null;
 	}
+	bindingForClaudeSession(claudeSessionId) {
+		const sessionId = this.dshSessionForClaudeSession(claudeSessionId);
+		if (!sessionId) return null;
+		return {
+			sessionId,
+			claudeSessionId,
+			config: structuredClone(this.configuration(sessionId)),
+			bindingMode: this.bindingModes.get(sessionId) ?? "native",
+			importState: this.importStates.get(sessionId) ?? null
+		};
+	}
+	bindImportedSession(sessionId, claudeSessionId, config = {}) {
+		const key = String(sessionId).trim();
+		const source = String(claudeSessionId).trim();
+		if (!key) throw new Error("DSH sessionId is required for an imported Claude binding");
+		if (!source) throw new Error("Claude sessionId is required for an imported binding");
+		const owner = this.dshSessionForClaudeSession(source);
+		if (owner && owner !== key) throw new Error(`Claude Session ${source} is already bound to DSH session ${owner}`);
+		const current = this.links.get(key);
+		if (current && current !== source) throw new Error(`DSH session ${key} is already bound to Claude Session ${current}`);
+		this.links.set(key, source);
+		this.settings.set(key, {
+			...this.configuration(key, config.cwd),
+			...compact(config)
+		});
+		this.bindingModes.set(key, "imported");
+		if (!this.importStates.has(key)) this.importStates.set(key, "reserved");
+		this.persistLink(key);
+		return this.bindingForClaudeSession(source);
+	}
+	markImportState(sessionId, state) {
+		const key = String(sessionId);
+		if (this.bindingModes.get(key) !== "imported") throw new Error(`DSH session ${key} is not an imported Claude binding`);
+		const next = IMPORT_STATES.indexOf(state);
+		if (next === -1) throw new Error(`unknown Claude import state ${state}`);
+		if (next > IMPORT_STATES.indexOf(this.importStates.get(key) ?? "reserved")) {
+			this.importStates.set(key, state);
+			this.persistLink(key);
+		}
+		return this.bindingForClaudeSession(this.links.get(key));
+	}
 	async *stream(options) {
 		if (options.purpose) {
 			yield* this.streamAuxiliary(options);
@@ -2074,7 +2333,8 @@ var ClaudeDshAdapter = class extends LlmAdapter {
 			cwd,
 			ephemeral: true,
 			settingSources: ["user"],
-			systemPrompt: options.system
+			systemPrompt: options.system,
+			plugins: []
 		})).id;
 		const queue = new ActivityQueue(options.signal, "Claude");
 		const onActivity = (message) => {
@@ -2519,6 +2779,370 @@ function effectivePreset(session) {
 	return session.header.agentPreset;
 }
 //#endregion
+//#region claude-import.mjs
+const IMPORT_STATE_ORDER = Object.freeze([
+	"reserved",
+	"session-created",
+	"hydrated",
+	"attached",
+	"committed"
+]);
+var ClaudeWorkspaceImporter = class {
+	constructor({ runtime, adapter, target, logger = console }) {
+		if (!runtime?.listWorkspaceSessions) throw new Error("Claude import requires Workspace Session inventory");
+		if (!adapter?.bindImportedSession) throw new Error("Claude import requires a DSH binding adapter");
+		if (![
+			"prepare",
+			"hydrate",
+			"attach",
+			"finalize"
+		].every((method) => typeof target?.[method] === "function")) throw new Error("Claude import requires a complete DSH Session target");
+		this.runtime = runtime;
+		this.adapter = adapter;
+		this.target = target;
+		this.logger = logger;
+		this.pendingSessions = /* @__PURE__ */ new Map();
+	}
+	async scanWorkspace(cwd) {
+		const canonicalCwd = await canonicalPath(cwd);
+		const discovered = await this.runtime.listWorkspaceSessions({ cwd: canonicalCwd });
+		const sessions = [];
+		for (const session of discovered) {
+			if (!session || typeof session.sessionId !== "string" || typeof session.cwd !== "string" || !session.cwd.trim()) continue;
+			const sessionCwd = await canonicalPath(session.cwd);
+			if (sessionCwd !== canonicalCwd) continue;
+			sessions.push({
+				...session,
+				cwd: sessionCwd
+			});
+		}
+		sessions.sort(compareInventorySessions);
+		const entries = sessions.map((session) => {
+			const binding = this.adapter.bindingForClaudeSession(session.sessionId);
+			if (!binding) return {
+				session,
+				binding: null,
+				status: "ready"
+			};
+			if (binding.bindingMode === "imported" && binding.importState !== "committed") return {
+				session,
+				binding,
+				status: "recoverable"
+			};
+			return {
+				session,
+				binding,
+				status: "existing"
+			};
+		});
+		const existing = entries.filter((entry) => entry.status === "existing").length;
+		const recoverable = entries.filter((entry) => entry.status === "recoverable").length;
+		return {
+			cwd: canonicalCwd,
+			entries,
+			summary: {
+				found: entries.length,
+				existing,
+				recoverable,
+				ready: entries.length - existing
+			}
+		};
+	}
+	async importWorkspace(cwd, { sessionIds, onProgress } = {}) {
+		const inventory = await this.scanWorkspace(cwd);
+		const entries = selectedImportEntries(inventory.entries, sessionIds);
+		const result = {
+			found: sessionIds === void 0 ? inventory.summary.found : entries.length,
+			imported: 0,
+			existing: 0,
+			failed: 0,
+			failures: []
+		};
+		let completed = 0;
+		for (const entry of entries) {
+			if (entry.status === "existing") result.existing += 1;
+			else try {
+				await this.importSession(entry.session, cwd, entry.binding);
+				result.imported += 1;
+			} catch (error) {
+				result.failed += 1;
+				const session = shortSessionId(entry.session.sessionId);
+				const message = publicErrorMessage(error, entry.session.sessionId, session);
+				result.failures.push({
+					session,
+					message
+				});
+				this.logger.warn?.(`Claude import failed for ${session}: ${message}`);
+			}
+			completed += 1;
+			onProgress?.({
+				completed,
+				total: entries.length,
+				...result
+			});
+		}
+		return result;
+	}
+	async importSession(session, workspaceCwd, existingBinding = null) {
+		const pending = this.pendingSessions.get(session.sessionId);
+		if (pending) return pending;
+		const operation = this.runImportSession(session, workspaceCwd, existingBinding).finally(() => {
+			this.pendingSessions.delete(session.sessionId);
+		});
+		this.pendingSessions.set(session.sessionId, operation);
+		return operation;
+	}
+	async runImportSession(session, workspaceCwd, existingBinding = null) {
+		const source = await this.runtime.readSession(session.sessionId, { cwd: workspaceCwd });
+		if (!source || source.sessionId !== session.sessionId) throw new Error(`Claude Session ${shortSessionId(session.sessionId)} is no longer available in this Workspace`);
+		if (await canonicalPath(source.cwd) !== await canonicalPath(workspaceCwd)) throw new Error(`Claude Session ${shortSessionId(session.sessionId)} no longer belongs to this Workspace`);
+		let binding = existingBinding;
+		if (!binding) {
+			const sessionId = importedDshSessionId(session.sessionId);
+			binding = this.adapter.bindImportedSession(sessionId, session.sessionId, {
+				...this.adapter.configuration(sessionId, session.cwd),
+				cwd: session.cwd
+			});
+		}
+		if (binding.bindingMode !== "imported") return binding.sessionId;
+		if (binding.importState === "committed") return binding.sessionId;
+		let transaction = null;
+		try {
+			transaction = await this.target.prepare({
+				session,
+				source,
+				binding,
+				workspaceCwd
+			});
+			binding = this.adapter.markImportState(binding.sessionId, "session-created");
+			if (before(binding.importState, "hydrated")) {
+				await this.target.hydrate(transaction);
+				binding = this.adapter.markImportState(binding.sessionId, "hydrated");
+			}
+			if (before(binding.importState, "attached")) {
+				await this.target.attach(transaction);
+				binding = this.adapter.markImportState(binding.sessionId, "attached");
+			}
+			if (before(binding.importState, "committed")) {
+				await this.target.finalize(transaction);
+				binding = this.adapter.markImportState(binding.sessionId, "committed");
+			}
+			return binding.sessionId;
+		} finally {
+			if (transaction !== null) await this.target.release?.(transaction);
+		}
+	}
+};
+function importedDshSessionId(sessionId) {
+	return `claude-import-${createHash("sha256").update(String(sessionId)).digest("hex").slice(0, 24)}`;
+}
+function before(current, target) {
+	return IMPORT_STATE_ORDER.indexOf(current) < IMPORT_STATE_ORDER.indexOf(target);
+}
+function compareInventorySessions(left, right) {
+	const updated = timestampValue(right.lastModified) - timestampValue(left.lastModified);
+	return updated === 0 ? String(left.sessionId).localeCompare(String(right.sessionId)) : updated;
+}
+function timestampValue(value) {
+	if (typeof value === "number" && Number.isFinite(value)) return value;
+	const parsed = Date.parse(String(value ?? ""));
+	return Number.isFinite(parsed) ? parsed : 0;
+}
+function selectedImportEntries(entries, sessionIds) {
+	if (sessionIds === void 0) return entries;
+	if (!Array.isArray(sessionIds) || sessionIds.length === 0) throw new Error("At least one Claude Session must be selected");
+	const selected = /* @__PURE__ */ new Set();
+	for (const rawId of sessionIds) {
+		if (typeof rawId !== "string") throw new Error("Selected Claude Session IDs must be non-empty strings");
+		const sessionId = rawId.trim();
+		if (!sessionId) throw new Error("Selected Claude Session IDs must be non-empty strings");
+		if (selected.has(sessionId)) throw new Error(`Claude Session ${shortSessionId(sessionId)} was selected more than once`);
+		selected.add(sessionId);
+	}
+	const inventory = new Map(entries.map((entry) => [entry.session.sessionId, entry]));
+	for (const sessionId of selected) {
+		const entry = inventory.get(sessionId);
+		if (!entry) throw new Error(`Claude Session ${shortSessionId(sessionId)} is not available in this Workspace`);
+		if (entry.status === "existing") throw new Error(`Claude Session ${shortSessionId(sessionId)} is already bound to DSH`);
+	}
+	return entries.filter((entry) => selected.has(entry.session.sessionId));
+}
+async function canonicalPath(path) {
+	const absolute = resolve(path);
+	try {
+		return await realpath(absolute);
+	} catch {
+		return absolute;
+	}
+}
+function shortSessionId(sessionId) {
+	const value = String(sessionId);
+	return value.length > 12 ? `${value.slice(0, 8)}...${value.slice(-4)}` : value;
+}
+function publicErrorMessage(error, sessionId, shortId) {
+	const message = error?.message ?? String(error);
+	return String(message).replaceAll(String(sessionId), shortId);
+}
+//#endregion
+//#region claude-import-contract.mjs
+const CLAUDE_IMPORT_PATH = "/api/relay/claude/import";
+//#endregion
+//#region claude-import-route.js
+function registerClaudeImportRoute(ctx, options) {
+	return ctx.webServer.register({
+		kind: "exact",
+		path: CLAUDE_IMPORT_PATH,
+		handler: createClaudeImportHandler({
+			workspaceRegistry: ctx.workspaceRegistry,
+			token: process.env.RELAY_CLAUDE_IMPORT_TOKEN,
+			...options
+		})
+	});
+}
+function createClaudeImportHandler({ importer, workspaceRegistry, token, maxBodyBytes = 16384 }) {
+	if (!importer || !workspaceRegistry) throw new Error("Claude import route requires importer and Workspace registry");
+	return async (request, response) => {
+		if (request.method !== "POST") {
+			writeJson(response, 405, { error: "method_not_allowed" }, { allow: "POST" });
+			return;
+		}
+		if (!authorized(request, token)) {
+			writeJson(response, 403, { error: "forbidden" });
+			return;
+		}
+		try {
+			const body = await readJson(request, maxBodyBytes);
+			const action = body?.action;
+			const cwd = requiredString$1(body?.cwd, "cwd");
+			if (action !== "scan" && action !== "import") throw new ImportRouteError(400, "action must be scan or import");
+			const workspace = await workspaceRegistry.resolveByPath(cwd);
+			if (!workspace) throw new ImportRouteError(404, "Workspace is not registered in DSH");
+			if (action === "scan") {
+				const inventory = await importer.scanWorkspace(workspace.path);
+				writeJson(response, 200, {
+					workspace: {
+						title: workspace.title,
+						path: workspace.path
+					},
+					summary: inventory.summary,
+					candidates: publicCandidates(inventory.entries)
+				});
+				return;
+			}
+			const sessionIds = optionalSessionIds(body?.sessionIds);
+			response.writeHead(200, {
+				"content-type": "application/x-ndjson; charset=utf-8",
+				"cache-control": "no-store",
+				"x-content-type-options": "nosniff"
+			});
+			try {
+				writeLine(response, {
+					type: "complete",
+					result: await importer.importWorkspace(workspace.path, {
+						sessionIds,
+						onProgress: (progress) => writeLine(response, {
+							type: "progress",
+							...progress
+						})
+					})
+				});
+			} catch (error) {
+				writeLine(response, {
+					type: "error",
+					error: "import_failed",
+					message: error?.message ?? String(error)
+				});
+			}
+			response.end();
+		} catch (error) {
+			const status = error instanceof ImportRouteError ? error.statusCode : 500;
+			writeJson(response, status, {
+				error: status === 413 ? "payload_too_large" : status === 404 ? "workspace_not_found" : status < 500 ? "invalid_request" : "import_failed",
+				message: error?.message ?? String(error)
+			});
+		}
+	};
+}
+async function readJson(request, maxBodyBytes) {
+	if (String(request.headers?.["content-type"] ?? "").split(";", 1)[0].trim() !== "application/json") throw new ImportRouteError(400, "content-type must be application/json");
+	const chunks = [];
+	let size = 0;
+	for await (const chunk of request) {
+		const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+		size += buffer.length;
+		if (size > maxBodyBytes) throw new ImportRouteError(413, `request exceeds ${maxBodyBytes} bytes`);
+		chunks.push(buffer);
+	}
+	if (size === 0) throw new ImportRouteError(400, "request body is empty");
+	try {
+		return JSON.parse(Buffer.concat(chunks).toString("utf8"));
+	} catch {
+		throw new ImportRouteError(400, "request body is not valid JSON");
+	}
+}
+function authorized(request, token) {
+	if (isLoopback(request.socket?.remoteAddress)) return true;
+	if (!token) return false;
+	const authorization = String(request.headers?.authorization ?? "");
+	if (!authorization.startsWith("Bearer ")) return false;
+	const supplied = Buffer.from(authorization.slice(7));
+	const expected = Buffer.from(String(token));
+	return supplied.length === expected.length && timingSafeEqual(supplied, expected);
+}
+function isLoopback(address) {
+	return address === "127.0.0.1" || address === "::1" || address === "::ffff:127.0.0.1";
+}
+function requiredString$1(value, name) {
+	if (typeof value !== "string" || !value.trim()) throw new ImportRouteError(400, `${name} is required`);
+	return value.trim();
+}
+function optionalSessionIds(value) {
+	if (value === void 0) return void 0;
+	if (!Array.isArray(value) || value.length === 0 || value.length > 100) throw new ImportRouteError(400, "sessionIds must contain between 1 and 100 IDs");
+	const ids = value.map((sessionId) => requiredString$1(sessionId, "sessionId"));
+	if (new Set(ids).size !== ids.length) throw new ImportRouteError(400, "sessionIds must be unique");
+	return ids;
+}
+function publicCandidates(entries = []) {
+	return entries.filter((entry) => entry.status === "ready" || entry.status === "recoverable").map(({ session, status }) => ({
+		id: session.sessionId,
+		title: publicSessionTitle(session),
+		cwd: session.cwd,
+		updatedAt: session.lastModified ?? session.createdAt ?? null,
+		status
+	}));
+}
+function publicSessionTitle(session) {
+	for (const value of [
+		session.customTitle,
+		session.summary,
+		session.firstPrompt
+	]) {
+		if (typeof value !== "string") continue;
+		const normalized = value.replace(/\s+/g, " ").trim();
+		if (normalized) return normalized.slice(0, 160);
+	}
+	return String(session.sessionId);
+}
+function writeLine(response, value) {
+	response.write(`${JSON.stringify(value)}\n`);
+}
+function writeJson(response, status, value, headers = {}) {
+	response.writeHead(status, {
+		"content-type": "application/json; charset=utf-8",
+		"cache-control": "no-store",
+		"x-content-type-options": "nosniff",
+		...headers
+	});
+	response.end(`${JSON.stringify(value)}\n`);
+}
+var ImportRouteError = class extends Error {
+	constructor(statusCode, message) {
+		super(message);
+		this.statusCode = statusCode;
+	}
+};
+//#endregion
 //#region claude-link-store.js
 var ClaudeLinkStore = class {
 	constructor(path) {
@@ -2558,7 +3182,13 @@ function loadRecords(path) {
 	}
 }
 function validRecord(record) {
-	return isObject(record) && (record.claudeSessionId === null || typeof record.claudeSessionId === "string") && isObject(record.config);
+	return isObject(record) && (record.claudeSessionId === null || typeof record.claudeSessionId === "string") && isObject(record.config) && (record.bindingMode === void 0 || record.bindingMode === "native" || record.bindingMode === "imported") && (record.importState === void 0 || [
+		"reserved",
+		"session-created",
+		"hydrated",
+		"attached",
+		"committed"
+	].includes(record.importState));
 }
 function isObject(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -2657,6 +3287,353 @@ function plainObject(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value) ? value : {};
 }
 //#endregion
+//#region dsh-import-target.js
+var DshClaudeImportTarget = class {
+	constructor({ ctx, logger = console }) {
+		this.ctx = ctx;
+		this.logger = logger;
+		this.persistedIds = null;
+	}
+	async prepare(input) {
+		const sessionId = SessionId(input.binding.sessionId);
+		const projection = claudeHistoryProjection(input.source.messages ?? []);
+		const seed = buildClaudeHistorySeed(projection, input.source.lastModified, input.binding.config);
+		const resident = this.ctx.agents.get(sessionId);
+		if (resident) return {
+			...input,
+			projection,
+			seed,
+			agent: resident,
+			handle: null
+		};
+		const persistedIds = await this.loadPersistedIds();
+		const agentOptions = {
+			provider: CLAUDE_PROVIDER,
+			model: input.binding.config.model
+		};
+		const handle = persistedIds.has(sessionId) ? await this.ctx.agents.resume({
+			resumeSessionId: sessionId,
+			agentOptions
+		}) : await this.ctx.agents.create({
+			sessionId,
+			seed,
+			agentOptions,
+			meta: {
+				cwd: input.source.cwd,
+				createdAt: importedCreatedAt(input.source, seed),
+				agentPreset: CLAUDE_PRESET
+			}
+		});
+		return {
+			...input,
+			projection,
+			seed,
+			agent: handle.agent,
+			handle
+		};
+	}
+	async hydrate(transaction) {
+		applySessionTitle(this.ctx, transaction.agent.session, transaction.source);
+		await this.ctx.sessions.flush(transaction.agent.session);
+		(await this.loadPersistedIds()).add(SessionId(transaction.binding.sessionId));
+		const projectionCache = this.ctx.get?.("sessionProjectionCache");
+		if (!projectionCache?.write) throw new Error("Claude Session import requires DSH's sessionProjectionCache service");
+		await projectionCache.write(transaction.agent.session);
+		return projectionSummary(transaction.projection);
+	}
+	async attach(transaction) {
+		const workspace = await this.ctx.workspaceRegistry.resolveByPath(transaction.workspaceCwd);
+		if (!workspace) throw new Error(`No registered DSH Workspace matches ${transaction.workspaceCwd}`);
+		await workspace.attachSession(SessionId(transaction.binding.sessionId));
+	}
+	async finalize(transaction) {
+		await this.ctx.sessions.flush(transaction.agent.session);
+		(await this.loadPersistedIds()).add(SessionId(transaction.binding.sessionId));
+	}
+	async release(transaction) {
+		await transaction.handle?.dispose();
+	}
+	async loadPersistedIds() {
+		if (this.persistedIds === null) this.persistedIds = new Set((await this.ctx.sessionPersistence.list()).map((header) => SessionId(header.id)));
+		return this.persistedIds;
+	}
+};
+function buildClaudeHistorySeed(projection, updatedAt, config) {
+	const time = timestampMs(updatedAt);
+	const events = [];
+	const append = (type, data, surfaceOp = null) => {
+		events.push({
+			type,
+			seq: events.length,
+			time,
+			data,
+			...surfaceOp === null ? {} : { surfaceOp }
+		});
+	};
+	append("request/header", {
+		header: { config: {
+			provider: CLAUDE_PROVIDER,
+			model: config.model,
+			...config.effort ? { reasoningEffort: config.effort } : {}
+		} },
+		reason: "initial"
+	});
+	let turn = 1;
+	for (const sourceTurn of projection.turns) {
+		if (sourceTurn.timeline.length === 0) continue;
+		append("turn/start", { turn });
+		let step = 0;
+		for (const entry of sourceTurn.timeline) {
+			if (entry.kind === "message" && entry.role === "user") {
+				append("user/message", freezeMessage({
+					id: MessageId(entry.id),
+					role: "user",
+					content: entry.content,
+					source: { kind: "user" }
+				}), "append");
+				continue;
+			}
+			step += 1;
+			append("step/start", {
+				turn,
+				step
+			});
+			if (entry.kind === "message") append("assistant/message", {
+				turn,
+				step,
+				message: freezeMessage({
+					id: MessageId(entry.id),
+					role: "assistant",
+					content: entry.content,
+					source: {
+						kind: "model",
+						provider: CLAUDE_PROVIDER,
+						model: "imported"
+					}
+				})
+			}, "append");
+			else {
+				const callId = CallId(entry.callId);
+				append("assistant/message", {
+					turn,
+					step,
+					message: freezeMessage({
+						id: MessageId(entry.requestId),
+						role: "assistant",
+						content: [{
+							type: "tool-call",
+							id: callId,
+							name: entry.name,
+							arguments: entry.arguments
+						}],
+						source: {
+							kind: "model",
+							provider: CLAUDE_PROVIDER,
+							model: "imported"
+						}
+					})
+				}, "append");
+				append("tool/call", {
+					turn,
+					step,
+					callId,
+					name: entry.name,
+					arguments: entry.arguments
+				});
+				append("tool/result", {
+					turn,
+					step,
+					message: freezeMessage({
+						id: MessageId(entry.resultId),
+						role: "user",
+						content: [{
+							type: "tool-result",
+							toolCallId: callId,
+							content: entry.content,
+							isError: entry.isError
+						}],
+						source: {
+							kind: "tool",
+							callId
+						}
+					})
+				}, "append");
+			}
+			append("step/end", {
+				turn,
+				step
+			});
+		}
+		append("turn/end", {
+			turn,
+			reason: { kind: "stop" }
+		});
+		turn += 1;
+	}
+	return events;
+}
+function claudeHistoryProjection(messages) {
+	const turns = [];
+	const pendingTools = /* @__PURE__ */ new Map();
+	let current = null;
+	let skippedBlocks = 0;
+	for (const source of messages) {
+		const content = sourceContentBlocks(source);
+		if (source?.type === "user" && source.parent_tool_use_id == null) {
+			const blocks = content.filter((block) => block?.type === "text" && normalizedText(block.text)).map((block) => ({
+				type: "text",
+				text: normalizedText(block.text)
+			}));
+			if (blocks.length > 0) {
+				skippedBlocks += content.filter((block) => block?.type !== "text").length;
+				current = {
+					sourceId: source.uuid,
+					timeline: []
+				};
+				current.timeline.push({
+					kind: "message",
+					role: "user",
+					id: projectionId(source, "user"),
+					content: blocks
+				});
+				turns.push(current);
+				continue;
+			}
+		}
+		if (!current) {
+			skippedBlocks += content.length;
+			continue;
+		}
+		if (source?.type === "assistant") {
+			for (const [index, block] of content.entries()) if (block?.type === "thinking" && normalizedText(block.thinking)) current.timeline.push({
+				kind: "message",
+				role: "assistant",
+				id: projectionId(source, `thinking-${index}`),
+				content: [{
+					type: "reasoning",
+					text: normalizedText(block.thinking)
+				}]
+			});
+			else if (block?.type === "text" && normalizedText(block.text)) current.timeline.push({
+				kind: "message",
+				role: "assistant",
+				id: projectionId(source, `text-${index}`),
+				content: [{
+					type: "text",
+					text: normalizedText(block.text)
+				}]
+			});
+			else if (block?.type === "tool_use" && normalizedText(block.id) && normalizedText(block.name)) pendingTools.set(block.id, {
+				turn: current,
+				source,
+				index,
+				name: block.name,
+				arguments: jsonText(block.input)
+			});
+			else skippedBlocks += 1;
+			continue;
+		}
+		if (source?.type === "user") {
+			for (const block of content) {
+				if (block?.type !== "tool_result" || !pendingTools.has(block.tool_use_id)) {
+					skippedBlocks += 1;
+					continue;
+				}
+				const tool = pendingTools.get(block.tool_use_id);
+				pendingTools.delete(block.tool_use_id);
+				const result = toolResultContent(block.content);
+				skippedBlocks += result.skipped;
+				tool.turn.timeline.push({
+					kind: "activity",
+					requestId: projectionId(tool.source, `tool-${tool.index}-request`),
+					resultId: projectionId(source, `tool-${tool.index}-result`),
+					callId: `claude:${block.tool_use_id}`,
+					name: tool.name,
+					arguments: tool.arguments,
+					content: result.content,
+					isError: block.is_error === true
+				});
+			}
+			continue;
+		}
+		skippedBlocks += content.length;
+	}
+	skippedBlocks += pendingTools.size;
+	return {
+		turns,
+		skippedBlocks
+	};
+}
+function sourceContentBlocks(source) {
+	const value = source?.message?.content;
+	if (Array.isArray(value)) return value;
+	if (source?.type === "user" && normalizedText(value)) return [{
+		type: "text",
+		text: value
+	}];
+	return [];
+}
+function toolResultContent(value) {
+	if (typeof value === "string") return {
+		content: [{
+			type: "text",
+			text: value
+		}],
+		skipped: 0
+	};
+	if (!Array.isArray(value)) return {
+		content: [],
+		skipped: value == null ? 0 : 1
+	};
+	const content = value.filter((block) => block?.type === "text" && typeof block.text === "string").map((block) => ({
+		type: "text",
+		text: block.text
+	}));
+	return {
+		content,
+		skipped: value.length - content.length
+	};
+}
+function projectionSummary(projection) {
+	return {
+		projectedTurns: projection.turns.length,
+		projectedMessages: projection.turns.reduce((count, turn) => count + turn.timeline.length, 0),
+		skippedBlocks: projection.skippedBlocks
+	};
+}
+function projectionId(message, suffix) {
+	return `claude:${createHash("sha256").update(`${message.session_id ?? "session"}:${message.uuid ?? "message"}:${suffix}`).digest("hex").slice(0, 24)}`;
+}
+function importedCreatedAt(source, seed) {
+	const updated = timestampMs(source.lastModified);
+	if (!seed.some((event) => event.type === "user/message")) return updated;
+	return Math.min(timestampMs(source.createdAt, updated), updated);
+}
+function timestampMs(value, fallback = Date.now()) {
+	if (typeof value !== "number" || !Number.isFinite(value) || value < 0) return fallback;
+	return Math.trunc(value < 0xe8d4a51000 ? value * 1e3 : value);
+}
+function applySessionTitle(ctx, session, source) {
+	const titles = ctx.get?.("sessionTitle");
+	if (!titles) throw new Error("Claude Session import requires DSH's sessionTitle service");
+	const title = summarizeTitle(source.customTitle) || summarizeTitle(source.summary) || summarizeTitle(source.firstPrompt) || `Claude ${String(source.sessionId).slice(0, 8)}`;
+	if (titles.get(session)?.title !== title) titles.rename(session, title);
+}
+function summarizeTitle(value) {
+	const text = normalizedText(value).replace(/\s+/g, " ");
+	return text.length > 80 ? `${text.slice(0, 79)}...` : text;
+}
+function normalizedText(value) {
+	return typeof value === "string" ? value.trim() : "";
+}
+function jsonText(value) {
+	try {
+		return JSON.stringify(value ?? {}, null, 2);
+	} catch {
+		return "{}";
+	}
+}
+//#endregion
 //#region dsh-plugin.js
 function createDshClaudePlugin(ctx, config = {}) {
 	return definePlugin({
@@ -2665,19 +3642,37 @@ function createDshClaudePlugin(ctx, config = {}) {
 			version: "1.0.0",
 			provides: { "relay.dsh.claude.v1": "1.0.0" },
 			requires: { "relay.execution.claude.v1": "^1.0.0" },
-			permissions: ["dsh:llm", "dsh:agents"]
+			permissions: [
+				"dsh:llm",
+				"dsh:agents",
+				"dsh:web-server"
+			]
 		},
 		async activate({ capabilities, defer }) {
 			installClaudeSessionEventType();
 			const runtime = capabilities.require("relay.execution.claude.v1");
+			const linkStore = new ClaudeLinkStore(resolveLinkPath(config.claudeLinkPath));
 			const adapter = new ClaudeDshAdapter({
 				runtime,
 				ready: runtime.whenReady(),
-				linkStore: new ClaudeLinkStore(resolveLinkPath(config.claudeLinkPath)),
+				linkStore,
 				attachments: ctx.attachments,
 				logger: ctx.logger
 			});
+			const importer = new ClaudeWorkspaceImporter({
+				runtime,
+				adapter,
+				target: new DshClaudeImportTarget({
+					ctx,
+					logger: ctx.logger
+				}),
+				logger: ctx.logger
+			});
 			defer(ctx.llm.registerAdapter([CLAUDE_PROVIDER], adapter));
+			defer(registerClaudeImportRoute(ctx, {
+				importer,
+				token: config.claudeImportToken ?? process.env.RELAY_CLAUDE_IMPORT_TOKEN
+			}));
 			defer(runtime.subscribeRequest((request) => {
 				handleClaudeSdkRequest(ctx, {
 					adapter,
@@ -2755,7 +3750,9 @@ const inject = [
 	"tools",
 	"typert",
 	"userQuestions",
-	"webServer"
+	"webServer",
+	"workspaceRegistry",
+	"sessionTitle"
 ];
 async function apply(ctx, config = {}) {
 	const host = new PluginHost();
@@ -2769,7 +3766,8 @@ async function apply(ctx, config = {}) {
 			args: config.claudeArgs,
 			codeExecutablePath: config.claudeCodeExecutablePath,
 			requestTimeoutMs: config.claudeRequestTimeoutMs,
-			cwd: config.cwd
+			cwd: config.cwd,
+			plugins: config.claudePlugins
 		}), createDshClaudePlugin(ctx, config)]);
 	} catch (error) {
 		await release();