hyperclaw 4.0.0 → 4.0.2

package/dist/server-DU9POoWc.js

@@ -0,0 +1,4 @@
+const require_chunk = require('./chunk-jS-bbMI5.js');
+const require_server = require('./server-BRlCEjyT.js');
+
+exports.startGateway = require_server.startGateway;

package/dist/server-RBqwE_GN.js

@@ -0,0 +1,4 @@
+const require_chunk = require('./chunk-jS-bbMI5.js');
+const require_server = require('./server-CCI1hv45.js');
+
+exports.startGateway = require_server.startGateway;

package/dist/session-store-CujxByI6.js

@@ -0,0 +1,113 @@
+const require_chunk = require('./chunk-jS-bbMI5.js');
+
+//#region packages/core/src/agent/session-store.ts
+function sanitizeKey(key) {
+	return key.replace(/[^a-z0-9_-]/gi, "_");
+}
+/** File-based session store. Sessions persist across gateway restarts. */
+async function createFileSessionStore(baseDir) {
+	const fs = await import("fs-extra");
+	const path = await import("path");
+	const dir = path.join(baseDir, "sessions");
+	await fs.ensureDir(dir);
+	const readState = async (key) => {
+		const fp = path.join(dir, `${sanitizeKey(key)}.json`);
+		if (!await fs.pathExists(fp)) return null;
+		try {
+			return await fs.readJson(fp);
+		} catch {
+			return null;
+		}
+	};
+	const writeState = async (key, state) => {
+		const fp = path.join(dir, `${sanitizeKey(key)}.json`);
+		await fs.writeJson(fp, {
+			...state,
+			lastActiveAt: (/* @__PURE__ */ new Date()).toISOString()
+		});
+	};
+	return {
+		async get(key) {
+			return readState(key);
+		},
+		async set(key, state) {
+			await writeState(key, {
+				...state,
+				lastActiveAt: (/* @__PURE__ */ new Date()).toISOString()
+			});
+		},
+		async append(key, role, content, source) {
+			const existing = await readState(key);
+			const transcript = existing?.transcript ?? [];
+			transcript.push({
+				role,
+				content
+			});
+			if (transcript.length > 100) transcript.splice(0, transcript.length - 80);
+			await writeState(key, {
+				id: existing?.id ?? key,
+				source: existing?.source ?? source ?? "unknown",
+				externalId: existing?.externalId,
+				transcript,
+				lastActiveAt: (/* @__PURE__ */ new Date()).toISOString(),
+				workingMemory: existing?.workingMemory,
+				agentState: existing?.agentState
+			});
+		},
+		async getWorkingMemory(key) {
+			const s = await readState(key);
+			const slots = (s?.workingMemory ?? []).filter((w) => {
+				if (w.expiresAt && new Date(w.expiresAt) < /* @__PURE__ */ new Date()) return false;
+				return true;
+			});
+			return slots.slice(-MAX_WORKING_MEMORY);
+		},
+		async setWorkingMemory(key, slots) {
+			const existing = await readState(key);
+			const state = {
+				id: existing?.id ?? key,
+				source: existing?.source ?? "unknown",
+				transcript: existing?.transcript ?? [],
+				lastActiveAt: (/* @__PURE__ */ new Date()).toISOString(),
+				workingMemory: slots.slice(-MAX_WORKING_MEMORY),
+				agentState: existing?.agentState
+			};
+			await writeState(key, state);
+		},
+		async updateAgentState(key, patch) {
+			const existing = await readState(key);
+			const agentState = {
+				...existing?.agentState ?? {},
+				...patch
+			};
+			await writeState(key, {
+				id: existing?.id ?? key,
+				source: existing?.source ?? "unknown",
+				externalId: existing?.externalId,
+				transcript: existing?.transcript ?? [],
+				lastActiveAt: (/* @__PURE__ */ new Date()).toISOString(),
+				workingMemory: existing?.workingMemory,
+				agentState
+			});
+		}
+	};
+}
+var MAX_WORKING_MEMORY, WORKING_MEMORY_TTL_MS;
+var init_session_store = require_chunk.__esm({ "packages/core/src/agent/session-store.ts"() {
+	MAX_WORKING_MEMORY = 20;
+	WORKING_MEMORY_TTL_MS = 24 * 60 * 60 * 1e3;
+} });
+
+//#endregion
+Object.defineProperty(exports, 'createFileSessionStore', {
+  enumerable: true,
+  get: function () {
+    return createFileSessionStore;
+  }
+});
+Object.defineProperty(exports, 'init_session_store', {
+  enumerable: true,
+  get: function () {
+    return init_session_store;
+  }
+});

package/dist/session-store-qpJUg2M1.js

@@ -0,0 +1,5 @@
+const require_chunk = require('./chunk-jS-bbMI5.js');
+const require_session_store = require('./session-store-CujxByI6.js');
+
+require_session_store.init_session_store();
+exports.createFileSessionStore = require_session_store.createFileSessionStore;

package/dist/sessions-tools-CB2qbwIk.js

@@ -0,0 +1,5 @@
+const require_chunk = require('./chunk-jS-bbMI5.js');
+const require_sessions_tools = require('./sessions-tools-DHMaTZIs.js');
+
+require_sessions_tools.init_sessions_tools();
+exports.getSessionsTools = require_sessions_tools.getSessionsTools;

package/dist/sessions-tools-DHMaTZIs.js

@@ -0,0 +1,95 @@
+const require_chunk = require('./chunk-jS-bbMI5.js');
+
+//#region packages/core/src/agent/sessions-tools.ts
+function getSessionsTools(getServer, currentSessionId) {
+	return [
+		{
+			name: "sessions_list",
+			description: "List active WebSocket sessions connected to the gateway. Use to discover other agents or clients.",
+			input_schema: {
+				type: "object",
+				properties: {},
+				required: []
+			},
+			handler: async () => {
+				const server = getServer();
+				if (!server) return "Gateway not available (sessions tools only work when running in gateway).";
+				const list = server.getSessionsList?.() ?? [];
+				return JSON.stringify(list, null, 2);
+			}
+		},
+		{
+			name: "sessions_send",
+			description: "Send a message to another session. Use sessions_list to get session IDs.",
+			input_schema: {
+				type: "object",
+				properties: {
+					sessionId: {
+						type: "string",
+						description: "Target session ID from sessions_list"
+					},
+					content: {
+						type: "string",
+						description: "Message content to send"
+					}
+				},
+				required: ["sessionId", "content"]
+			},
+			handler: async (input) => {
+				const server = getServer();
+				if (!server) return "Gateway not available.";
+				const sessionId = input.sessionId;
+				const content = input.content;
+				const ok = server.sendToSession?.(sessionId, {
+					type: "chat:incoming",
+					content,
+					fromSession: currentSessionId ?? "unknown"
+				});
+				if (ok) return `Sent to session ${sessionId}.`;
+				return `Session ${sessionId} not found or disconnected.`;
+			}
+		},
+		{
+			name: "sessions_history",
+			description: "Get recent chat transcript for a session. Returns user/assistant turns.",
+			input_schema: {
+				type: "object",
+				properties: {
+					sessionId: {
+						type: "string",
+						description: "Session ID (use \"self\" for current session)"
+					},
+					limit: {
+						type: "string",
+						description: "Max turns to return (default 20)"
+					}
+				},
+				required: ["sessionId"]
+			},
+			handler: async (input) => {
+				const server = getServer();
+				if (!server) return "Gateway not available.";
+				const sid = input.sessionId === "self" ? currentSessionId : input.sessionId;
+				if (!sid) return "No current session.";
+				const limit = parseInt(input.limit || "20");
+				const history = server.getSessionHistory?.(sid, limit) ?? [];
+				return JSON.stringify(history, null, 2);
+			}
+		}
+	];
+}
+var init_sessions_tools = require_chunk.__esm({ "packages/core/src/agent/sessions-tools.ts"() {} });
+
+//#endregion
+Object.defineProperty(exports, 'getSessionsTools', {
+  enumerable: true,
+  get: function () {
+    return getSessionsTools;
+  }
+});
+Object.defineProperty(exports, 'init_sessions_tools', {
+  enumerable: true,
+  get: function () {
+    return init_sessions_tools;
+  }
+});

package/dist/skill-loader-BkceKkIg.js

@@ -0,0 +1,7 @@
+const require_chunk = require('./chunk-jS-bbMI5.js');
+const require_skill_loader = require('./skill-loader-DhgIwK4J.js');
+
+require_skill_loader.init_skill_loader();
+exports.buildSkillsContext = require_skill_loader.buildSkillsContext;
+exports.loadSkills = require_skill_loader.loadSkills;
+exports.writeSkill = require_skill_loader.writeSkill;

package/dist/skill-loader-DhgIwK4J.js

@@ -0,0 +1,159 @@
+const require_chunk = require('./chunk-jS-bbMI5.js');
+const fs_extra = require_chunk.__toESM(require("fs-extra"));
+const path = require_chunk.__toESM(require("path"));
+const os = require_chunk.__toESM(require("os"));
+
+//#region packages/core/src/agent/skill-loader.ts
+/** Validate skill id and content (manifest checks). */
+function validateSkill(id, content) {
+	const errors = [];
+	if (!id || id.length > 64) errors.push("id must be 1–64 characters");
+	else if (!ID_REGEX.test(id)) errors.push("id must be lowercase alphanumeric with only - or _");
+	const trimmed = (content || "").trim();
+	if (!trimmed) errors.push("content is empty");
+	if (trimmed.length > MAX_SKILL_CONTENT_SIZE) errors.push(`content exceeds ${MAX_SKILL_CONTENT_SIZE} characters`);
+	return {
+		valid: errors.length === 0,
+		errors
+	};
+}
+/** Extract manifest (title, version) from content. */
+function extractManifest(content) {
+	const titleMatch = content.match(/^#\s+(.+)$/m);
+	const versionMatch = content.match(/^(?:version|Version):\s*(\S+)/m);
+	return {
+		title: titleMatch ? titleMatch[1].trim().slice(0, 120) : void 0,
+		version: versionMatch ? versionMatch[1].trim().slice(0, 32) : void 0
+	};
+}
+async function runBeforeLoad() {
+	for (const h of lifecycleHooks) if (h.onBeforeLoad) await Promise.resolve(h.onBeforeLoad());
+}
+async function runAfterLoad(skills) {
+	for (const h of lifecycleHooks) if (h.onAfterLoad) await Promise.resolve(h.onAfterLoad(skills));
+}
+async function runUnload(skills) {
+	for (const h of lifecycleHooks) if (h.onUnload) await Promise.resolve(h.onUnload(skills));
+}
+function extractCapabilities(content) {
+	const capMatch = content.match(/## Capabilities?\s*\n+([\s\S]*?)(?=\n## |\n# |$)/i);
+	if (capMatch) return capMatch[1].trim().slice(0, 200);
+	const firstPara = content.replace(/^#.*\n+/, "").split(/\n\n/)[0]?.trim();
+	return firstPara ? firstPara.slice(0, 200) : "";
+}
+async function loadSkills(opts) {
+	await runBeforeLoad();
+	const skills = [];
+	for (const base of [BUNDLED_SKILLS, WORKSPACE_SKILLS]) {
+		if (!await fs_extra.default.pathExists(base)) continue;
+		const dirs = await fs_extra.default.readdir(base);
+		for (const id of dirs) {
+			const skillPath = path.default.join(base, id, "SKILL.md");
+			if (!await fs_extra.default.pathExists(skillPath)) continue;
+			const content = await fs_extra.default.readFile(skillPath, "utf8");
+			if (skills.some((s) => s.id === id)) continue;
+			if (!opts?.skipValidation) {
+				const v = validateSkill(id, content);
+				if (!v.valid) continue;
+			}
+			const manifest = extractManifest(content);
+			skills.push({
+				id,
+				path: skillPath,
+				content,
+				capabilities: extractCapabilities(content),
+				title: manifest.title,
+				version: manifest.version
+			});
+		}
+	}
+	lastLoaded = skills;
+	await runAfterLoad(skills);
+	return skills;
+}
+/** Unload current skills (run onUnload), then load again. */
+async function reloadSkills() {
+	await runUnload(lastLoaded);
+	return loadSkills();
+}
+function buildSkillsContext(skills) {
+	if (skills.length === 0) return "";
+	const capabilityList = skills.filter((s) => s.capabilities).map((s) => `- ${s.id}: ${s.capabilities}`).join("\n");
+	const header = capabilityList ? `\nCapability summary:\n${capabilityList}\n\n` : "";
+	const blocks = skills.map((s) => `## Skill: ${s.id}\n\n${s.content}`).join("\n\n---\n\n");
+	return `\n\n# Loaded Skills\n${header}${blocks}\n`;
+}
+/** Capability discovery: return id + summary for each loaded skill. */
+function getSkillCapabilities(skills) {
+	return skills.filter((s) => s.capabilities).map((s) => ({
+		id: s.id,
+		capabilities: s.capabilities
+	}));
+}
+/** Create or overwrite a skill from agent (self-writing skills). */
+async function writeSkill(skillId, opts) {
+	const id = skillId.replace(/[^a-z0-9-_]/gi, "-").toLowerCase() || "unnamed-skill";
+	const dir = path.default.join(WORKSPACE_SKILLS, id);
+	await fs_extra.default.ensureDir(dir);
+	const header = opts.name || id ? `# ${opts.name || id}\n\n${opts.description ? `> ${opts.description}\n\n` : ""}` : "";
+	const full = header + opts.content.trim();
+	await fs_extra.default.writeFile(path.default.join(dir, "SKILL.md"), full, "utf8");
+	return {
+		path: path.default.join(dir, "SKILL.md"),
+		id
+	};
+}
+var HC_DIR, BUNDLED_SKILLS, WORKSPACE_SKILLS, MAX_SKILL_CONTENT_SIZE, ID_REGEX, lifecycleHooks, lastLoaded;
+var init_skill_loader = require_chunk.__esm({ "packages/core/src/agent/skill-loader.ts"() {
+	HC_DIR = path.default.join(os.default.homedir(), ".hyperclaw");
+	BUNDLED_SKILLS = path.default.join(__dirname, "..", "..", "..", "..", "skills");
+	WORKSPACE_SKILLS = path.default.join(HC_DIR, "workspace", "skills");
+	MAX_SKILL_CONTENT_SIZE = 2e5;
+	ID_REGEX = /^[a-z0-9][a-z0-9-_]*$/;
+	lifecycleHooks = [];
+	lastLoaded = [];
+} });
+
+//#endregion
+Object.defineProperty(exports, 'buildSkillsContext', {
+  enumerable: true,
+  get: function () {
+    return buildSkillsContext;
+  }
+});
+Object.defineProperty(exports, 'getSkillCapabilities', {
+  enumerable: true,
+  get: function () {
+    return getSkillCapabilities;
+  }
+});
+Object.defineProperty(exports, 'init_skill_loader', {
+  enumerable: true,
+  get: function () {
+    return init_skill_loader;
+  }
+});
+Object.defineProperty(exports, 'loadSkills', {
+  enumerable: true,
+  get: function () {
+    return loadSkills;
+  }
+});
+Object.defineProperty(exports, 'reloadSkills', {
+  enumerable: true,
+  get: function () {
+    return reloadSkills;
+  }
+});
+Object.defineProperty(exports, 'validateSkill', {
+  enumerable: true,
+  get: function () {
+    return validateSkill;
+  }
+});
+Object.defineProperty(exports, 'writeSkill', {
+  enumerable: true,
+  get: function () {
+    return writeSkill;
+  }
+});

package/dist/skill-runtime--LqxWrp5.js

@@ -0,0 +1,102 @@
+const require_chunk = require('./chunk-jS-bbMI5.js');
+
+//#region packages/core/src/agent/skill-runtime.ts
+/** Extract execution contract from skill content. Parses ## Execution or ## Invoke blocks. */
+function extractExecutionContract(skill) {
+	const content = skill.content || "";
+	const execMatch = content.match(/##\s*(?:Execution|Invoke)\s*\n+([\s\S]*?)(?=\n## |\n# |$)/i);
+	if (!execMatch) return null;
+	const block = execMatch[1].trim();
+	const contract = {
+		skillId: skill.id,
+		invokeMode: "prompt"
+	};
+	const schemaMatch = block.match(/input\s*:\s*\{([^}]+)\}/i) || block.match(/params\s*:\s*\{([^}]+)\}/i);
+	if (schemaMatch) {
+		const props = {};
+		const parts = schemaMatch[1].split(/,\s*/);
+		for (const p of parts) {
+			const [key, typeDesc] = p.split(/\s*:\s*/).map((s) => s.trim());
+			if (key) props[key] = {
+				type: typeDesc || "string",
+				description: ""
+			};
+		}
+		contract.inputSchema = {
+			properties: props,
+			required: Object.keys(props)
+		};
+	}
+	if (block.toLowerCase().includes("subagent") || block.toLowerCase().includes("full run")) contract.invokeMode = "subagent";
+	return contract;
+}
+/** Invoke a skill with params. Runs as focused prompt or subagent call. */
+async function invokeSkill(skillId, params, opts) {
+	const { loadSkills } = await Promise.resolve().then(() => require("./skill-loader-BkceKkIg.js"));
+	const skills = opts?.skills ?? await loadSkills();
+	const skill = skills.find((s) => s.id === skillId);
+	if (!skill) return `Error: Skill "${skillId}" not found.`;
+	const contract = extractExecutionContract(skill);
+	const inputStr = Object.entries(params).map(([k, v]) => `${k}: ${typeof v === "object" ? JSON.stringify(v) : v}`).join(", ");
+	const { runAgentEngine } = await Promise.resolve().then(() => require("./engine-B4eMiTgl.js"));
+	const prompt = `Execute the skill "${skillId}" with these inputs: ${inputStr}\n\nFollow the skill instructions exactly. Output only the result.`;
+	const result = await runAgentEngine(prompt, {});
+	return result.text;
+}
+/** Build tools for skill invocation. Agent can call invoke_skill(skillId, params). */
+function getSkillInvokeTools(skills) {
+	const invokable = skills.filter((s) => extractExecutionContract(s) || s.capabilities);
+	if (invokable.length === 0) return [];
+	const descriptions = invokable.map((s) => `- ${s.id}: ${s.capabilities || s.title || "no description"}`).join("\n");
+	return [{
+		name: "invoke_skill",
+		description: `Invoke a loaded skill by id. Available: ${invokable.map((s) => s.id).join(", ")}. Use when the user wants to run a specific capability.`,
+		input_schema: {
+			type: "object",
+			properties: {
+				skill_id: {
+					type: "string",
+					description: `Skill id. Options: ${invokable.map((s) => s.id).join(", ")}`
+				},
+				params: {
+					type: "object",
+					description: "Optional key-value params for the skill"
+				}
+			},
+			required: ["skill_id"]
+		},
+		handler: async (input) => {
+			const id = String(input.skill_id || "").trim();
+			const params = typeof input.params === "object" && input.params !== null ? input.params : {};
+			if (!id) return "Error: skill_id is required.";
+			return invokeSkill(id, params);
+		}
+	}];
+}
+var init_skill_runtime = require_chunk.__esm({ "packages/core/src/agent/skill-runtime.ts"() {} });
+
+//#endregion
+Object.defineProperty(exports, 'extractExecutionContract', {
+  enumerable: true,
+  get: function () {
+    return extractExecutionContract;
+  }
+});
+Object.defineProperty(exports, 'getSkillInvokeTools', {
+  enumerable: true,
+  get: function () {
+    return getSkillInvokeTools;
+  }
+});
+Object.defineProperty(exports, 'init_skill_runtime', {
+  enumerable: true,
+  get: function () {
+    return init_skill_runtime;
+  }
+});
+Object.defineProperty(exports, 'invokeSkill', {
+  enumerable: true,
+  get: function () {
+    return invokeSkill;
+  }
+});

package/dist/skill-runtime-C5l0Tgt-.js

@@ -0,0 +1,5 @@
+const require_chunk = require('./chunk-jS-bbMI5.js');
+const require_skill_runtime = require('./skill-runtime--LqxWrp5.js');
+
+require_skill_runtime.init_skill_runtime();
+exports.getSkillInvokeTools = require_skill_runtime.getSkillInvokeTools;

package/dist/skill-runtime-DsXK_HYG.js

@@ -0,0 +1,102 @@
+const require_chunk = require('./chunk-jS-bbMI5.js');
+
+//#region packages/core/src/agent/skill-runtime.ts
+/** Extract execution contract from skill content. Parses ## Execution or ## Invoke blocks. */
+function extractExecutionContract(skill) {
+	const content = skill.content || "";
+	const execMatch = content.match(/##\s*(?:Execution|Invoke)\s*\n+([\s\S]*?)(?=\n## |\n# |$)/i);
+	if (!execMatch) return null;
+	const block = execMatch[1].trim();
+	const contract = {
+		skillId: skill.id,
+		invokeMode: "prompt"
+	};
+	const schemaMatch = block.match(/input\s*:\s*\{([^}]+)\}/i) || block.match(/params\s*:\s*\{([^}]+)\}/i);
+	if (schemaMatch) {
+		const props = {};
+		const parts = schemaMatch[1].split(/,\s*/);
+		for (const p of parts) {
+			const [key, typeDesc] = p.split(/\s*:\s*/).map((s) => s.trim());
+			if (key) props[key] = {
+				type: typeDesc || "string",
+				description: ""
+			};
+		}
+		contract.inputSchema = {
+			properties: props,
+			required: Object.keys(props)
+		};
+	}
+	if (block.toLowerCase().includes("subagent") || block.toLowerCase().includes("full run")) contract.invokeMode = "subagent";
+	return contract;
+}
+/** Invoke a skill with params. Runs as focused prompt or subagent call. */
+async function invokeSkill(skillId, params, opts) {
+	const { loadSkills } = await Promise.resolve().then(() => require("./skill-loader-CSxIAcTC.js"));
+	const skills = opts?.skills ?? await loadSkills();
+	const skill = skills.find((s) => s.id === skillId);
+	if (!skill) return `Error: Skill "${skillId}" not found.`;
+	const contract = extractExecutionContract(skill);
+	const inputStr = Object.entries(params).map(([k, v]) => `${k}: ${typeof v === "object" ? JSON.stringify(v) : v}`).join(", ");
+	const { runAgentEngine } = await Promise.resolve().then(() => require("./engine-B8M7dYul.js"));
+	const prompt = `Execute the skill "${skillId}" with these inputs: ${inputStr}\n\nFollow the skill instructions exactly. Output only the result.`;
+	const result = await runAgentEngine(prompt, {});
+	return result.text;
+}
+/** Build tools for skill invocation. Agent can call invoke_skill(skillId, params). */
+function getSkillInvokeTools(skills) {
+	const invokable = skills.filter((s) => extractExecutionContract(s) || s.capabilities);
+	if (invokable.length === 0) return [];
+	const descriptions = invokable.map((s) => `- ${s.id}: ${s.capabilities || s.title || "no description"}`).join("\n");
+	return [{
+		name: "invoke_skill",
+		description: `Invoke a loaded skill by id. Available: ${invokable.map((s) => s.id).join(", ")}. Use when the user wants to run a specific capability.`,
+		input_schema: {
+			type: "object",
+			properties: {
+				skill_id: {
+					type: "string",
+					description: `Skill id. Options: ${invokable.map((s) => s.id).join(", ")}`
+				},
+				params: {
+					type: "object",
+					description: "Optional key-value params for the skill"
+				}
+			},
+			required: ["skill_id"]
+		},
+		handler: async (input) => {
+			const id = String(input.skill_id || "").trim();
+			const params = typeof input.params === "object" && input.params !== null ? input.params : {};
+			if (!id) return "Error: skill_id is required.";
+			return invokeSkill(id, params);
+		}
+	}];
+}
+var init_skill_runtime = require_chunk.__esm({ "packages/core/src/agent/skill-runtime.ts"() {} });
+
+//#endregion
+Object.defineProperty(exports, 'extractExecutionContract', {
+  enumerable: true,
+  get: function () {
+    return extractExecutionContract;
+  }
+});
+Object.defineProperty(exports, 'getSkillInvokeTools', {
+  enumerable: true,
+  get: function () {
+    return getSkillInvokeTools;
+  }
+});
+Object.defineProperty(exports, 'init_skill_runtime', {
+  enumerable: true,
+  get: function () {
+    return init_skill_runtime;
+  }
+});
+Object.defineProperty(exports, 'invokeSkill', {
+  enumerable: true,
+  get: function () {
+    return invokeSkill;
+  }
+});

package/dist/skill-runtime-IVTiqrMR.js

@@ -0,0 +1,5 @@
+const require_chunk = require('./chunk-jS-bbMI5.js');
+const require_skill_runtime = require('./skill-runtime-DsXK_HYG.js');
+
+require_skill_runtime.init_skill_runtime();
+exports.getSkillInvokeTools = require_skill_runtime.getSkillInvokeTools;

package/dist/src-BEVLgaF1.js

@@ -0,0 +1,63 @@
+const require_chunk = require('./chunk-jS-bbMI5.js');
+const require_paths = require('./paths-AIyBxIzm.js');
+const require_browser_tools = require('./browser-tools-YQmwRLLM.js');
+require('./src-DWCUhnD4.js');
+const require_engine = require('./engine-BhT-1M9W.js');
+const require_extraction_tools = require('./extraction-tools-D3qDFBJ1.js');
+const require_inference = require('./inference-CTWJeX9Q.js');
+const require_memory_auto = require('./memory-auto-Bc7euou4.js');
+const require_orchestrator = require('./orchestrator-BSp2M5EU.js');
+const require_pc_access = require('./pc-access-NxBvTrRj.js');
+const require_session_store = require('./session-store-CujxByI6.js');
+const require_sessions_tools = require('./sessions-tools-DHMaTZIs.js');
+const require_skill_loader = require('./skill-loader-DhgIwK4J.js');
+const require_skill_runtime = require('./skill-runtime--LqxWrp5.js');
+const require_vision_tools = require('./vision-tools-CQnBI9aa.js');
+const require_website_watch_tools = require('./website-watch-tools-DraMPxdl.js');
+const require_src$1 = require('./src-Bgu_OxTQ.js');
+
+require_src$1.init_src();
+exports.ACPThreadManager = require_src$1.ACPThreadManager;
+exports.AutoMemory = require_memory_auto.AutoMemory;
+exports.InferenceEngine = require_inference.InferenceEngine;
+exports.appendMemory = require_memory_auto.appendMemory;
+exports.buildSkillsContext = require_skill_loader.buildSkillsContext;
+exports.clearMemory = require_memory_auto.clearMemory;
+exports.createFileSessionStore = require_session_store.createFileSessionStore;
+exports.createPiRPCHandler = require_src$1.createPiRPCHandler;
+exports.extractExecutionContract = require_skill_runtime.extractExecutionContract;
+exports.extractFactsLocally = require_memory_auto.extractFactsLocally;
+exports.formatAgentResponse = require_src$1.formatAgentResponse;
+exports.getAgentHelp = require_src$1.getAgentHelp;
+exports.getBrowserTools = require_browser_tools.getBrowserTools;
+exports.getBuiltinTools = require_inference.getBuiltinTools;
+exports.getConfigPath = require_paths.getConfigPath;
+exports.getEnvFilePath = require_paths.getEnvFilePath;
+exports.getExtractionTools = require_extraction_tools.getExtractionTools;
+exports.getHyperClawDir = require_paths.getHyperClawDir;
+exports.getPCAccessTools = require_pc_access.getPCAccessTools;
+exports.getSessionsTools = require_sessions_tools.getSessionsTools;
+exports.getSkillCapabilities = require_skill_loader.getSkillCapabilities;
+exports.getSkillInvokeTools = require_skill_runtime.getSkillInvokeTools;
+exports.getVisionTools = require_vision_tools.getVisionTools;
+exports.getWebsiteWatchTools = require_website_watch_tools.getWebsiteWatchTools;
+exports.invokeSkill = require_skill_runtime.invokeSkill;
+exports.loadPCAccessConfig = require_pc_access.loadPCAccessConfig;
+exports.loadSkills = require_skill_loader.loadSkills;
+exports.loadSkillsContext = require_engine.loadSkillsContext;
+exports.loadWorkspaceContext = require_engine.loadWorkspaceContext;
+exports.planSteps = require_orchestrator.planSteps;
+exports.readMemory = require_memory_auto.readMemory;
+exports.reloadSkills = require_skill_loader.reloadSkills;
+exports.resolveTools = require_engine.resolveTools;
+exports.runAgent = require_src$1.runAgent;
+exports.runAgentEngine = require_engine.runAgentEngine;
+exports.runMultiStep = require_orchestrator.runMultiStep;
+exports.runMultiStepParallel = require_orchestrator.runMultiStepParallel;
+exports.runWithPlan = require_orchestrator.runWithPlan;
+exports.saveMemoryDirect = require_memory_auto.saveMemoryDirect;
+exports.savePCAccessConfig = require_pc_access.savePCAccessConfig;
+exports.searchMemory = require_memory_auto.searchMemory;
+exports.showMemory = require_memory_auto.showMemory;
+exports.showPCAccessStatus = require_pc_access.showPCAccessStatus;
+exports.validateSkill = require_skill_loader.validateSkill;