@victor-software-house/pi-acp 0.7.0 → 0.9.0

package/dist/{serve-DLukbpF4.mjs → daemon-tHPrf3qs.mjs}

@@ -1,12 +1,189 @@
-#!/usr/bin/env node
+#!/usr/bin/env bun
+import { a as removeStaleSocketIfAny, i as releaseLock, n as controlSocketPath, o as socketPath, r as ensureSocketParentDir, t as acquireLock } from "./socket-wvV053VI.mjs";
+import { t as piChangelogPath } from "./pi-package-aHs6rWNo.mjs";
+import { createServer } from "node:net";
+import { existsSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
-import { spawnSync } from "node:child_process";
-import { existsSync, readFileSync, realpathSync } from "node:fs";
-import { dirname, isAbsolute, join, resolve } from "node:path";
+import { isAbsolute, join, resolve } from "node:path";
+import { Hono } from "hono";
 import { AgentSideConnection, RequestError, ndJsonStream } from "@agentclientprotocol/sdk";
 import { randomUUID } from "node:crypto";
-import { SessionManager, createAgentSession } from "@earendil-works/pi-coding-agent";
+import { DefaultResourceLoader, SessionManager, createAgentSession, getAgentDir } from "@earendil-works/pi-coding-agent";
 import * as z from "zod";
+import { parse } from "yaml";
+import { $ } from "bun";
+//#region src/daemon/session-registry.ts
+function createSessionRegistry() {
+	const map = /* @__PURE__ */ new Map();
+	return {
+		register(input) {
+			const entry = {
+				sessionId: input.sessionId,
+				piSession: input.piSession,
+				ownerConnectionId: input.ownerConnectionId,
+				alsoHeldBy: /* @__PURE__ */ new Set(),
+				cwd: input.cwd,
+				sessionFile: input.sessionFile,
+				updatedAt: /* @__PURE__ */ new Date()
+			};
+			map.set(input.sessionId, entry);
+		},
+		attach(sessionId, connectionId) {
+			const entry = map.get(sessionId);
+			if (entry === void 0) return void 0;
+			if (entry.ownerConnectionId !== connectionId) {
+				entry.alsoHeldBy.add(connectionId);
+				entry.updatedAt = /* @__PURE__ */ new Date();
+			}
+			return entry;
+		},
+		release(sessionId, connectionId) {
+			const entry = map.get(sessionId);
+			if (entry === void 0) return { kind: "unknown" };
+			if (entry.alsoHeldBy.delete(connectionId)) {
+				entry.updatedAt = /* @__PURE__ */ new Date();
+				if (entry.ownerConnectionId === connectionId && entry.alsoHeldBy.size === 0) {
+					map.delete(sessionId);
+					return {
+						kind: "disposed",
+						entry
+					};
+				}
+				return {
+					kind: "still-held",
+					entry
+				};
+			}
+			if (entry.ownerConnectionId === connectionId) {
+				if (entry.alsoHeldBy.size > 0) {
+					const next = entry.alsoHeldBy.values().next().value;
+					if (next !== void 0) {
+						entry.alsoHeldBy.delete(next);
+						entry.ownerConnectionId = next;
+						entry.updatedAt = /* @__PURE__ */ new Date();
+						return {
+							kind: "still-held",
+							entry
+						};
+					}
+				}
+				map.delete(sessionId);
+				return {
+					kind: "disposed",
+					entry
+				};
+			}
+			return {
+				kind: "still-held",
+				entry
+			};
+		},
+		get(sessionId) {
+			return map.get(sessionId);
+		},
+		listAll() {
+			return Array.from(map.values());
+		},
+		listOwnedBy(connectionId) {
+			return Array.from(map.values()).filter((e) => e.ownerConnectionId === connectionId || e.alsoHeldBy.has(connectionId));
+		}
+	};
+}
+//#endregion
+//#region src/daemon/context.ts
+/**
+* Daemon-level shared state injected into per-connection PiAcpAgent instances.
+*
+* Phase 1 landed the interface + stub IdleTracker.
+* Phase 2 wires the real SessionRegistry.
+* Phase 3 will replace IdleTracker.
+*/
+function createNoopIdleTracker() {
+	return {
+		bump() {},
+		dispose() {}
+	};
+}
+function createDaemonContext() {
+	return {
+		sessionRegistry: createSessionRegistry(),
+		idleTracker: createNoopIdleTracker()
+	};
+}
+//#endregion
+//#region src/daemon/control.ts
+function buildControlApp(control) {
+	const app = new Hono();
+	app.get("/status", (c) => c.json({
+		uptimeSeconds: Math.round((Date.now() - control.startedAt) / 1e3),
+		connections: control.activeConnections(),
+		sessions: control.ctx.sessionRegistry.listAll().length,
+		pid: control.pid,
+		version: control.version
+	}));
+	app.post("/shutdown", (c) => {
+		setImmediate(control.onShutdown);
+		return c.json({ ok: true });
+	});
+	app.get("/sessions", (c) => c.json({ sessions: control.ctx.sessionRegistry.listAll().map((entry) => ({
+		sessionId: entry.sessionId,
+		cwd: entry.cwd,
+		owner: entry.ownerConnectionId,
+		alsoHeldBy: [...entry.alsoHeldBy],
+		updatedAt: entry.updatedAt
+	})) }));
+	return app;
+}
+/**
+* Bind the control app to a Unix domain socket. Uses Bun.serve's `unix` option.
+*/
+function serveControl(app, socketPath) {
+	const server = Bun.serve({
+		unix: socketPath,
+		fetch: app.fetch
+	});
+	return { stop() {
+		try {
+			server.stop(true);
+		} catch {}
+	} };
+}
+//#endregion
+//#region src/daemon/idle.ts
+const DEFAULT_IDLE_SECONDS = 600;
+function createIdleTracker(opts) {
+	let active = 0;
+	let timer = null;
+	const startTimer = () => {
+		if (timer !== null) return;
+		timer = setTimeout(opts.onIdle, opts.idleMs);
+		timer.unref?.();
+	};
+	const stopTimer = () => {
+		if (timer === null) return;
+		clearTimeout(timer);
+		timer = null;
+	};
+	startTimer();
+	return {
+		bump(delta) {
+			active = Math.max(0, active + delta);
+			if (active === 0) startTimer();
+			else stopTimer();
+		},
+		dispose() {
+			stopTimer();
+		}
+	};
+}
+function resolveIdleMs() {
+	const raw = process.env["PI_ACP_DAEMON_IDLE_SECONDS"];
+	if (raw === void 0 || raw === "") return DEFAULT_IDLE_SECONDS * 1e3;
+	const n = Number.parseInt(raw, 10);
+	if (!Number.isFinite(n) || n <= 0) return DEFAULT_IDLE_SECONDS * 1e3;
+	return n * 1e3;
+}
+//#endregion
 //#region src/acp/auth.ts
 const AUTH_METHOD_ID = "pi_terminal_login";
 function buildAuthMethods(opts) {
@@ -1136,9 +1313,449 @@ function acpPromptToPiMessage(blocks) {
 	};
 }
 //#endregion
+//#region src/resources/sources/local.ts
+/**
+* LocalBackend: wraps pi's DefaultResourceLoader for one (cwd, agentDir) root.
+* Phase 4 skeleton — manifest support (multiple local roots) lands in Phase 5.
+*/
+var LocalBackend = class {
+	id;
+	kind = "local";
+	loader;
+	constructor(opts) {
+		this.id = opts.id ?? "local";
+		this.loader = new DefaultResourceLoader({
+			cwd: opts.cwd,
+			agentDir: opts.agentDir
+		});
+	}
+	async reload() {
+		await this.loader.reload();
+	}
+	getAgentsFiles() {
+		return this.loader.getAgentsFiles().agentsFiles;
+	}
+	getSkills() {
+		return this.loader.getSkills();
+	}
+	getPrompts() {
+		return this.loader.getPrompts();
+	}
+	getExtensions() {
+		return this.loader.getExtensions();
+	}
+	getSystemPrompt() {
+		return this.loader.getSystemPrompt();
+	}
+	getAppendSystemPrompt() {
+		return this.loader.getAppendSystemPrompt();
+	}
+	/**
+	* Expose the wrapped DefaultResourceLoader for VirtualResourceLoader's
+	* extension/theme passthrough. Other backends don't expose this.
+	*/
+	inner() {
+		return this.loader;
+	}
+};
+//#endregion
+//#region src/resources/loader.ts
+var VirtualResourceLoader = class {
+	sources;
+	mergeStrategy;
+	primary;
+	constructor(opts) {
+		if (opts.sources.length === 0) throw new Error("VirtualResourceLoader requires at least one source");
+		this.sources = opts.sources;
+		this.mergeStrategy = opts.mergeStrategy ?? "append";
+		const primary = resolvePrimary(opts.sources, opts.primarySourceId);
+		this.primary = primary;
+	}
+	async reload() {
+		await Promise.all(this.sources.map((s) => s.reload()));
+	}
+	getAgentsFiles() {
+		const seen = /* @__PURE__ */ new Set();
+		const merged = [];
+		for (const source of this.sources) for (const file of source.getAgentsFiles()) {
+			if (seen.has(file.path)) continue;
+			seen.add(file.path);
+			merged.push(file);
+		}
+		return { agentsFiles: merged };
+	}
+	getSkills() {
+		const merge = createMerger(this.mergeStrategy, (s) => s.name);
+		const diagnostics = [];
+		for (const source of this.sources) {
+			const result = source.getSkills();
+			merge.absorb(result.skills);
+			diagnostics.push(...result.diagnostics);
+		}
+		return {
+			skills: merge.list(),
+			diagnostics
+		};
+	}
+	getPrompts() {
+		const merge = createMerger(this.mergeStrategy, (p) => p.name);
+		const diagnostics = [];
+		for (const source of this.sources) {
+			const result = source.getPrompts();
+			merge.absorb(result.prompts);
+			diagnostics.push(...result.diagnostics);
+		}
+		return {
+			prompts: merge.list(),
+			diagnostics
+		};
+	}
+	getThemes() {
+		return this.primary.inner().getThemes();
+	}
+	getExtensions() {
+		return this.primary.getExtensions();
+	}
+	getSystemPrompt() {
+		for (const source of this.sources) {
+			const sp = source.getSystemPrompt();
+			if (sp !== void 0) return sp;
+		}
+	}
+	getAppendSystemPrompt() {
+		const merged = [];
+		for (const source of this.sources) merged.push(...source.getAppendSystemPrompt());
+		return merged;
+	}
+	extendResources(paths) {
+		this.primary.inner().extendResources(paths);
+	}
+	/** Returns the active source list. Useful for diagnostics. */
+	listSources() {
+		return [...this.sources];
+	}
+};
+function resolvePrimary(sources, preferredId) {
+	if (preferredId !== void 0) {
+		const found = sources.find((s) => s.id === preferredId);
+		if (found === void 0) throw new Error(`VirtualResourceLoader: primarySourceId "${preferredId}" not in sources`);
+		if (!(found instanceof LocalBackend)) throw new Error(`VirtualResourceLoader: primary source "${preferredId}" must be a LocalBackend`);
+		return found;
+	}
+	const firstLocal = sources.find((s) => s instanceof LocalBackend);
+	if (firstLocal === void 0) throw new Error("VirtualResourceLoader: at least one LocalBackend is required (for extensions + themes)");
+	return firstLocal;
+}
+function createMerger(strategy, key) {
+	if (strategy === "append") {
+		const out = [];
+		return {
+			absorb(items) {
+				out.push(...items);
+			},
+			list() {
+				return out;
+			}
+		};
+	}
+	const byKey = /* @__PURE__ */ new Map();
+	return {
+		absorb(items) {
+			for (const item of items) byKey.set(key(item), item);
+		},
+		list() {
+			return Array.from(byKey.values());
+		}
+	};
+}
+//#endregion
+//#region src/resources/manifest.schema.ts
+/**
+* Zod schema for the `.pi-acp.yaml` resource composition manifest (ADR-0008).
+*
+* Backend kinds: `local`, `ssh`, `http`, `acp-fs`. Phase 5 ships parsing and
+* validation for all four; only `local` is honored by the loader until the
+* remote-backend phases land — unknown kinds parse fine and surface as a
+* diagnostic at load time.
+*/
+const IdSchema = z.string().trim().min(1, "id is required");
+const LocalPathsSchema = z.object({
+	cwd: z.string().trim().optional(),
+	agentDir: z.string().trim().optional()
+}).strict();
+const RemotePathsSchema = z.object({
+	skills: z.string().trim().optional(),
+	prompts: z.string().trim().optional(),
+	agentsFiles: z.array(z.string().trim()).optional(),
+	extensions: z.string().trim().optional()
+}).strict();
+const LocalRootSchema = z.object({
+	id: IdSchema,
+	kind: z.literal("local"),
+	paths: LocalPathsSchema.default({})
+}).strict();
+const SshRootSchema = z.object({
+	id: IdSchema,
+	kind: z.literal("ssh"),
+	host: z.string().trim().min(1),
+	user: z.string().trim().optional(),
+	paths: RemotePathsSchema.default({})
+}).strict();
+const HttpRootSchema = z.object({
+	id: IdSchema,
+	kind: z.literal("http"),
+	baseUrl: z.url().refine((u) => u.startsWith("https://"), { error: "baseUrl must use https://" }),
+	cache: z.object({ ttl: z.int().nonnegative() }).strict().optional(),
+	paths: RemotePathsSchema.default({})
+}).strict();
+const AcpFsRootSchema = z.object({
+	id: IdSchema,
+	kind: z.literal("acp-fs"),
+	paths: RemotePathsSchema.default({})
+}).strict();
+const RootSchema = z.discriminatedUnion("kind", [
+	LocalRootSchema,
+	SshRootSchema,
+	HttpRootSchema,
+	AcpFsRootSchema
+]);
+const AutoImportSchema = z.object({
+	source: IdSchema,
+	paths: z.array(z.string().trim()).min(1)
+}).strict();
+const ManifestSchema = z.object({
+	version: z.literal(1),
+	mode: z.enum([
+		"local",
+		"overlay",
+		"none"
+	]).default("local"),
+	roots: z.array(RootSchema).default([]),
+	mergeStrategy: z.enum(["append", "override-by-name"]).default("append"),
+	autoImport: z.array(AutoImportSchema).optional(),
+	diagnostics: z.boolean().default(false)
+}).strict();
+const DEFAULT_MANIFEST = {
+	version: 1,
+	mode: "local",
+	roots: [],
+	mergeStrategy: "append",
+	diagnostics: false
+};
+//#endregion
+//#region src/resources/manifest.ts
+/**
+* Cascade resolver for the `.pi-acp.yaml` resource composition manifest
+* (ADR-0008, PRD-002 §FR-3).
+*
+* Precedence (highest first):
+*   1. ACP session params: `params._meta.piAcp.manifest`
+*      — either an inline manifest object or a string path to a YAML file
+*   2. Project-level: `<cwd>/.pi-acp.yaml`
+*   3. User-global:   `~/.pi-acp/config.yaml`
+*   4. Synthesized default
+*
+* Parse errors at any layer fall through to the next; the caller never gets
+* an exception. Errors collect into the returned `diagnostics` list so they
+* can be surfaced to the operator.
+*/
+const USER_MANIFEST_PATH = join(homedir(), ".pi-acp", "config.yaml");
+const PROJECT_MANIFEST_BASENAME = ".pi-acp.yaml";
+async function loadManifest(input) {
+	const diagnostics = [];
+	const fromParams = await tryFromSessionParams(input.sessionParams, diagnostics);
+	if (fromParams !== null) {
+		const result = {
+			manifest: fromParams.manifest,
+			source: "session-params",
+			diagnostics
+		};
+		if (fromParams.path !== void 0) result.path = fromParams.path;
+		return result;
+	}
+	const projectPath = join(input.cwd, PROJECT_MANIFEST_BASENAME);
+	const fromProject = tryFromFile(projectPath, "project", diagnostics);
+	if (fromProject !== null) return {
+		manifest: fromProject,
+		source: "project",
+		path: projectPath,
+		diagnostics
+	};
+	const fromUser = tryFromFile(USER_MANIFEST_PATH, "user-global", diagnostics);
+	if (fromUser !== null) return {
+		manifest: fromUser,
+		source: "user-global",
+		path: USER_MANIFEST_PATH,
+		diagnostics
+	};
+	return {
+		manifest: DEFAULT_MANIFEST,
+		source: "default",
+		diagnostics
+	};
+}
+async function tryFromSessionParams(params, diagnostics) {
+	if (typeof params !== "object" || params === null) return null;
+	const meta = params._meta;
+	if (typeof meta !== "object" || meta === null) return null;
+	const piAcp = meta.piAcp;
+	if (typeof piAcp !== "object" || piAcp === null) return null;
+	const manifestRef = piAcp.manifest;
+	if (manifestRef === void 0) return null;
+	if (typeof manifestRef === "string") {
+		const parsed = tryFromFile(manifestRef, "session-params", diagnostics);
+		if (parsed !== null) return {
+			manifest: parsed,
+			path: manifestRef
+		};
+		return null;
+	}
+	const result = ManifestSchema.safeParse(manifestRef);
+	if (result.success) return { manifest: result.data };
+	diagnostics.push({
+		source: "session-params",
+		message: `inline manifest validation failed: ${result.error.message}`
+	});
+	return null;
+}
+function tryFromFile(path, source, diagnostics) {
+	if (!existsSync(path)) return null;
+	let raw;
+	try {
+		raw = readFileSync(path, "utf8");
+	} catch (err) {
+		diagnostics.push({
+			source,
+			path,
+			message: `read failed: ${err instanceof Error ? err.message : String(err)}`
+		});
+		return null;
+	}
+	let parsed;
+	try {
+		parsed = parse(raw);
+	} catch (err) {
+		diagnostics.push({
+			source,
+			path,
+			message: `YAML parse failed: ${err instanceof Error ? err.message : String(err)}`
+		});
+		return null;
+	}
+	const result = ManifestSchema.safeParse(parsed);
+	if (result.success) return result.data;
+	diagnostics.push({
+		source,
+		path,
+		message: `schema validation failed: ${result.error.message}`
+	});
+	return null;
+}
+//#endregion
+//#region src/resources/sources/ssh.ts
+const DEFAULT_TIMEOUT_MS = 5e3;
+var SshBackend = class {
+	id;
+	kind = "ssh";
+	host;
+	user;
+	paths;
+	timeoutMs;
+	sshCommand;
+	cache = null;
+	constructor(opts) {
+		this.id = opts.id;
+		this.host = opts.host;
+		this.user = opts.user;
+		this.paths = opts.paths ?? {};
+		this.timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+		this.sshCommand = opts.sshCommand ?? "ssh";
+	}
+	async reload() {
+		const diagnostics = [];
+		for (const kind of [
+			"skills",
+			"prompts",
+			"extensions"
+		]) if (this.paths[kind] !== void 0) diagnostics.push(this.unsupportedDiagnostic(kind));
+		const list = this.paths.agentsFiles ?? [];
+		const files = [];
+		if (list.length > 0) {
+			const results = await Promise.all(list.map((path) => this.cat(path).then((content) => ({
+				path,
+				content,
+				error: null
+			}), (err) => ({
+				path,
+				content: null,
+				error: err instanceof Error ? err.message : String(err)
+			}))));
+			for (const r of results) {
+				if (r.content !== null) {
+					files.push({
+						path: this.qualifyPath(r.path),
+						content: r.content
+					});
+					continue;
+				}
+				diagnostics.push({
+					type: "warning",
+					message: `pi-acp ssh source '${this.id}' (${this.target()}): agentsFile '${r.path}' unreadable — ${r.error ?? "(unknown)"}`,
+					path: r.path
+				});
+			}
+		}
+		this.cache = {
+			files,
+			diagnostics
+		};
+	}
+	getAgentsFiles() {
+		return this.cache?.files ?? [];
+	}
+	getSkills() {
+		return {
+			skills: [],
+			diagnostics: this.cache?.diagnostics ?? []
+		};
+	}
+	getPrompts() {
+		return {
+			prompts: [],
+			diagnostics: []
+		};
+	}
+	getSystemPrompt() {}
+	getAppendSystemPrompt() {
+		return [];
+	}
+	target() {
+		return this.user !== void 0 && this.user.length > 0 ? `${this.user}@${this.host}` : this.host;
+	}
+	qualifyPath(path) {
+		return `ssh://${this.target()}/${path.replace(/^\//, "")}`;
+	}
+	unsupportedDiagnostic(kind) {
+		return {
+			type: "warning",
+			message: `pi-acp ssh source '${this.id}' (${this.target()}): ${kind} discovery over SSH not yet implemented — declare individual files via paths.agentsFiles for now, or omit paths.${kind}.`
+		};
+	}
+	async cat(path) {
+		const seconds = Math.max(1, Math.ceil(this.timeoutMs / 1e3));
+		const aliveCount = Math.max(1, Math.floor(seconds / 2));
+		const result = await $`${this.sshCommand} -o BatchMode=yes -o ConnectTimeout=${seconds} -o ServerAliveInterval=2 -o ServerAliveCountMax=${aliveCount} ${this.target()} -- cat ${path}`.quiet().nothrow();
+		if (result.exitCode !== 0) {
+			const stderr = result.stderr.toString().trim();
+			throw new Error(`ssh exited ${result.exitCode}: ${stderr || "(no stderr)"}`);
+		}
+		return result.stdout.toString();
+	}
+};
+//#endregion
 //#region package.json
 var name = "@victor-software-house/pi-acp";
-var version = "0.7.0";
+var version = "0.9.0";
 //#endregion
 //#region src/acp/agent.ts
 /** Builtin ACP slash commands handled directly by the adapter. */
@@ -1259,6 +1876,64 @@ var PiAcpAgent = class {
 		if (this.daemonContext === void 0) return { disposed: true };
 		return { disposed: this.daemonContext.sessionRegistry.release(sessionId, this.connectionId).kind === "disposed" };
 	}
+	/**
+	* Build a VirtualResourceLoader for a new pi session. Reads the
+	* `.pi-acp.yaml` manifest cascade (ACP params > project > user-global >
+	* default), turns each declared root into a ResourceSource, and ensures at
+	* least one LocalBackend is present for the extension / theme passthrough.
+	*
+	* Phase 5 materializes `kind: "local"`. Phase 6 adds `kind: "ssh"`.
+	* `http` and `acp-fs` still parse fine but surface as diagnostics until
+	* their backends land in subsequent phases.
+	*/
+	async buildResourceLoader(cwd, sessionParams) {
+		const loaded = await loadManifest({
+			cwd,
+			sessionParams
+		});
+		const diagnostics = [...loaded.diagnostics];
+		const sources = [];
+		for (const root of loaded.manifest.roots) {
+			if (root.kind === "local") {
+				sources.push(new LocalBackend({
+					id: root.id,
+					cwd: root.paths.cwd ?? cwd,
+					agentDir: root.paths.agentDir ?? getAgentDir()
+				}));
+				continue;
+			}
+			if (root.kind === "ssh") {
+				const sshOpts = {
+					id: root.id,
+					host: root.host,
+					paths: root.paths
+				};
+				if (root.user !== void 0) sshOpts.user = root.user;
+				sources.push(new SshBackend(sshOpts));
+				continue;
+			}
+			const diag = {
+				source: loaded.source,
+				message: `root "${root.id}" kind="${root.kind}" not yet supported in this build (skipped)`
+			};
+			if (loaded.path !== void 0) diag.path = loaded.path;
+			diagnostics.push(diag);
+		}
+		if (!sources.some((s) => s.kind === "local")) sources.unshift(new LocalBackend({
+			cwd,
+			agentDir: getAgentDir()
+		}));
+		const loader = new VirtualResourceLoader({
+			sources,
+			mergeStrategy: loaded.manifest.mergeStrategy
+		});
+		await loader.reload();
+		if (diagnostics.length > 0 && process.env["PI_ACP_DAEMON_DEBUG"] === "1") for (const d of diagnostics) {
+			const where = d.path !== void 0 ? ` ${d.path}` : "";
+			process.stderr.write(`pi-acp manifest [${d.source}${where}]: ${d.message}\n`);
+		}
+		return loader;
+	}
 	async initialize(params) {
 		const supportedVersion = 1;
 		const requested = params.protocolVersion;
@@ -1295,7 +1970,11 @@ var PiAcpAgent = class {
 		if (!isAbsolute(params.cwd)) throw RequestError.invalidParams(`cwd must be an absolute path: ${params.cwd}`);
 		let result;
 		try {
-			result = await createAgentSession({ cwd: params.cwd });
+			const resourceLoader = await this.buildResourceLoader(params.cwd, params);
+			result = await createAgentSession({
+				cwd: params.cwd,
+				resourceLoader
+			});
 		} catch (e) {
 			const authErr = detectAuthError(e);
 			if (authErr !== null) throw authErr;
@@ -1565,9 +2244,11 @@ var PiAcpAgent = class {
 		let result;
 		try {
 			const sm = SessionManager.open(sessionFile);
+			const resourceLoader = await this.buildResourceLoader(params.cwd, params);
 			result = await createAgentSession({
 				cwd: params.cwd,
-				sessionManager: sm
+				sessionManager: sm,
+				resourceLoader
 			});
 		} catch (e) {
 			const authErr = detectAuthError(e);
@@ -1663,9 +2344,11 @@ var PiAcpAgent = class {
 		let result;
 		try {
 			const sm = SessionManager.open(sessionFile);
+			const resourceLoader = await this.buildResourceLoader(params.cwd, params);
 			result = await createAgentSession({
 				cwd: params.cwd,
-				sessionManager: sm
+				sessionManager: sm,
+				resourceLoader
 			});
 		} catch (e) {
 			const authErr = detectAuthError(e);
@@ -1720,9 +2403,11 @@ var PiAcpAgent = class {
 		let result;
 		try {
 			const sm = SessionManager.forkFrom(sourceFile, params.cwd);
+			const resourceLoader = await this.buildResourceLoader(params.cwd, params);
 			result = await createAgentSession({
 				cwd: params.cwd,
-				sessionManager: sm
+				sessionManager: sm,
+				resourceLoader
 			});
 		} catch (e) {
 			const authErr = detectAuthError(e);
@@ -2191,20 +2876,8 @@ function buildCommandList(piSession, enableSkillCommands) {
 }
 function findChangelog() {
 	try {
-		const which = spawnSync(process.platform === "win32" ? "where" : "which", ["pi"], { encoding: "utf-8" });
-		const piPath = String(which.stdout ?? "").split(/\r?\n/)[0]?.trim();
-		if (piPath !== void 0 && piPath !== "") {
-			const p = join(dirname(dirname(realpathSync(piPath))), "CHANGELOG.md");
-			if (existsSync(p)) return p;
-		}
-	} catch {}
-	try {
-		const npmRoot = spawnSync("npm", ["root", "-g"], { encoding: "utf-8" });
-		const root = String(npmRoot.stdout ?? "").trim();
-		if (root) {
-			const p = join(root, "@mariozechner", "pi-coding-agent", "CHANGELOG.md");
-			if (existsSync(p)) return p;
-		}
+		const p = piChangelogPath();
+		if (existsSync(p)) return p;
 	} catch {}
 	return null;
 }
@@ -2258,6 +2931,108 @@ function toWebWritable(dst) {
 	} });
 }
 //#endregion
-export { serveAcp as t };
+//#region src/daemon/index.ts
+/**
+* Daemon entry point. Invoked when pi-acp is launched with `--daemon`.
+*
+* Lifecycle:
+*   1. Acquire per-UID lockfile (refuses if another daemon alive).
+*   2. Remove stale socket files left by a dead prior daemon.
+*   3. Construct DaemonContext shared singletons.
+*   4. Bind ACP socket (raw NDJSON via node:net).
+*   5. Bind control socket (HTTP via Bun.serve + Hono).
+*   6. SIGINT/SIGTERM/idle-timeout trigger graceful shutdown.
+*/
+async function runDaemon() {
+	const lockResult = acquireLock();
+	if (!lockResult.ok) {
+		process.stderr.write(`pi-acp daemon: already running (pid ${lockResult.heldByPid ?? "unknown"})\n`);
+		process.exit(1);
+	}
+	ensureSocketParentDir();
+	removeStaleSocketIfAny();
+	const connections = /* @__PURE__ */ new Set();
+	let shuttingDown = false;
+	const startedAt = Date.now();
+	const shutdown = () => {
+		if (shuttingDown) return;
+		shuttingDown = true;
+		server.close();
+		controlServer.stop();
+		for (const entry of connections) {
+			try {
+				entry.handle.dispose();
+			} catch {}
+			try {
+				entry.socket.destroy();
+			} catch {}
+		}
+		connections.clear();
+		ctx.idleTracker.dispose();
+		removeStaleSocketIfAny();
+		releaseLock();
+		process.exit(0);
+	};
+	const ctx = createDaemonContext();
+	ctx.idleTracker = createIdleTracker({
+		idleMs: resolveIdleMs(),
+		onIdle: shutdown
+	});
+	const controlCtx = {
+		ctx,
+		startedAt,
+		pid: process.pid,
+		version,
+		activeConnections: () => connections.size,
+		onShutdown: shutdown
+	};
+	const server = createServer((socket) => {
+		if (shuttingDown) {
+			socket.destroy();
+			return;
+		}
+		onAccept(socket);
+	});
+	const onAccept = (socket) => {
+		const handle = serveAcp({
+			input: socket,
+			output: socket,
+			daemonContext: ctx
+		});
+		const entry = {
+			socket,
+			handle
+		};
+		connections.add(entry);
+		ctx.idleTracker.bump(1);
+		const cleanup = () => {
+			if (!connections.delete(entry)) return;
+			try {
+				handle.dispose();
+			} catch {}
+			ctx.idleTracker.bump(-1);
+		};
+		socket.on("close", cleanup);
+		socket.on("error", cleanup);
+	};
+	server.on("error", (err) => {
+		process.stderr.write(`pi-acp daemon: server error: ${err.message}\n`);
+	});
+	await new Promise((resolve, reject) => {
+		const path = socketPath();
+		server.listen(path, () => resolve());
+		server.once("error", reject);
+	});
+	const controlServer = serveControl(buildControlApp(controlCtx), controlSocketPath());
+	if (process.env["PI_ACP_DAEMON_DEBUG"] === "1") process.stderr.write(`pi-acp daemon: acp=${socketPath()} control=${controlSocketPath()} pid=${process.pid}\n`);
+	process.on("SIGINT", () => {
+		shutdown();
+	});
+	process.on("SIGTERM", () => {
+		shutdown();
+	});
+}
+//#endregion
+export { runDaemon };
 
-//# sourceMappingURL=serve-DLukbpF4.mjs.map
+//# sourceMappingURL=daemon-tHPrf3qs.mjs.map