pi2dsh 0.2.0

package/dist/mcp-config-jL9w70It.mjs

@@ -0,0 +1,1535 @@
+
+import { t as getAgentDir } from "./pi-config-shim-CZ1wFzqM.mjs";
+import { builtinModules } from "node:module";
+import { cp, lstat, mkdir, readFile, readdir, stat, writeFile } from "node:fs/promises";
+import { basename, dirname, extname, join, relative, resolve } from "node:path";
+import ts from "typescript";
+import { fileURLToPath } from "node:url";
+import { parse } from "yaml";
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+//#region src/compatibility.ts
+const rule = (level, detail) => ({
+	level,
+	detail
+});
+const PI_CODING_AGENT_PACKAGES = Object.freeze(["@earendil-works/pi-coding-agent", "@mariozechner/pi-coding-agent"]);
+const PI_TUI_PACKAGES = Object.freeze(["@earendil-works/pi-tui", "@mariozechner/pi-tui"]);
+const PI_AI_PACKAGES = Object.freeze(["@earendil-works/pi-ai", "@mariozechner/pi-ai"]);
+const VENDORED = "Vendored byte-identical from Pi, so semantics match Pi exactly.";
+const HEADLESS_COMPONENT = "Constructible headless component with Pi-exact signatures; renders plain text, never a terminal.";
+const RUNTIME_STUB = "Importable, but calling it fails explicitly: it belongs to Pi's internal agent runtime and needs a native DSH port.";
+const HOST_IMPORT_RULES = Object.freeze({
+	"pi-coding-agent": Object.freeze({
+		defineTool: rule("full", "Identity helper, preserved."),
+		CONFIG_DIR_NAME: rule("partial", "The conventional config directory name is preserved, while DSH owns the actual profile layout."),
+		DEFAULT_MAX_LINES: rule("full", VENDORED),
+		DEFAULT_MAX_BYTES: rule("full", VENDORED),
+		VERSION: rule("partial", "Reports a pi2dsh compatibility marker instead of a Pi release version."),
+		CURRENT_SESSION_VERSION: rule("full", VENDORED),
+		getAgentDir: rule("partial", "Redirected to an isolated DSH-owned pi2dsh directory instead of Pi global state."),
+		getPackageDir: rule("partial", "Resolves inside the DSH-owned pi2dsh agent directory."),
+		formatSize: rule("full", VENDORED),
+		truncateHead: rule("full", VENDORED),
+		truncateTail: rule("full", VENDORED),
+		truncateLine: rule("full", VENDORED),
+		withFileMutationQueue: rule("full", VENDORED),
+		SessionManager: rule("full", `${VENDORED} Sessions live under the DSH-owned pi2dsh agent directory.`),
+		parseSessionEntries: rule("full", VENDORED),
+		migrateSessionEntries: rule("full", VENDORED),
+		getLatestCompactionEntry: rule("full", VENDORED),
+		sessionEntryToContextMessages: rule("full", VENDORED),
+		buildContextEntries: rule("full", VENDORED),
+		buildSessionContext: rule("full", VENDORED),
+		loadEntriesFromFile: rule("full", VENDORED),
+		findMostRecentSession: rule("full", VENDORED),
+		getDefaultSessionDir: rule("full", VENDORED),
+		assertValidSessionId: rule("full", VENDORED),
+		convertToLlm: rule("full", VENDORED),
+		createCustomMessage: rule("full", VENDORED),
+		createBranchSummaryMessage: rule("full", VENDORED),
+		createCompactionSummaryMessage: rule("full", VENDORED),
+		bashExecutionToText: rule("full", VENDORED),
+		estimateTokens: rule("full", "Reimplements Pi's chars/4 heuristic over the same message roles."),
+		calculateContextTokens: rule("full", "Sums the Pi chars/4 heuristic across messages."),
+		DEFAULT_COMPACTION_SETTINGS: rule("full", "Pi's default compaction thresholds, preserved as constants."),
+		serializeConversation: rule("partial", "JSON serialization without Pi's prompt-oriented formatting."),
+		shouldCompact: rule("partial", "Always reports false: DSH owns compaction scheduling."),
+		compact: rule("unsupported", "Pi compaction execution belongs to DSH's native compaction plugin; calling fails explicitly."),
+		findCutPoint: rule("unsupported", RUNTIME_STUB),
+		generateSummary: rule("unsupported", RUNTIME_STUB),
+		generateSummaryWithUsage: rule("unsupported", RUNTIME_STUB),
+		generateBranchSummary: rule("unsupported", RUNTIME_STUB),
+		parseFrontmatter: rule("full", "Frontmatter parsing with Pi-compatible semantics."),
+		stripFrontmatter: rule("full", "Frontmatter stripping with Pi-compatible semantics."),
+		copyToClipboard: rule("partial", "Attempts the platform clipboard command (pbcopy/clip/wl-copy/xclip); resolves false when none succeeds."),
+		resizeImage: rule("partial", "Passes images through un-resized; Pi resizes only to save tokens, so content is preserved."),
+		convertToPng: rule("partial", "PNG input passes through; other formats fail explicitly without Pi's wasm codec."),
+		getShellConfig: rule("partial", "Standard shell detection without Pi's managed-bin PATH handling."),
+		getBinDir: rule("partial", "Reports the first PATH segment instead of Pi's managed bin directory."),
+		Theme: rule("partial", "Headless theme: styling calls return their input text unstyled."),
+		theme: rule("partial", "A headless theme singleton; jiti-loaded Pi extensions must not rely on Pi global theme state anyway."),
+		initTheme: rule("partial", "Accepted as a no-op; DSH surfaces own presentation."),
+		getSettingsListTheme: rule("partial", "Returns an unstyled theme with Pi's exact field shape."),
+		getSelectListTheme: rule("partial", "Returns an unstyled theme with Pi's exact field shape."),
+		getMarkdownTheme: rule("partial", "Returns a plain-text headless theme; Pi terminal styling is intentionally discarded."),
+		getLanguageFromPath: rule("partial", "Extension-based language detection covering common languages."),
+		highlightCode: rule("partial", "Splits lines without terminal syntax colors."),
+		DynamicBorder: rule("full", "Headless implementation of Pi's one-line border component; pass an explicit color function as Pi itself recommends."),
+		SettingsManager: rule("partial", "In-memory settings with Pi's getter/setter surface; DSH owns real persisted configuration."),
+		InMemorySettingsStorage: rule("partial", "In-memory storage stub honoring the withLock contract."),
+		FileSettingsStorage: rule("partial", "Alias of the in-memory storage; DSH owns persisted settings."),
+		ModelRegistry: rule("partial", "A local registry container; DSH llm adapters own real model routing."),
+		createEventBus: rule("full", "Pi event-bus semantics: async handler isolation and unsubscribe functions."),
+		readStoredCredential: rule("partial", "Reads Pi-style auth.json from the pi2dsh-owned agent directory; DSH credentials stay authoritative for DSH model calls."),
+		parseSkillBlock: rule("full", "Pi's skill_content block parser, reimplemented over the same wire shape."),
+		wrapRegisteredTool: rule("unsupported", RUNTIME_STUB),
+		ProjectTrustStore: rule("unsupported", RUNTIME_STUB),
+		DefaultResourceLoader: rule("unsupported", RUNTIME_STUB),
+		DefaultPackageManager: rule("unsupported", RUNTIME_STUB),
+		ModelRuntime: rule("unsupported", RUNTIME_STUB),
+		createAgentSession: rule("unsupported", RUNTIME_STUB),
+		createCodingTools: rule("unsupported", RUNTIME_STUB),
+		createReadOnlyTools: rule("unsupported", RUNTIME_STUB),
+		createBashTool: rule("unsupported", RUNTIME_STUB),
+		createReadTool: rule("unsupported", RUNTIME_STUB),
+		createEditTool: rule("unsupported", RUNTIME_STUB),
+		createWriteTool: rule("unsupported", RUNTIME_STUB),
+		createGrepTool: rule("unsupported", RUNTIME_STUB),
+		createFindTool: rule("unsupported", RUNTIME_STUB),
+		createLsTool: rule("unsupported", RUNTIME_STUB),
+		loadSkills: rule("unsupported", RUNTIME_STUB),
+		loadSkillsFromDir: rule("unsupported", RUNTIME_STUB),
+		formatSkillsForPrompt: rule("unsupported", RUNTIME_STUB),
+		CustomEditor: rule("partial", HEADLESS_COMPONENT),
+		ToolExecutionComponent: rule("partial", HEADLESS_COMPONENT),
+		FooterComponent: rule("partial", HEADLESS_COMPONENT),
+		BorderedLoader: rule("partial", HEADLESS_COMPONENT),
+		CustomMessageComponent: rule("partial", HEADLESS_COMPONENT),
+		AssistantMessageComponent: rule("partial", HEADLESS_COMPONENT),
+		UserMessageComponent: rule("partial", HEADLESS_COMPONENT),
+		ExtensionSelectorComponent: rule("partial", HEADLESS_COMPONENT),
+		ExtensionInputComponent: rule("partial", HEADLESS_COMPONENT),
+		ExtensionEditorComponent: rule("partial", HEADLESS_COMPONENT),
+		SettingsSelectorComponent: rule("partial", HEADLESS_COMPONENT),
+		renderDiff: rule("partial", "Plain unified-style diff lines without terminal colors."),
+		truncateToVisualLines: rule("partial", "Visual-line truncation backed by Pi's vendored width math."),
+		keyHint: rule("partial", "Plain-text key hint without theme styling."),
+		keyText: rule("partial", "Plain-text key name without theme styling."),
+		rawKeyHint: rule("partial", "Plain-text key hint without theme styling.")
+	}),
+	"pi-tui": Object.freeze({
+		visibleWidth: rule("full", VENDORED),
+		truncateToWidth: rule("full", VENDORED),
+		wrapTextWithAnsi: rule("full", VENDORED),
+		sliceByColumn: rule("full", VENDORED),
+		sliceWithWidth: rule("full", VENDORED),
+		stripTerminalSequences: rule("full", VENDORED),
+		getOsc8LinkAtColumn: rule("full", VENDORED),
+		normalizeTerminalOutput: rule("full", VENDORED),
+		extractAnsiCode: rule("full", VENDORED),
+		getGraphemeCellRange: rule("full", VENDORED),
+		getGraphemeSegmenter: rule("full", VENDORED),
+		getWordSegmenter: rule("full", VENDORED),
+		applyBackgroundToLine: rule("full", VENDORED),
+		isWhitespaceChar: rule("full", VENDORED),
+		isPunctuationChar: rule("full", VENDORED),
+		cjkBreakRegex: rule("full", VENDORED),
+		PUNCTUATION_REGEX: rule("full", VENDORED),
+		fuzzyMatch: rule("full", VENDORED),
+		fuzzyFilter: rule("full", VENDORED),
+		parseKey: rule("full", VENDORED),
+		matchesKey: rule("full", VENDORED),
+		isKeyRelease: rule("full", VENDORED),
+		isKeyRepeat: rule("full", VENDORED),
+		decodeKittyPrintable: rule("full", VENDORED),
+		isKittyProtocolActive: rule("full", VENDORED),
+		setKittyProtocolActive: rule("full", VENDORED),
+		Key: rule("full", VENDORED),
+		getKeybindings: rule("full", `${VENDORED} Bindings only match when a surface feeds terminal input, which DSH does not.`),
+		setKeybindings: rule("full", VENDORED),
+		KeybindingsManager: rule("full", VENDORED),
+		TUI_KEYBINDINGS: rule("full", VENDORED),
+		parseOsc11BackgroundColor: rule("full", VENDORED),
+		parseTerminalColorSchemeReport: rule("full", VENDORED),
+		renderLatex: rule("full", VENDORED),
+		getPngDimensions: rule("full", VENDORED),
+		getJpegDimensions: rule("full", VENDORED),
+		getGifDimensions: rule("full", VENDORED),
+		getWebpDimensions: rule("full", VENDORED),
+		getImageDimensions: rule("full", VENDORED),
+		calculateImageRows: rule("full", VENDORED),
+		allocateImageId: rule("full", VENDORED),
+		encodeKitty: rule("partial", `${VENDORED} No DSH surface consumes the escape sequences.`),
+		encodeITerm2: rule("partial", `${VENDORED} No DSH surface consumes the escape sequences.`),
+		deleteKittyImage: rule("partial", `${VENDORED} No DSH surface consumes the escape sequences.`),
+		deleteAllKittyImages: rule("partial", `${VENDORED} No DSH surface consumes the escape sequences.`),
+		detectCapabilities: rule("partial", `${VENDORED} Headless environments report no image protocol.`),
+		getCapabilities: rule("partial", VENDORED),
+		setCapabilities: rule("partial", VENDORED),
+		resetCapabilitiesCache: rule("partial", VENDORED),
+		getCellDimensions: rule("partial", VENDORED),
+		setCellDimensions: rule("partial", VENDORED),
+		hyperlink: rule("full", VENDORED),
+		imageFallback: rule("full", VENDORED),
+		CombinedAutocompleteProvider: rule("partial", `${VENDORED} Suggestions surface only if a DSH UI asks for them.`),
+		Marked: rule("full", "Re-exported from the same marked dependency Pi uses."),
+		CURSOR_MARKER: rule("full", "Pi's exact APC marker; vendored width math treats it as zero-width."),
+		Text: rule("partial", HEADLESS_COMPONENT),
+		Spacer: rule("partial", HEADLESS_COMPONENT),
+		Container: rule("partial", HEADLESS_COMPONENT),
+		Box: rule("partial", HEADLESS_COMPONENT),
+		Markdown: rule("partial", HEADLESS_COMPONENT),
+		TruncatedText: rule("partial", HEADLESS_COMPONENT),
+		Editor: rule("partial", `${HEADLESS_COMPONENT} Text editing state works; interactive keyboard flows do not.`),
+		Input: rule("partial", `${HEADLESS_COMPONENT} Value state and submit/escape callbacks work; kill-ring editing does not.`),
+		SelectList: rule("partial", `${HEADLESS_COMPONENT} Filtering and selection state work; keyboard interaction does not.`),
+		SettingsList: rule("partial", `${HEADLESS_COMPONENT} Value updates work; keyboard interaction does not.`),
+		ScrollView: rule("partial", HEADLESS_COMPONENT),
+		VStack: rule("partial", HEADLESS_COMPONENT),
+		HStack: rule("partial", HEADLESS_COMPONENT),
+		Loader: rule("partial", HEADLESS_COMPONENT),
+		CancellableLoader: rule("partial", HEADLESS_COMPONENT),
+		Image: rule("partial", `${HEADLESS_COMPONENT} Renders a text placeholder; image bytes flow through DSH attachments instead.`),
+		isFocusable: rule("full", "Structural check preserved."),
+		isViewportTUI: rule("partial", "Always false: no viewport TUI exists in DSH surfaces.")
+	}),
+	"pi-ai": Object.freeze({
+		StringEnum: rule("full", "Preserves Pi flat string-enum JSON Schema generation without loading provider SDKs."),
+		registerProvider: rule("partial", "Recorded in a bridge-local registry; DSH llm adapters own real routing."),
+		getProviders: rule("partial", "Returns the bridge-local registry contents."),
+		getProvider: rule("partial", "Reads the bridge-local registry."),
+		getModel: rule("partial", "Resolves no Pi model objects; DSH owns model routing."),
+		getModels: rule("partial", "Returns an empty list; DSH owns model routing."),
+		complete: rule("unsupported", "Pi provider SDK calls have no DSH mapping; calling fails explicitly."),
+		stream: rule("unsupported", "Pi provider SDK calls have no DSH mapping; calling fails explicitly."),
+		Type: rule("full", "Re-exported from the same typebox dependency Pi resolves for extensions."),
+		uuidv7: rule("full", VENDORED),
+		isContextOverflow: rule("full", VENDORED),
+		isRecoverableLength: rule("full", VENDORED),
+		isRetryableAssistantError: rule("full", VENDORED),
+		contentText: rule("full", "Pi's text-block joiner, reimplemented with identical semantics."),
+		clampThinkingLevel: rule("full", "Pi's clamping walk over the extended thinking-level ladder."),
+		getSupportedThinkingLevels: rule("full", "Pi's thinkingLevelMap filter, preserved."),
+		modelsAreEqual: rule("full", "Id+provider equality, preserved.")
+	})
+});
+const CONTEXT_RULES = Object.freeze({
+	cwd: rule("full", "Mapped to the active DSH agent session working directory."),
+	signal: rule("full", "Mapped to the active DSH cancellation signal when one is available."),
+	hasUI: rule("full", "Reports whether the native DSH userQuestions service is available to back Pi dialogs."),
+	mode: rule("partial", "Reports rpc mode so Pi extensions can choose their documented headless fallback."),
+	isIdle: rule("partial", "Command contexts report idle; tool/lifecycle contexts conservatively report non-idle."),
+	isProjectTrusted: rule("partial", "Fails closed as untrusted because DSH does not expose Pi project-trust state."),
+	hasPendingMessages: rule("partial", "Conservatively reports no Pi-specific pending-message queue."),
+	getContextUsage: rule("partial", "Returns no Pi token-usage projection."),
+	getSystemPrompt: rule("full", "Returns the system prompt currently assembled by the bridge."),
+	getSystemPromptOptions: rule("partial", "Returns an empty Pi option projection in command contexts."),
+	waitForIdle: rule("partial", "Mapped to the DSH agent idle boundary when available."),
+	sessionManager: rule("partial", "A real read-only projection: DSH durable messages plus pi2dsh sidecar entries, exposed through Pi's exact 14-method surface as a single-branch tree."),
+	modelRegistry: rule("partial", "Exposes no Pi provider registry because DSH owns model adapters."),
+	model: rule("partial", "Reflects the model override recorded by setModel(); DSH configuration remains authoritative."),
+	scopedModels: rule("partial", "No Pi scoped-model list is projected from DSH configuration."),
+	thinkingLevel: rule("partial", "Reflects the level recorded by setThinkingLevel(); applied as reasoningEffort on the next request."),
+	abort: rule("partial", "Mapped to agent.cancel({ kind: \"hook\" }) on the live DSH agent."),
+	shutdown: rule("unsupported", "A migrated package may not shut down the DSH host; calling fails explicitly."),
+	compact: rule("unsupported", "Pi compaction control requires a native DSH compaction integration; calling fails explicitly."),
+	newSession: rule("unsupported", "Session replacement belongs to the DSH host; calling fails explicitly."),
+	fork: rule("unsupported", "Pi entry-tree forking has no DSH equivalent (DSH fork is boundary-based); calling fails explicitly."),
+	navigateTree: rule("unsupported", "Pi tree navigation has no DSH equivalent; calling fails explicitly."),
+	switchSession: rule("unsupported", "Session switching belongs to the DSH host; calling fails explicitly."),
+	reload: rule("unsupported", "Extension reload belongs to the DSH host (HMR); calling fails explicitly.")
+});
+const UI_CONTEXT_RULES = Object.freeze({
+	notify: rule("full", "Captured as a command result when applicable and emitted through DSH logging."),
+	setStatus: rule("partial", "Accepted as a no-op because DSH owns status presentation."),
+	setWidget: rule("partial", "Accepted as a no-op because Pi terminal widgets cannot render in DSH."),
+	select: rule("full", "Mapped to one native DSH userQuestions single-select request."),
+	confirm: rule("full", "Mapped to one native DSH userQuestions Yes/No request."),
+	input: rule("full", "Mapped to one native DSH userQuestions free-text request."),
+	editor: rule("partial", "Mapped to one DSH userQuestions free-text request; multi-line editing UX is not emulated."),
+	custom: rule("partial", "Resolves undefined, exactly like Pi's own rpc mode; guarded fallbacks keep working."),
+	onTerminalInput: rule("partial", "Raw terminal input is absent; feature-detected listeners remain disabled."),
+	setWorkingMessage: rule("partial", "Accepted as a no-op; DSH owns progress presentation."),
+	setWorkingVisible: rule("partial", "Accepted as a no-op; DSH owns progress presentation."),
+	setWorkingIndicator: rule("partial", "Accepted as a no-op; DSH owns progress presentation."),
+	setHiddenThinkingLabel: rule("partial", "Accepted as a no-op; DSH owns thinking presentation."),
+	setFooter: rule("partial", "Accepted as a no-op; DSH owns footer presentation."),
+	setHeader: rule("partial", "Accepted as a no-op; DSH owns header presentation."),
+	setTitle: rule("partial", "Accepted as a no-op; DSH owns window titles."),
+	pasteToEditor: rule("partial", "Appends to a per-agent editor buffer readable through getEditorText()."),
+	setEditorText: rule("partial", "Stored in a per-agent editor buffer readable through getEditorText()."),
+	getEditorText: rule("partial", "Reads the per-agent editor buffer maintained by the bridge."),
+	addAutocompleteProvider: rule("partial", "Registration is recorded; no DSH surface requests suggestions."),
+	setEditorComponent: rule("partial", "Registration is recorded; no DSH surface mounts a Pi editor component."),
+	getEditorComponent: rule("partial", "Returns the recorded factory."),
+	theme: rule("partial", "A headless theme whose styling calls return unstyled text."),
+	getAllThemes: rule("partial", "Lists the single headless theme."),
+	getTheme: rule("partial", "Resolves only the headless theme."),
+	setTheme: rule("partial", "Accepts the headless theme; other names report an explicit error result."),
+	getToolsExpanded: rule("partial", "A bridge-local presentation flag."),
+	setToolsExpanded: rule("partial", "A bridge-local presentation flag.")
+});
+const API_RULES = Object.freeze({
+	registerTool: {
+		level: "partial",
+		detail: "Registered as a native DSH tool. Text and image results use native DSH content/attachments; unsupported JSON Schema constraints and Pi-only error details are explicitly degraded."
+	},
+	unregisterTool: {
+		level: "full",
+		detail: "Disposes the exact native DSH tool registration and removes it from the migrated package registry."
+	},
+	registerCommand: {
+		level: "partial",
+		detail: "Registered in ctx.commands; ui.notify becomes the result, while interactive Pi TUI methods fail explicitly in headless DSH."
+	},
+	registerShortcut: {
+		level: "partial",
+		detail: "Registration is recorded and introspectable; DSH surfaces feed no terminal key input, so handlers never fire — the same as Pi's non-TUI modes."
+	},
+	registerFlag: {
+		level: "partial",
+		detail: "The declared default is available through getFlag; Pi process flags cannot be added to the DSH launcher."
+	},
+	getFlag: {
+		level: "partial",
+		detail: "Returns the migrated flag default because DSH cannot register the original Pi CLI flag."
+	},
+	registerProvider: {
+		level: "partial",
+		detail: "The provider declaration is recorded and introspectable; model calls stay on native DSH llm adapters and credentials, which own transports and secrets."
+	},
+	unregisterProvider: {
+		level: "partial",
+		detail: "Removes the recorded provider declaration."
+	},
+	registerMessageRenderer: {
+		level: "partial",
+		detail: "Registration is accepted; DSH owns presentation, so the renderer is never invoked — matching Pi's non-TUI surfaces."
+	},
+	registerEntryRenderer: {
+		level: "partial",
+		detail: "Registration is accepted; DSH owns presentation, so the renderer is never invoked — matching Pi's non-TUI surfaces."
+	},
+	registerMarkdownTransformer: {
+		level: "partial",
+		detail: "Registration is accepted; DSH owns presentation, so the transformer is never invoked — matching Pi's non-TUI surfaces."
+	},
+	sendMessage: {
+		level: "partial",
+		detail: "Mapped to native DSH inject/steer/followup delivery with honest plugin provenance; Pi display/details metadata awaits the custom session-entry seam."
+	},
+	sendUserMessage: {
+		level: "full",
+		detail: "Mapped to native DSH steer/followup delivery with text and attachment-backed image content."
+	},
+	appendEntry: {
+		level: "partial",
+		detail: "Persisted in a pi2dsh sidecar next to the DSH session and replayed on session start; DSH's main log stays untouched because it has no out-of-repo plugin-event channel yet."
+	},
+	setSessionName: {
+		level: "partial",
+		detail: "Persisted in the pi2dsh sidecar and announced through session_info_changed; DSH's own title events are also projected when present."
+	},
+	getSessionName: {
+		level: "partial",
+		detail: "Reads the sidecar-persisted session name."
+	},
+	setLabel: {
+		level: "partial",
+		detail: "Persisted in the pi2dsh sidecar and reflected by the sessionManager projection."
+	},
+	exec: {
+		level: "partial",
+		detail: "Mapped to ctx.subprocess, so the selected local/E2B provider owns execution, isolation, cancellation, and tree cleanup; output is bounded to 64 MiB per stream."
+	},
+	getActiveTools: {
+		level: "partial",
+		detail: "Returns every tool visible in the current DSH agent scope, including native and migrated tools; scope-local tools follow DSH composition rules."
+	},
+	getAllTools: {
+		level: "partial",
+		detail: "Returns metadata for all tools visible in the current DSH scope, without Pi-specific prompt guidelines unavailable from DSH schemas."
+	},
+	setActiveTools: {
+		level: "partial",
+		detail: "Mapped to the active DSH agent scope through tools.restrict({ allow }), preserving per-agent global-tool visibility without mutating other agents; DSH scope-local tools remain visible by design."
+	},
+	getCommands: {
+		level: "partial",
+		detail: "Returns commands registered by this migrated Pi package, not every command visible in the DSH scope."
+	},
+	setModel: {
+		level: "partial",
+		detail: "Recorded as a per-agent override applied through the agent/request waterfall on the next model call; DSH remains authoritative for provider routing."
+	},
+	getThinkingLevel: {
+		level: "partial",
+		detail: "Returns the level recorded by setThinkingLevel (default off)."
+	},
+	setThinkingLevel: {
+		level: "partial",
+		detail: "Recorded per agent and applied as reasoningEffort through the agent/request waterfall; DSH validates the effort id at the request boundary."
+	},
+	events: {
+		level: "full",
+		detail: "Package-local Pi extension event-bus emit/on semantics are preserved for migrated extensions in the same bundle."
+	}
+});
+const OBSERVED_NEVER_FIRES = (moment) => ({
+	level: "partial",
+	detail: `Registration is accepted; ${moment} never occurs on DSH surfaces, so the handler never fires. Loading is unaffected.`
+});
+const EVENT_RULES = Object.freeze({
+	session_start: {
+		level: "full",
+		detail: "Mapped to agent/session-start."
+	},
+	session_shutdown: {
+		level: "full",
+		detail: "Mapped to agent disposal and plugin teardown with duplicate suppression."
+	},
+	session_info_changed: {
+		level: "partial",
+		detail: "Fired by setSessionName() and projected from DSH session/title events."
+	},
+	agent_start: {
+		level: "full",
+		detail: "Mapped to the DSH turn/start boundary."
+	},
+	agent_settled: {
+		level: "full",
+		detail: "Mapped to the DSH turn/end boundary."
+	},
+	turn_start: {
+		level: "full",
+		detail: "Mapped from durable turn/start events."
+	},
+	tool_execution_start: {
+		level: "full",
+		detail: "Mapped from durable tool/call events."
+	},
+	tool_execution_end: {
+		level: "full",
+		detail: "Mapped from finalized tools/result events."
+	},
+	tool_execution_update: {
+		level: "partial",
+		detail: "Fired from migrated Pi tools' own onUpdate callbacks; DSH-native tools expose no partial-result stream."
+	},
+	tool_call: {
+		level: "partial",
+		detail: "Blocking is supported, and in-place argument mutation reaches migrated Pi tools; mutating a DSH-native tool's arguments is rejected because DSH logs arguments before policy."
+	},
+	tool_result: {
+		level: "partial",
+		detail: "Text replacement and success-to-error blocking are supported; arbitrary details and error recovery are not."
+	},
+	before_agent_start: {
+		level: "partial",
+		detail: "System-prompt replacement is supported; Pi raw prompt and custom-message injection are unavailable at DSH assembly time."
+	},
+	agent_end: {
+		level: "partial",
+		detail: "The lifecycle boundary is mapped, but the reconstructed Pi message history is intentionally minimal."
+	},
+	turn_end: {
+		level: "partial",
+		detail: "The lifecycle boundary and tool results are mapped; the exact Pi final-message shape is not guaranteed."
+	},
+	message_start: {
+		level: "partial",
+		detail: "Durable user, assistant, and tool-result messages are mapped without Pi-specific provider metadata."
+	},
+	message_end: {
+		level: "partial",
+		detail: "Durable messages are observed, but message replacement is not supported."
+	},
+	message_update: {
+		level: "partial",
+		detail: "Projected from DSH assistant/chunk events with accumulated text; Pi's full AgentMessage accumulation state is approximated."
+	},
+	session_before_compact: {
+		level: "partial",
+		detail: "Projected from DSH compaction/start as a notification; cancel/replace cannot reach DSH's compactor."
+	},
+	session_compact: {
+		level: "partial",
+		detail: "Projected from DSH compaction summary/end events."
+	},
+	model_select: {
+		level: "partial",
+		detail: "Fired by setModel() and projected from request/header model changes in the durable log."
+	},
+	thinking_level_select: {
+		level: "partial",
+		detail: "Fired by setThinkingLevel(); DSH-side reasoning changes surface through request/header projection."
+	},
+	context: {
+		level: "unsupported",
+		detail: "Pi context-list replacement conflicts with DSH append-only request reconstruction; the handler is accepted but never fires."
+	},
+	before_provider_request: {
+		level: "unsupported",
+		detail: "Provider payload mutation belongs in a native DSH LLM adapter; the handler is accepted but never fires."
+	},
+	before_provider_headers: {
+		level: "unsupported",
+		detail: "Provider header mutation belongs in a native DSH LLM adapter; the handler is accepted but never fires."
+	},
+	after_provider_response: {
+		level: "unsupported",
+		detail: "Provider response interception belongs in a native DSH LLM adapter; the handler is accepted but never fires."
+	},
+	user_bash: OBSERVED_NEVER_FIRES("Pi's ! command surface"),
+	input: OBSERVED_NEVER_FIRES("raw Pi terminal input"),
+	project_trust: {
+		level: "unsupported",
+		detail: "Project trust must remain owned by the DSH host; the handler is accepted but never consulted."
+	},
+	resources_discover: {
+		level: "unsupported",
+		detail: "Dynamic resource discovery must be converted into DSH providers; the handler is accepted but never fires."
+	},
+	session_before_switch: OBSERVED_NEVER_FIRES("Pi session switching"),
+	session_before_fork: OBSERVED_NEVER_FIRES("Pi tree forking"),
+	session_before_tree: OBSERVED_NEVER_FIRES("Pi session-tree navigation"),
+	session_tree: OBSERVED_NEVER_FIRES("Pi session-tree navigation")
+});
+function ruleForApi(method) {
+	return API_RULES[method];
+}
+function ruleForEvent(event) {
+	return EVENT_RULES[event] ?? {
+		level: "unsupported",
+		detail: `Unknown Pi event ${JSON.stringify(event)} has no verified DSH mapping.`
+	};
+}
+function ruleForHostImport(packageName, importedName) {
+	const family = PI_CODING_AGENT_PACKAGES.includes(packageName) ? "pi-coding-agent" : PI_TUI_PACKAGES.includes(packageName) ? "pi-tui" : PI_AI_PACKAGES.includes(packageName) ? "pi-ai" : void 0;
+	return family === void 0 ? void 0 : HOST_IMPORT_RULES[family]?.[importedName];
+}
+function ruleForContextProperty(property) {
+	return CONTEXT_RULES[property];
+}
+function ruleForUiContextProperty(property) {
+	return UI_CONTEXT_RULES[property];
+}
+//#endregion
+//#region src/module-graph.ts
+const SCRIPT_EXTENSIONS = /* @__PURE__ */ new Set([
+	".ts",
+	".tsx",
+	".mts",
+	".cts",
+	".js",
+	".jsx",
+	".mjs",
+	".cjs"
+]);
+const MODULE_EXTENSIONS = [
+	".ts",
+	".tsx",
+	".mts",
+	".cts",
+	".js",
+	".jsx",
+	".mjs",
+	".cjs",
+	".json"
+];
+function sourceKind(path) {
+	if (path.endsWith(".js") || path.endsWith(".mjs") || path.endsWith(".cjs")) return ts.ScriptKind.JS;
+	if (path.endsWith(".jsx")) return ts.ScriptKind.JSX;
+	if (path.endsWith(".tsx")) return ts.ScriptKind.TSX;
+	return ts.ScriptKind.TS;
+}
+function literalModule(node) {
+	return node !== void 0 && (ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node)) ? node.text : void 0;
+}
+function isImportMetaUrl(node) {
+	return node !== void 0 && ts.isPropertyAccessExpression(node) && node.name.text === "url" && ts.isMetaProperty(node.expression) && node.expression.keywordToken === ts.SyntaxKind.ImportKeyword;
+}
+function localReferences(path, text) {
+	const source = ts.createSourceFile(path, text, ts.ScriptTarget.Latest, true, sourceKind(path));
+	const values = /* @__PURE__ */ new Map();
+	const createRequireNames = /* @__PURE__ */ new Set(["createRequire"]);
+	const requireNames = /* @__PURE__ */ new Set(["require"]);
+	const add = (kind, specifier) => {
+		if (specifier.startsWith(".") || specifier.startsWith("#")) values.set(`${kind}:${specifier}`, {
+			kind,
+			specifier
+		});
+	};
+	function collectRequireAliases(node) {
+		if (ts.isImportDeclaration(node) && ts.isStringLiteral(node.moduleSpecifier) && (node.moduleSpecifier.text === "node:module" || node.moduleSpecifier.text === "module") && node.importClause?.namedBindings !== void 0 && ts.isNamedImports(node.importClause.namedBindings)) {
+			for (const element of node.importClause.namedBindings.elements) if ((element.propertyName?.text ?? element.name.text) === "createRequire") createRequireNames.add(element.name.text);
+		} else if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && node.initializer !== void 0 && ts.isCallExpression(node.initializer) && ts.isIdentifier(node.initializer.expression) && createRequireNames.has(node.initializer.expression.text)) requireNames.add(node.name.text);
+		ts.forEachChild(node, collectRequireAliases);
+	}
+	collectRequireAliases(source);
+	function visit(node) {
+		if ((ts.isImportDeclaration(node) || ts.isExportDeclaration(node)) && node.moduleSpecifier !== void 0 && ts.isStringLiteral(node.moduleSpecifier)) add("module", node.moduleSpecifier.text);
+		else if (ts.isImportEqualsDeclaration(node) && ts.isExternalModuleReference(node.moduleReference) && ts.isStringLiteral(node.moduleReference.expression)) add("module", node.moduleReference.expression.text);
+		else if (ts.isCallExpression(node) && node.arguments.length > 0 && (node.expression.kind === ts.SyntaxKind.ImportKeyword || ts.isIdentifier(node.expression) && requireNames.has(node.expression.text))) {
+			const specifier = literalModule(node.arguments[0]);
+			if (specifier !== void 0) add("module", specifier);
+		} else if (ts.isNewExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === "URL" && isImportMetaUrl(node.arguments?.[1])) {
+			const specifier = literalModule(node.arguments?.[0]);
+			if (specifier !== void 0) add("asset", specifier);
+		}
+		ts.forEachChild(node, visit);
+	}
+	visit(source);
+	return [...values.values()];
+}
+function externalPackage(specifier) {
+	if (specifier.startsWith(".") || specifier.startsWith("/") || specifier.startsWith("#") || specifier.startsWith("node:") || builtinModules.includes(specifier)) return void 0;
+	const parts = specifier.split("/");
+	return specifier.startsWith("@") ? parts.slice(0, 2).join("/") : parts[0];
+}
+function runtimeExternalPackages(path, text) {
+	const source = ts.createSourceFile(path, text, ts.ScriptTarget.Latest, true, sourceKind(path));
+	const packages = /* @__PURE__ */ new Set();
+	const createRequireNames = /* @__PURE__ */ new Set(["createRequire"]);
+	const requireNames = /* @__PURE__ */ new Set(["require"]);
+	const add = (specifier) => {
+		const name = externalPackage(specifier);
+		if (name !== void 0 && name.length > 0) packages.add(name);
+	};
+	function collectRequireAliases(node) {
+		if (ts.isImportDeclaration(node) && ts.isStringLiteral(node.moduleSpecifier) && (node.moduleSpecifier.text === "node:module" || node.moduleSpecifier.text === "module") && node.importClause?.namedBindings !== void 0 && ts.isNamedImports(node.importClause.namedBindings)) {
+			for (const element of node.importClause.namedBindings.elements) if ((element.propertyName?.text ?? element.name.text) === "createRequire") createRequireNames.add(element.name.text);
+		} else if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && node.initializer !== void 0 && ts.isCallExpression(node.initializer) && ts.isIdentifier(node.initializer.expression) && createRequireNames.has(node.initializer.expression.text)) requireNames.add(node.name.text);
+		ts.forEachChild(node, collectRequireAliases);
+	}
+	collectRequireAliases(source);
+	function visit(node) {
+		if (ts.isImportDeclaration(node) && ts.isStringLiteral(node.moduleSpecifier)) {
+			const clause = node.importClause;
+			const named = clause?.namedBindings;
+			const namedImportsAreTypeOnly = named !== void 0 && ts.isNamedImports(named) && named.elements.length > 0 && named.elements.every((element) => element.isTypeOnly);
+			if (clause === void 0 || !clause.isTypeOnly && (clause.name !== void 0 || !namedImportsAreTypeOnly)) add(node.moduleSpecifier.text);
+		} else if (ts.isExportDeclaration(node) && !node.isTypeOnly && node.moduleSpecifier !== void 0 && ts.isStringLiteral(node.moduleSpecifier)) add(node.moduleSpecifier.text);
+		else if (ts.isImportEqualsDeclaration(node) && !node.isTypeOnly && ts.isExternalModuleReference(node.moduleReference) && ts.isStringLiteral(node.moduleReference.expression)) add(node.moduleReference.expression.text);
+		else if (ts.isCallExpression(node) && node.arguments.length > 0 && (node.expression.kind === ts.SyntaxKind.ImportKeyword || ts.isIdentifier(node.expression) && requireNames.has(node.expression.text))) {
+			const specifier = literalModule(node.arguments[0]);
+			if (specifier !== void 0) add(specifier);
+		}
+		ts.forEachChild(node, visit);
+	}
+	visit(source);
+	return [...packages];
+}
+function inside(rootDir, path) {
+	const pathRelative = relative(rootDir, path);
+	return pathRelative === "" || pathRelative !== ".." && !pathRelative.startsWith(`..${process.platform === "win32" ? "\\" : "/"}`);
+}
+function sourceAlternates(base) {
+	const extension = extname(base);
+	const stem = extension.length > 0 ? base.slice(0, -extension.length) : base;
+	if (extension === ".js") return [`${stem}.ts`, `${stem}.tsx`];
+	if (extension === ".mjs") return [`${stem}.mts`, `${stem}.ts`];
+	if (extension === ".cjs") return [`${stem}.cts`, `${stem}.ts`];
+	if (extension === ".jsx") return [`${stem}.tsx`, `${stem}.ts`];
+	return [];
+}
+async function isFile(path) {
+	try {
+		return (await stat(path)).isFile();
+	} catch (error) {
+		if (error.code === "ENOENT") return false;
+		throw error;
+	}
+}
+function subpathImportTarget(rootDir, specifier, importsMap) {
+	const conditionValue = (value) => {
+		if (typeof value === "string") return value;
+		if (typeof value !== "object" || value === null) return void 0;
+		const record = value;
+		for (const condition of [
+			"import",
+			"node",
+			"default"
+		]) {
+			const candidate = conditionValue(record[condition]);
+			if (candidate !== void 0) return candidate;
+		}
+	};
+	const direct = conditionValue(importsMap[specifier]);
+	if (direct !== void 0) return resolve(rootDir, direct);
+	for (const [pattern, value] of Object.entries(importsMap)) {
+		const star = pattern.indexOf("*");
+		if (star === -1) continue;
+		const prefix = pattern.slice(0, star);
+		const suffix = pattern.slice(star + 1);
+		if (!specifier.startsWith(prefix) || !specifier.endsWith(suffix)) continue;
+		const wildcard = specifier.slice(prefix.length, specifier.length - suffix.length);
+		const target = conditionValue(value);
+		if (target !== void 0) return resolve(rootDir, target.replace("*", wildcard));
+	}
+}
+async function packageImportsMap(rootDir) {
+	try {
+		const parsed = JSON.parse(await readFile(join(rootDir, "package.json"), "utf8"));
+		return typeof parsed.imports === "object" && parsed.imports !== null ? parsed.imports : {};
+	} catch {
+		return {};
+	}
+}
+async function resolveModule(fromFile, specifier, rootDir, importsMap) {
+	if (specifier.startsWith("#")) {
+		const target = subpathImportTarget(rootDir, specifier, importsMap);
+		if (target === void 0) throw new Error(`cannot resolve subpath import ${JSON.stringify(specifier)} through the package "imports" map`);
+		return resolveModule(fromFile, relative(dirname(fromFile), target).startsWith(".") ? relative(dirname(fromFile), target) : `./${relative(dirname(fromFile), target)}`, rootDir, importsMap);
+	}
+	const base = resolve(dirname(fromFile), specifier);
+	const candidates = [
+		base,
+		...sourceAlternates(base),
+		...extname(base) === "" ? MODULE_EXTENSIONS.map((extension) => `${base}${extension}`) : [],
+		...MODULE_EXTENSIONS.map((extension) => join(base, `index${extension}`))
+	];
+	for (const candidate of [...new Set(candidates)]) {
+		if (!inside(rootDir, candidate)) throw new Error(`extension import escapes the Pi package: ${specifier} from ${fromFile}`);
+		if (await isFile(candidate)) return candidate;
+	}
+	throw new Error(`cannot resolve local extension import ${JSON.stringify(specifier)} from ${fromFile}`);
+}
+async function expandAsset(path, rootDir) {
+	if (!inside(rootDir, path)) throw new Error(`extension asset escapes the Pi package: ${path}`);
+	let info;
+	try {
+		info = await lstat(path);
+	} catch (error) {
+		if (error.code !== "ENOENT") throw error;
+		for (const alternate of sourceAlternates(path)) if (await isFile(alternate)) return [alternate];
+		throw error;
+	}
+	if (info.isSymbolicLink()) throw new Error(`refusing to copy symbolic link from Pi package: ${path}`);
+	if (info.isFile()) return [path];
+	if (!info.isDirectory()) return [];
+	const output = [];
+	for (const entry of await readdir(path)) output.push(...await expandAsset(join(path, entry), rootDir));
+	return output;
+}
+async function collectLocalClosure(rootDir, entries) {
+	const queue = entries.map((path) => resolve(path));
+	const closure = /* @__PURE__ */ new Set();
+	const issues = [];
+	const importsMap = await packageImportsMap(rootDir);
+	while (queue.length > 0) {
+		const source = queue.shift();
+		if (closure.has(source)) continue;
+		if (!inside(rootDir, source)) throw new Error(`extension source escapes the Pi package: ${source}`);
+		const info = await lstat(source);
+		if (info.isSymbolicLink()) throw new Error(`refusing to copy symbolic link from Pi package: ${source}`);
+		if (!info.isFile()) throw new Error(`extension closure contains a non-file path: ${source}`);
+		closure.add(source);
+		if (!SCRIPT_EXTENSIONS.has(extname(source))) continue;
+		const text = await readFile(source, "utf8");
+		for (const reference of localReferences(source, text)) try {
+			if (reference.kind === "module") queue.push(await resolveModule(source, reference.specifier, rootDir, importsMap));
+			else queue.push(...await expandAsset(resolve(dirname(source), reference.specifier), rootDir));
+		} catch (error) {
+			issues.push({
+				file: source,
+				kind: reference.kind,
+				specifier: reference.specifier,
+				detail: error instanceof Error ? error.message : String(error)
+			});
+		}
+	}
+	return {
+		files: [...closure].sort(),
+		issues
+	};
+}
+//#endregion
+//#region src/analyzer.ts
+function literalText(node) {
+	return node !== void 0 && (ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node)) ? node.text : void 0;
+}
+function hasModifier(node, kind) {
+	return ts.canHaveModifiers(node) && ts.getModifiers(node)?.some((modifier) => modifier.kind === kind) === true;
+}
+function parameterIdentifier(node) {
+	const parameter = node.parameters[0];
+	return parameter !== void 0 && ts.isIdentifier(parameter.name) ? parameter.name.text : void 0;
+}
+function extensionApiReceivers(source) {
+	const receivers = /* @__PURE__ */ new Set();
+	const functions = /* @__PURE__ */ new Map();
+	function index(node) {
+		if (ts.isFunctionDeclaration(node) && node.name !== void 0) functions.set(node.name.text, node);
+		if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && node.initializer !== void 0 && (ts.isArrowFunction(node.initializer) || ts.isFunctionExpression(node.initializer))) functions.set(node.name.text, node.initializer);
+		if (ts.isParameter(node) && node.type !== void 0 && /(?:^|\.)ExtensionAPI\b/u.test(node.type.getText(source)) && ts.isIdentifier(node.name)) receivers.add(node.name.text);
+		if (ts.isParameter(node) && ts.isIdentifier(node.name) && /^(?:pi|extensionApi)$/iu.test(node.name.text)) receivers.add(node.name.text);
+		ts.forEachChild(node, index);
+	}
+	index(source);
+	for (const statement of source.statements) {
+		if (ts.isFunctionDeclaration(statement) && hasModifier(statement, ts.SyntaxKind.ExportKeyword) && hasModifier(statement, ts.SyntaxKind.DefaultKeyword)) {
+			const name = parameterIdentifier(statement);
+			if (name !== void 0) receivers.add(name);
+		}
+		if (ts.isExportAssignment(statement)) {
+			const expression = statement.expression;
+			if (ts.isArrowFunction(expression) || ts.isFunctionExpression(expression)) {
+				const name = parameterIdentifier(expression);
+				if (name !== void 0) receivers.add(name);
+			} else if (ts.isIdentifier(expression)) {
+				const candidate = functions.get(expression.text);
+				if (candidate !== void 0) {
+					const name = parameterIdentifier(candidate);
+					if (name !== void 0) receivers.add(name);
+				}
+			}
+		}
+		if (ts.isExportDeclaration(statement) && statement.moduleSpecifier === void 0 && statement.exportClause !== void 0 && ts.isNamedExports(statement.exportClause)) for (const element of statement.exportClause.elements) {
+			if (element.name.text !== "default" || element.propertyName === void 0 || !ts.isIdentifier(element.propertyName)) continue;
+			const candidate = functions.get(element.propertyName.text);
+			if (candidate !== void 0) {
+				const name = parameterIdentifier(candidate);
+				if (name !== void 0) receivers.add(name);
+			}
+		}
+	}
+	return receivers;
+}
+function extensionApiProperties(source, receivers) {
+	const properties = /* @__PURE__ */ new Set();
+	function visit(node) {
+		if ((ts.isPropertyDeclaration(node) || ts.isParameter(node)) && ts.isIdentifier(node.name)) {
+			if (node.type !== void 0 && /(?:^|\.)(?:Pi)?ExtensionAPI\b/u.test(node.type.getText(source)) || /^(?:pi|extensionApi)$/iu.test(node.name.text)) properties.add(node.name.text);
+		} else if (ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.EqualsToken && ts.isPropertyAccessExpression(node.left) && node.left.expression.kind === ts.SyntaxKind.ThisKeyword && ts.isIdentifier(node.right) && receivers.has(node.right.text)) properties.add(node.left.name.text);
+		ts.forEachChild(node, visit);
+	}
+	visit(source);
+	return properties;
+}
+function enclosingFunctionName(node) {
+	const parent = node.parent;
+	if (ts.isMethodDeclaration(parent) && parent.name !== void 0) return parent.name.getText();
+	if ((ts.isArrowFunction(parent) || ts.isFunctionExpression(parent)) && ts.isPropertyAssignment(parent.parent)) return parent.parent.name.getText();
+}
+function extensionContextReceivers(source) {
+	const receivers = /* @__PURE__ */ new Set();
+	function visit(node) {
+		if (ts.isParameter(node) && ts.isIdentifier(node.name)) {
+			const typedContext = node.type !== void 0 && /(?:^|\.)(?:Extension|ExtensionCommand|ToolExecution)Context\b/u.test(node.type.getText(source));
+			const conventionalHandlerContext = /^(?:ctx|context)$/iu.test(node.name.text) && /^(?:execute|handler)$/u.test(enclosingFunctionName(node) ?? "");
+			if (typedContext || conventionalHandlerContext) receivers.add(node.name.text);
+		}
+		ts.forEachChild(node, visit);
+	}
+	visit(source);
+	return receivers;
+}
+const PI_SHIMMED_PACKAGES = /* @__PURE__ */ new Set([
+	...PI_CODING_AGENT_PACKAGES,
+	...PI_TUI_PACKAGES,
+	...PI_AI_PACKAGES
+]);
+const PI_HOST_PACKAGES = /* @__PURE__ */ new Set([
+	...PI_SHIMMED_PACKAGES,
+	"typebox",
+	"@sinclair/typebox"
+]);
+function dependencyNames(packageJson) {
+	const names = /* @__PURE__ */ new Set();
+	for (const field of [
+		"dependencies",
+		"optionalDependencies",
+		"peerDependencies"
+	]) {
+		const value = packageJson[field];
+		if (typeof value !== "object" || value === null || Array.isArray(value)) continue;
+		for (const [name, specifier] of Object.entries(value)) if (typeof specifier === "string") names.add(name);
+	}
+	return names;
+}
+function pushFinding(findings, rootDir, file, source, node, capability, level, detail) {
+	const position = source.getLineAndCharacterOfPosition(node.getStart(source));
+	findings.push({
+		capability,
+		level,
+		file: relative(rootDir, file).replaceAll("\\", "/"),
+		line: position.line + 1,
+		detail
+	});
+}
+async function analyzeExtension(rootDir, file) {
+	const text = await readFile(file, "utf8");
+	const source = ts.createSourceFile(file, text, ts.ScriptTarget.Latest, true, sourceKind(file));
+	const findings = [];
+	const receivers = extensionApiReceivers(source);
+	const apiProperties = extensionApiProperties(source, receivers);
+	const contextReceivers = extensionContextReceivers(source);
+	const methodAliases = /* @__PURE__ */ new Map();
+	const eventBusAliases = /* @__PURE__ */ new Set();
+	const uiAliases = /* @__PURE__ */ new Set();
+	function reportHostImport(packageName, importedName, node) {
+		const matched = ruleForHostImport(packageName, importedName);
+		if (matched === void 0) {
+			pushFinding(findings, rootDir, file, source, node, `host-import(${packageName}:${importedName})`, "unsupported", `The pi2dsh host shim does not export ${JSON.stringify(importedName)} from ${JSON.stringify(packageName)}.`);
+			return;
+		}
+		pushFinding(findings, rootDir, file, source, node, `host-import(${packageName}:${importedName})`, matched.level, matched.detail);
+	}
+	for (const statement of source.statements) if (ts.isImportDeclaration(statement) && ts.isStringLiteral(statement.moduleSpecifier) && PI_SHIMMED_PACKAGES.has(statement.moduleSpecifier.text)) {
+		const packageName = statement.moduleSpecifier.text;
+		const clause = statement.importClause;
+		if (clause === void 0) {
+			reportHostImport(packageName, "<side-effect>", statement);
+			continue;
+		}
+		if (clause.isTypeOnly) continue;
+		if (clause.name !== void 0) reportHostImport(packageName, "default", clause.name);
+		if (clause.namedBindings !== void 0 && ts.isNamespaceImport(clause.namedBindings)) reportHostImport(packageName, "*", clause.namedBindings);
+		else if (clause.namedBindings !== void 0) {
+			for (const element of clause.namedBindings.elements) if (!element.isTypeOnly) reportHostImport(packageName, element.propertyName?.text ?? element.name.text, element);
+		}
+	} else if (ts.isExportDeclaration(statement) && !statement.isTypeOnly && statement.moduleSpecifier !== void 0 && ts.isStringLiteral(statement.moduleSpecifier) && PI_HOST_PACKAGES.has(statement.moduleSpecifier.text)) {
+		const packageName = statement.moduleSpecifier.text;
+		if (statement.exportClause === void 0 || ts.isNamespaceExport(statement.exportClause)) reportHostImport(packageName, "*", statement);
+		else for (const element of statement.exportClause.elements) if (!element.isTypeOnly) reportHostImport(packageName, element.propertyName?.text ?? element.name.text, element);
+	} else if (ts.isImportEqualsDeclaration(statement) && !statement.isTypeOnly && ts.isExternalModuleReference(statement.moduleReference) && ts.isStringLiteral(statement.moduleReference.expression) && PI_HOST_PACKAGES.has(statement.moduleReference.expression.text)) reportHostImport(statement.moduleReference.expression.text, "*", statement);
+	const declarations = [];
+	const isApiReceiver = (node) => ts.isIdentifier(node) && receivers.has(node.text) || ts.isPropertyAccessExpression(node) && node.expression.kind === ts.SyntaxKind.ThisKeyword && apiProperties.has(node.name.text);
+	function collectDeclarations(node) {
+		if (ts.isVariableDeclaration(node)) declarations.push(node);
+		ts.forEachChild(node, collectDeclarations);
+	}
+	collectDeclarations(source);
+	for (let pass = 0; pass < declarations.length + 1; pass += 1) {
+		let changed = false;
+		for (const declaration of declarations) {
+			const initializer = declaration.initializer;
+			if (initializer === void 0) continue;
+			if (ts.isIdentifier(declaration.name) && isApiReceiver(initializer)) {
+				if (!receivers.has(declaration.name.text)) {
+					receivers.add(declaration.name.text);
+					changed = true;
+				}
+			}
+			if (ts.isIdentifier(declaration.name) && ts.isIdentifier(initializer) && contextReceivers.has(initializer.text)) {
+				if (!contextReceivers.has(declaration.name.text)) {
+					contextReceivers.add(declaration.name.text);
+					changed = true;
+				}
+			}
+			if (ts.isIdentifier(declaration.name) && ts.isPropertyAccessExpression(initializer) && initializer.name.text === "ui" && ts.isIdentifier(initializer.expression) && contextReceivers.has(initializer.expression.text) && !uiAliases.has(declaration.name.text)) {
+				uiAliases.add(declaration.name.text);
+				changed = true;
+			}
+			if (ts.isIdentifier(declaration.name) && ts.isPropertyAccessExpression(initializer) && isApiReceiver(initializer.expression)) {
+				if (initializer.name.text === "events") {
+					if (!eventBusAliases.has(declaration.name.text)) {
+						eventBusAliases.add(declaration.name.text);
+						changed = true;
+					}
+				} else if (!methodAliases.has(declaration.name.text)) {
+					methodAliases.set(declaration.name.text, initializer.name.text);
+					changed = true;
+				}
+			}
+			if (ts.isObjectBindingPattern(declaration.name) && isApiReceiver(initializer)) for (const element of declaration.name.elements) {
+				if (!ts.isIdentifier(element.name)) continue;
+				const method = element.propertyName !== void 0 && ts.isIdentifier(element.propertyName) ? element.propertyName.text : element.name.text;
+				if (method === "events") {
+					if (!eventBusAliases.has(element.name.text)) {
+						eventBusAliases.add(element.name.text);
+						changed = true;
+					}
+				} else if (!methodAliases.has(element.name.text)) {
+					methodAliases.set(element.name.text, method);
+					changed = true;
+				}
+			}
+		}
+		if (!changed) break;
+	}
+	function reportMethod(method, args, node) {
+		if (method === "on") {
+			const event = literalText(args[0]);
+			if (event === void 0) pushFinding(findings, rootDir, file, source, node, "on(<dynamic>)", "unsupported", "Dynamic event names cannot be audited or mapped safely.");
+			else {
+				const rule = ruleForEvent(event);
+				pushFinding(findings, rootDir, file, source, node, `on(${event})`, rule.level, rule.detail);
+			}
+			return;
+		}
+		const rule = ruleForApi(method);
+		if (rule === void 0) {
+			pushFinding(findings, rootDir, file, source, node, method, "unsupported", `Unknown ExtensionAPI method ${JSON.stringify(method)} cannot be audited or mapped safely.`);
+			return;
+		}
+		pushFinding(findings, rootDir, file, source, node, method, rule.level, rule.detail);
+	}
+	function reportEventBus(method, node) {
+		const rule = ruleForApi("events");
+		if ((method === "on" || method === "emit") && rule !== void 0) pushFinding(findings, rootDir, file, source, node, `events.${method}`, rule.level, rule.detail);
+		else pushFinding(findings, rootDir, file, source, node, `events.${method}`, "unsupported", `Unknown Pi event-bus method ${JSON.stringify(method)} cannot be mapped safely.`);
+	}
+	function reportContext(property, node) {
+		const matched = ruleForContextProperty(property);
+		if (matched === void 0) pushFinding(findings, rootDir, file, source, node, `ctx.${property}`, "unsupported", `Unknown Pi extension-context property ${JSON.stringify(property)} cannot be audited or mapped safely.`);
+		else pushFinding(findings, rootDir, file, source, node, `ctx.${property}`, matched.level, matched.detail);
+	}
+	function reportUiContext(property, node) {
+		const matched = ruleForUiContextProperty(property);
+		if (matched === void 0) pushFinding(findings, rootDir, file, source, node, `ctx.ui.${property}`, "unsupported", `Unknown Pi UI-context property ${JSON.stringify(property)} cannot be audited or mapped safely.`);
+		else pushFinding(findings, rootDir, file, source, node, `ctx.ui.${property}`, matched.level, matched.detail);
+	}
+	function visit(node) {
+		if (ts.isCallExpression(node) && ts.isIdentifier(node.expression)) {
+			const method = methodAliases.get(node.expression.text);
+			if (method !== void 0) reportMethod(method, node.arguments, node);
+		} else if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression)) {
+			const target = node.expression.expression;
+			if (isApiReceiver(target)) reportMethod(node.expression.name.text, node.arguments, node);
+			else if (ts.isIdentifier(target) && eventBusAliases.has(target.text)) reportEventBus(node.expression.name.text, node);
+			else if (ts.isPropertyAccessExpression(target) && target.name.text === "events" && isApiReceiver(target.expression)) reportEventBus(node.expression.name.text, node);
+		} else if (ts.isCallExpression(node) && ts.isElementAccessExpression(node.expression) && isApiReceiver(node.expression.expression)) {
+			const method = literalText(node.expression.argumentExpression);
+			if (method === void 0) pushFinding(findings, rootDir, file, source, node, "<dynamic-api-method>", "unsupported", "Dynamic ExtensionAPI method access cannot be audited or mapped safely.");
+			else reportMethod(method, node.arguments, node);
+		}
+		if (ts.isPropertyAccessExpression(node)) {
+			const target = node.expression;
+			if (ts.isPropertyAccessExpression(target) && target.name.text === "ui" && ts.isIdentifier(target.expression) && contextReceivers.has(target.expression.text)) reportUiContext(node.name.text, node);
+			else if (ts.isIdentifier(target) && uiAliases.has(target.text)) reportUiContext(node.name.text, node);
+			else if (ts.isIdentifier(target) && contextReceivers.has(target.text) && node.name.text !== "ui") reportContext(node.name.text, node);
+		} else if (ts.isElementAccessExpression(node) && ts.isIdentifier(node.expression) && contextReceivers.has(node.expression.text)) {
+			const property = literalText(node.argumentExpression);
+			if (property === void 0) pushFinding(findings, rootDir, file, source, node, "ctx.<dynamic>", "unsupported", "Dynamic Pi extension-context access cannot be audited or mapped safely.");
+			else if (property !== "ui") reportContext(property, node);
+		}
+		ts.forEachChild(node, visit);
+	}
+	visit(source);
+	return findings;
+}
+async function analyzePackage(pkg) {
+	const extensionClosure = await collectLocalClosure(pkg.rootDir, pkg.resources.extensions);
+	const findings = (await Promise.all(extensionClosure.files.filter((file) => SCRIPT_EXTENSIONS.has(extname(file))).map((file) => analyzeExtension(pkg.rootDir, file)))).flat();
+	if (pkg.resources.extensions.length > 0 && findings.length === 0) findings.push({
+		capability: "static-audit",
+		level: "unsupported",
+		file: pkg.resources.extensions.map((file) => relative(pkg.rootDir, file).replaceAll("\\", "/")).join(", "),
+		line: 1,
+		detail: "No ExtensionAPI use was statically proven across the local module closure; conversion fails closed instead of claiming compatibility."
+	});
+	for (const issue of extensionClosure.issues) findings.push({
+		capability: `${issue.kind}(${issue.specifier})`,
+		level: "fatal",
+		file: relative(pkg.rootDir, issue.file).replaceAll("\\", "/"),
+		line: 1,
+		detail: `The local extension closure is incomplete: ${issue.detail}`
+	});
+	const declaredDependencies = dependencyNames(pkg.packageJson);
+	for (const file of extensionClosure.files.filter((candidate) => SCRIPT_EXTENSIONS.has(extname(candidate)))) {
+		const text = await readFile(file, "utf8");
+		for (const packageName of runtimeExternalPackages(file, text)) {
+			if (PI_HOST_PACKAGES.has(packageName) || declaredDependencies.has(packageName)) continue;
+			findings.push({
+				capability: `undeclared-runtime-dependency(${packageName})`,
+				level: "fatal",
+				file: relative(pkg.rootDir, file).replaceAll("\\", "/"),
+				line: 1,
+				detail: `The extension imports ${JSON.stringify(packageName)} at runtime, but the Pi package does not declare it as a dependency.`
+			});
+		}
+	}
+	const resourceFinding = (file, capability, level, detail) => ({
+		capability,
+		level,
+		file: relative(pkg.rootDir, file).replaceAll("\\", "/"),
+		line: 1,
+		detail
+	});
+	for (const file of pkg.resources.skills.filter((path) => basename(path) === "SKILL.md" || path.endsWith(".md"))) findings.push(resourceFinding(file, "skill", "full", "Copied as a DSH filesystem skill with its resource directory intact."));
+	for (const file of pkg.resources.prompts) findings.push(resourceFinding(file, "prompt", "full", "Registered as a DSH slash command with Pi-compatible argument expansion."));
+	for (const file of pkg.resources.themes) findings.push(resourceFinding(file, "theme", "unsupported", "Pi terminal themes have no effect in DSH Web or headless surfaces."));
+	findings.sort((left, right) => left.file.localeCompare(right.file) || left.line - right.line || left.capability.localeCompare(right.capability));
+	const summary = {
+		full: 0,
+		partial: 0,
+		unsupported: 0,
+		fatal: 0
+	};
+	for (const finding of findings) summary[finding.level] += 1;
+	const verdict = summary.fatal > 0 ? "blocked" : summary.partial > 0 || summary.unsupported > 0 ? "review" : "ready";
+	return {
+		schemaVersion: 1,
+		package: pkg.identity,
+		verdict,
+		summary,
+		resources: {
+			extensions: pkg.resources.extensions.map((file) => relative(pkg.rootDir, file).replaceAll("\\", "/")),
+			skills: pkg.resources.skills.map((file) => relative(pkg.rootDir, file).replaceAll("\\", "/")),
+			prompts: pkg.resources.prompts.map((file) => relative(pkg.rootDir, file).replaceAll("\\", "/")),
+			themes: pkg.resources.themes.map((file) => relative(pkg.rootDir, file).replaceAll("\\", "/"))
+		},
+		findings
+	};
+}
+//#endregion
+//#region src/generator.ts
+const SHIMMED_PI_HOST_PACKAGES = /* @__PURE__ */ new Set([
+	"@earendil-works/pi-coding-agent",
+	"@mariozechner/pi-coding-agent",
+	"@earendil-works/pi-tui",
+	"@mariozechner/pi-tui",
+	"@earendil-works/pi-ai",
+	"@mariozechner/pi-ai",
+	"typebox",
+	"@sinclair/typebox"
+]);
+function packageSlug(name) {
+	return name.replace(/^@/u, "").replaceAll("/", "-").replace(/[^a-zA-Z0-9._-]+/gu, "-").toLowerCase().replace(/^-+|-+$/gu, "") || "package";
+}
+function stringRecord$1(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return {};
+	return Object.fromEntries(Object.entries(value).filter((entry) => typeof entry[1] === "string"));
+}
+async function assertEmptyOrMissing(path) {
+	try {
+		if (!(await stat(path)).isDirectory()) throw new Error(`output exists and is not a directory: ${path}`);
+		if ((await readdir(path)).length > 0) throw new Error(`output directory is not empty: ${path}`);
+	} catch (error) {
+		if (error.code !== "ENOENT") throw error;
+	}
+}
+function parseFrontmatter(text) {
+	const normalized = text.replace(/\r\n?/gu, "\n");
+	if (!normalized.startsWith("---")) return {
+		attributes: {},
+		body: normalized
+	};
+	const endIndex = normalized.indexOf("\n---", 3);
+	if (endIndex === -1) return {
+		attributes: {},
+		body: normalized
+	};
+	const raw = parse(normalized.slice(4, endIndex));
+	return {
+		attributes: typeof raw === "object" && raw !== null && !Array.isArray(raw) ? stringRecord$1(raw) : {},
+		body: normalized.slice(endIndex + 4).trim()
+	};
+}
+async function assertNoSymlinks(path) {
+	const info = await lstat(path);
+	if (info.isSymbolicLink()) throw new Error(`refusing to copy symbolic link from Pi package: ${path}`);
+	if (!info.isDirectory()) return;
+	for (const entry of await readdir(path)) await assertNoSymlinks(join(path, entry));
+}
+async function copyExtensions(pkg, outDir) {
+	const copied = [];
+	const runtimePackages = /* @__PURE__ */ new Set();
+	const closure = await collectLocalClosure(pkg.rootDir, pkg.resources.extensions);
+	if (closure.issues.length > 0) throw new Error(`cannot snapshot extension closure:\n${closure.issues.map((issue) => `- ${issue.file}: ${issue.detail}`).join("\n")}`);
+	for (const source of closure.files) {
+		if (SCRIPT_EXTENSIONS.has(extname(source))) {
+			const text = await readFile(source, "utf8");
+			for (const packageName of runtimeExternalPackages(source, text)) runtimePackages.add(packageName);
+		}
+		const targetRelative = `vendor/${relative(pkg.rootDir, source).replaceAll("\\", "/")}`;
+		const target = join(outDir, targetRelative);
+		await mkdir(dirname(target), { recursive: true });
+		await cp(source, target, { dereference: false });
+		if (pkg.resources.extensions.map((entry) => resolve(entry)).includes(source)) copied.push(targetRelative);
+	}
+	for (const source of pkg.resources.skills) {
+		if (!SCRIPT_EXTENSIONS.has(extname(source))) continue;
+		const text = await readFile(source, "utf8");
+		for (const packageName of runtimeExternalPackages(source, text)) runtimePackages.add(packageName);
+	}
+	return {
+		entries: copied,
+		runtimePackages
+	};
+}
+async function copySkills(pkg, outDir) {
+	const entryFiles = pkg.resources.skills.filter((file) => basename(file) === "SKILL.md" || file.endsWith(".md"));
+	if (entryFiles.length === 0) return [];
+	const names = /* @__PURE__ */ new Set();
+	for (const entry of entryFiles) {
+		const isBundle = basename(entry) === "SKILL.md";
+		let name = isBundle ? basename(dirname(entry)) : basename(entry, ".md");
+		if (names.has(name)) {
+			const candidate = `${basename(dirname(isBundle ? dirname(entry) : entry))}-${name}`.replace(/[^a-zA-Z0-9._-]+/gu, "-");
+			name = names.has(candidate) ? `${candidate}-${names.size}` : candidate;
+		}
+		names.add(name);
+		const target = join(outDir, "skills", isBundle ? name : `${name}.md`);
+		await mkdir(dirname(target), { recursive: true });
+		const source = isBundle ? dirname(entry) : entry;
+		await assertNoSymlinks(source);
+		await cp(source, target, {
+			recursive: isBundle,
+			dereference: false
+		});
+	}
+	return ["skills"];
+}
+async function copyPrompts(pkg, outDir) {
+	const prompts = [];
+	const names = /* @__PURE__ */ new Set();
+	for (const source of pkg.resources.prompts) {
+		const name = basename(source, ".md").toLowerCase().replace(/[^a-z0-9_-]+/gu, "-");
+		if (names.has(name)) throw new Error(`prompt command name collision while flattening Pi package: ${name}`);
+		names.add(name);
+		const targetRelative = `prompts/${name}.md`;
+		const target = join(outDir, targetRelative);
+		await mkdir(dirname(target), { recursive: true });
+		await assertNoSymlinks(source);
+		await cp(source, target, { dereference: false });
+		const { attributes, body } = parseFrontmatter(await readFile(source, "utf8"));
+		const firstLine = body.split(/\r?\n/u).map((line) => line.trim()).find(Boolean);
+		prompts.push({
+			name,
+			description: attributes.description ?? firstLine ?? `Run migrated Pi prompt ${name}`,
+			...attributes["argument-hint"] !== void 0 ? { argumentHint: attributes["argument-hint"] } : {},
+			path: targetRelative
+		});
+	}
+	return prompts;
+}
+async function copyNotices(pkg, outDir) {
+	const copied = [];
+	for (const entry of await readdir(pkg.rootDir)) {
+		if (!/^(?:licen[cs]e|notice|copying)(?:[._-].*)?$/iu.test(entry)) continue;
+		const source = join(pkg.rootDir, entry);
+		const info = await lstat(source);
+		if (info.isSymbolicLink()) throw new Error(`refusing to copy symbolic link from Pi package: ${source}`);
+		if (!info.isFile()) continue;
+		await cp(source, join(outDir, entry), { dereference: false });
+		copied.push(entry);
+	}
+	return copied.sort();
+}
+function generatedPackageJson(pkg, generatedName, runtimeSpec, runtimePackages, hasSkills) {
+	const declaredDependencies = {
+		...stringRecord$1(pkg.packageJson.dependencies),
+		...stringRecord$1(pkg.packageJson.optionalDependencies),
+		...stringRecord$1(pkg.packageJson.peerDependencies)
+	};
+	const externalRuntimePackages = [...runtimePackages].filter((name) => !SHIMMED_PI_HOST_PACKAGES.has(name));
+	const missing = externalRuntimePackages.filter((name) => declaredDependencies[name] === void 0);
+	if (missing.length > 0) throw new Error(`runtime dependencies are imported but not declared by the Pi package: ${missing.join(", ")}`);
+	const declaredRuntime = {
+		...stringRecord$1(pkg.packageJson.dependencies),
+		...stringRecord$1(pkg.packageJson.optionalDependencies)
+	};
+	const dependencies = {
+		...Object.fromEntries(Object.entries(declaredRuntime).filter(([name]) => !SHIMMED_PI_HOST_PACKAGES.has(name))),
+		...Object.fromEntries(externalRuntimePackages.sort().map((name) => [name, declaredDependencies[name]])),
+		...runtimeSpec === void 0 ? {
+			jiti: "^2.7.0",
+			"get-east-asian-width": "^1.6.0",
+			marked: "^16.4.1",
+			typebox: "^1.0.4"
+		} : {},
+		...hasSkills ? { "@deepseek-ai/dsh-skill-filesystem": "^0.1.0-rc.6" } : {},
+		...runtimeSpec !== void 0 ? { pi2dsh: runtimeSpec } : {}
+	};
+	const remapImports = (value) => {
+		if (typeof value === "string") return value.startsWith("./") ? `./vendor/${value.slice(2)}` : value;
+		if (typeof value === "object" && value !== null && !Array.isArray(value)) return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, remapImports(entry)]));
+		return value;
+	};
+	const sourceImports = pkg.packageJson.imports;
+	return {
+		name: generatedName,
+		version: pkg.identity.version,
+		description: `DeepSeek Harness adapter generated from ${pkg.identity.name}`,
+		type: "module",
+		main: "./index.js",
+		...typeof sourceImports === "object" && sourceImports !== null ? { imports: remapImports(sourceImports) } : {},
+		files: [
+			"index.js",
+			"cordis.patch.yml",
+			"pi2dsh.manifest.json",
+			"pi2dsh.report.json",
+			"README.md",
+			"LICENSE*",
+			"NOTICE*",
+			"COPYING*",
+			"PI2DSH-LICENSE",
+			"runtime",
+			"vendor",
+			"skills",
+			"prompts"
+		],
+		dependencies,
+		...runtimeSpec === void 0 ? { peerDependencies: {
+			"@deepseek-ai/dsh-llm": "^0.1.0-rc.6",
+			"@deepseek-ai/dsh-system-prompt": "^0.1.0-rc.6"
+		} } : {},
+		keywords: [
+			"dsh-plugin",
+			"deepseek-harness",
+			"pi-package",
+			"pi2dsh"
+		],
+		license: typeof pkg.packageJson.license === "string" ? pkg.packageJson.license : "UNLICENSED",
+		dsh: { bundle: { patch: "./cordis.patch.yml" } }
+	};
+}
+function generatedReadme(pkg, packageName, report) {
+	return `# ${packageName}\n\nGenerated by [pi2dsh](https://github.com/weijiafu14/pi2dsh) from \`${pkg.identity.name}@${pkg.identity.version}\`.\n\nCompatibility verdict: **${report.verdict}** (full ${report.summary.full}, partial ${report.summary.partial}, unsupported ${report.summary.unsupported}).\n\nReview \`pi2dsh.report.json\` before installation. This bundle executes the original Pi extension source and should only be installed when that source is trusted.\n\nInstall with DeepSeek Harness (keep the \`file:\` prefix so pnpm installs this bundle's dependencies instead of creating a bare link):\n\n\`\`\`sh\ndsh plugin --profile headless add file:$PWD\ndsh --profile headless --dump-config\n\`\`\`\n`;
+}
+function pluginSource(manifest, runtimeImport) {
+	const injections = ["tools", "systemPrompt"];
+	if (manifest.prompts.length > 0 || manifest.report?.findings.some((item) => item.capability === "registerCommand") === true) injections.push("commands");
+	if (manifest.skillDirs.length > 0) injections.push("skills");
+	return `import { applyPiPackage } from ${JSON.stringify(runtimeImport)}\n\nexport const name = ${JSON.stringify(`pi2dsh:${packageSlug(manifest.package.name)}`)}\nexport const inject = ${JSON.stringify(injections)}\n\nconst manifest = ${JSON.stringify(manifest, null, 2)}\n\nexport async function apply(ctx, config = {}) {\n  await applyPiPackage(ctx, { rootUrl: new URL('.', import.meta.url), manifest, config })\n}\n`;
+}
+async function firstExisting(paths) {
+	for (const path of paths) try {
+		await stat(path);
+		return path;
+	} catch {}
+	throw new Error(`cannot locate pi2dsh runtime artifact; tried: ${paths.join(", ")}`);
+}
+async function copyEmbeddedRuntime(outDir) {
+	const moduleDir = dirname(fileURLToPath(import.meta.url));
+	const runtimeSource = await firstExisting([join(moduleDir, "runtime.mjs"), join(moduleDir, "../dist/runtime.mjs")]);
+	const runtimeRoot = dirname(runtimeSource);
+	const targetRoot = join(outDir, "runtime");
+	await mkdir(targetRoot, { recursive: true });
+	for (const entry of await readdir(runtimeRoot)) if (entry.endsWith(".mjs")) await cp(join(runtimeRoot, entry), join(targetRoot, entry));
+	for (const sub of ["compat", join("compat", "vendor")]) {
+		const sourceDir = join(runtimeRoot, sub);
+		try {
+			const entries = await readdir(sourceDir);
+			await mkdir(join(targetRoot, sub), { recursive: true });
+			for (const entry of entries) if (entry.endsWith(".mjs")) await cp(join(sourceDir, entry), join(targetRoot, sub, entry));
+		} catch {}
+	}
+	await cp(join(targetRoot, "runtime.mjs"), join(targetRoot, "pi2dsh-runtime.mjs"));
+	const license = await firstExisting([join(moduleDir, "../LICENSE"), join(moduleDir, "../../LICENSE")]);
+	await cp(license, join(outDir, "PI2DSH-LICENSE"));
+}
+function patchSource(generatedName, slug) {
+	return `- insert:\n    - id: pi2dsh-${slug}\n      name: ${JSON.stringify(generatedName)}\n`;
+}
+function enforceReport(report, options) {
+	if (report.summary.fatal > 0) throw new Error(`conversion blocked: ${report.summary.fatal} fatal finding(s) — the bundle cannot be built or trusted; run inspect for details`);
+	if (options.strict && (report.summary.partial > 0 || report.summary.unsupported > 0)) throw new Error("strict conversion requires every detected Pi API use to have full compatibility");
+}
+async function generateBundle(pkg, options) {
+	const outDir = resolve(options.outDir);
+	const report = await analyzePackage(pkg);
+	enforceReport(report, options);
+	await assertEmptyOrMissing(outDir);
+	await mkdir(outDir, { recursive: true });
+	const slug = packageSlug(pkg.identity.name);
+	const packageName = `dsh-pi-${slug}`;
+	const extensionSnapshot = await copyExtensions(pkg, outDir);
+	const skillDirs = await copySkills(pkg, outDir);
+	const prompts = await copyPrompts(pkg, outDir);
+	await copyNotices(pkg, outDir);
+	const manifest = {
+		schemaVersion: 1,
+		package: pkg.identity,
+		extensions: extensionSnapshot.entries,
+		skillDirs,
+		prompts,
+		report
+	};
+	const runtimeSpec = options.runtimeSpec;
+	if (runtimeSpec === void 0) await copyEmbeddedRuntime(outDir);
+	await Promise.all([
+		writeFile(join(outDir, "package.json"), `${JSON.stringify(generatedPackageJson(pkg, packageName, runtimeSpec, extensionSnapshot.runtimePackages, skillDirs.length > 0), null, 2)}\n`),
+		writeFile(join(outDir, "pi2dsh.manifest.json"), `${JSON.stringify(manifest, null, 2)}\n`),
+		writeFile(join(outDir, "pi2dsh.report.json"), `${JSON.stringify(report, null, 2)}\n`),
+		writeFile(join(outDir, "index.js"), pluginSource(manifest, runtimeSpec === void 0 ? "./runtime/pi2dsh-runtime.mjs" : "pi2dsh/runtime")),
+		writeFile(join(outDir, "cordis.patch.yml"), patchSource(packageName, slug)),
+		writeFile(join(outDir, "README.md"), generatedReadme(pkg, packageName, report))
+	]);
+	return {
+		outDir,
+		report,
+		packageName
+	};
+}
+//#endregion
+//#region src/mcp-config.ts
+/** Pi's documented config precedence, lowest to highest. */
+function piMcpConfigPaths(cwd) {
+	const home = homedir();
+	return [
+		join(home, ".config", "mcp", "mcp.json"),
+		join(home, ".agents", "mcp.json"),
+		join(home, ".agents", "mcp", "mcp.json"),
+		join(getAgentDir(), "mcp.json"),
+		join(cwd, ".mcp.json"),
+		join(cwd, ".pi", "mcp.json")
+	];
+}
+function stringRecord(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return void 0;
+	const entries = Object.entries(value).filter((entry) => typeof entry[1] === "string");
+	return entries.length === 0 ? void 0 : Object.fromEntries(entries);
+}
+function parseServer(name, raw, sourcePath) {
+	if (typeof raw !== "object" || raw === null) return void 0;
+	const record = raw;
+	const disabled = record.disabled === true;
+	if (typeof record.url === "string") return {
+		name,
+		sourcePath,
+		transport: "streamable-http",
+		url: record.url,
+		...stringRecord(record.headers) === void 0 ? {} : { headers: stringRecord(record.headers) },
+		disabled
+	};
+	if (typeof record.command === "string") return {
+		name,
+		sourcePath,
+		transport: "stdio",
+		command: record.command,
+		...Array.isArray(record.args) ? { args: record.args.map(String) } : {},
+		...stringRecord(record.env) === void 0 ? {} : { env: stringRecord(record.env) },
+		...typeof record.cwd === "string" ? { cwd: record.cwd } : {},
+		disabled
+	};
+}
+function collectPiMcpServers(cwd, extraPaths = []) {
+	const servers = /* @__PURE__ */ new Map();
+	const sources = [];
+	for (const path of [...piMcpConfigPaths(cwd), ...extraPaths]) {
+		if (!existsSync(path)) continue;
+		let parsed;
+		try {
+			parsed = JSON.parse(readFileSync(path, "utf8"));
+		} catch {
+			continue;
+		}
+		const mcpServers = parsed?.mcpServers;
+		if (typeof mcpServers !== "object" || mcpServers === null) continue;
+		sources.push(path);
+		for (const [name, raw] of Object.entries(mcpServers)) {
+			const record = raw;
+			const existing = servers.get(name);
+			if (existing !== void 0 && typeof record === "object" && record !== null && record.command === void 0 && record.url === void 0 && typeof record.disabled === "boolean") {
+				servers.set(name, {
+					...existing,
+					disabled: record.disabled,
+					sourcePath: path
+				});
+				continue;
+			}
+			const server = parseServer(name, raw, path);
+			if (server !== void 0) servers.set(name, server);
+		}
+	}
+	return {
+		servers,
+		sources
+	};
+}
+const SERVER_NAME_PATTERN = /^[A-Za-z0-9_-]{1,32}$/u;
+const ENV_REFERENCE_PATTERN = /^\$\{?([A-Za-z_][A-Za-z0-9_]*)\}?$/u;
+const SECRETISH_KEY_PATTERN = /token|secret|key|password|credential/iu;
+function js(expression) {
+	return { __pi2dshJs: expression };
+}
+function convertValueMap(server, kind, values, warnings) {
+	if (values === void 0) return void 0;
+	const output = {};
+	for (const [key, value] of Object.entries(values)) {
+		const reference = ENV_REFERENCE_PATTERN.exec(value);
+		if (reference !== null) {
+			output[key] = js(`process.env.${reference[1]}`);
+			continue;
+		}
+		if (SECRETISH_KEY_PATTERN.test(key)) warnings.push({
+			server,
+			message: `${kind}.${key} carries a literal value; move the secret to an environment variable and reference it as $NAME so the patch stays credential-free`
+		});
+		output[key] = value;
+	}
+	return output;
+}
+function convertPiMcpConfig(cwd, extraPaths = []) {
+	const { servers, sources } = collectPiMcpServers(cwd, extraPaths);
+	const warnings = [];
+	const entries = [];
+	for (const server of servers.values()) {
+		if (server.disabled) {
+			warnings.push({
+				server: server.name,
+				message: "skipped: disabled in Pi configuration"
+			});
+			continue;
+		}
+		if (!SERVER_NAME_PATTERN.test(server.name)) {
+			warnings.push({
+				server: server.name,
+				message: "skipped: DSH serverName must match [A-Za-z0-9_-]{1,32}; rename the server in the Pi config"
+			});
+			continue;
+		}
+		const config = {
+			serverName: server.name,
+			transport: server.transport
+		};
+		if (server.transport === "stdio") {
+			config.command = server.command;
+			if (server.args !== void 0) config.args = server.args;
+			const env = convertValueMap(server.name, "env", server.env, warnings);
+			if (env !== void 0) config.env = env;
+			if (server.cwd !== void 0) config.cwd = server.cwd;
+		} else {
+			config.url = server.url;
+			const headers = convertValueMap(server.name, "headers", server.headers, warnings);
+			if (headers !== void 0) config.headers = headers;
+		}
+		entries.push({
+			id: `mcp-${server.name}`,
+			name: "@deepseek-ai/dsh-mcp-client",
+			config
+		});
+	}
+	return {
+		servers: [...servers.values()],
+		entries,
+		warnings,
+		sources
+	};
+}
+function yamlScalar(value, indent) {
+	if (typeof value === "object" && value !== null && "__pi2dshJs" in value) return `!!js ${value.__pi2dshJs}`;
+	if (typeof value === "string") return /^[A-Za-z0-9@._\/:-]+$/u.test(value) ? value : JSON.stringify(value);
+	if (Array.isArray(value)) {
+		if (value.length === 0) return "[]";
+		return `\n${value.map((item) => `${indent}  - ${yamlScalar(item, `${indent}  `)}`).join("\n")}`;
+	}
+	if (typeof value === "object" && value !== null) {
+		const record = value;
+		const keys = Object.keys(record);
+		if (keys.length === 0) return "{}";
+		return `\n${keys.map((key) => `${indent}  ${key}: ${yamlScalar(record[key], `${indent}  `)}`).join("\n")}`;
+	}
+	return String(value);
+}
+/** Render the converted entries as a cordis.patch.yml `insert` block. */
+function renderMcpPatch(result) {
+	if (result.entries.length === 0) return "# no enabled MCP servers found in Pi configuration\n";
+	const lines = ["- insert:"];
+	for (const entry of result.entries) {
+		lines.push(`    - id: ${String(entry.id)}`);
+		lines.push(`      name: '@deepseek-ai/dsh-mcp-client'`);
+		lines.push(`      inject: [tools]`);
+		lines.push(`      config:${yamlScalar(entry.config, "      ")}`);
+	}
+	return `${lines.join("\n")}\n`;
+}
+//#endregion
+export { ruleForHostImport as _, analyzePackage as a, EVENT_RULES as c, PI_CODING_AGENT_PACKAGES as d, PI_TUI_PACKAGES as f, ruleForEvent as g, ruleForContextProperty as h, generateBundle as i, HOST_IMPORT_RULES as l, ruleForApi as m, convertPiMcpConfig as n, API_RULES as o, UI_CONTEXT_RULES as p, renderMcpPatch as r, CONTEXT_RULES as s, collectPiMcpServers as t, PI_AI_PACKAGES as u, ruleForUiContextProperty as v };
+
+//# sourceMappingURL=mcp-config-jL9w70It.mjs.map