@rivus/agent 0.4.1 → 0.5.1

package/dist/rivus-daemon-cli.js

@@ -3,8 +3,8 @@ import { createRequire } from "node:module";
 import { Effect } from "effect";
 import { createHash, randomUUID } from "node:crypto";
 import { pathToFileURL } from "node:url";
-import { dirname, isAbsolute, join, relative, sep } from "node:path";
-import { open, readFile, realpath, stat } from "node:fs/promises";
+import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { lstat, open, readFile, readdir, realpath, stat } from "node:fs/promises";
 import { constants } from "node:fs";
 //#region src/application/plugin/rivus-automation-runtime-definition.ts
 function resolveRivusAutomationRuntimeDefinition(definition, requestedToolIds, requestedSkillIds) {
@@ -108,7 +108,12 @@ async function loadRivusDeployment(options) {
 			continue;
 		}
 		try {
-			const definition = resolveRivusAgentDefinition(catalog, agent);
+			const baseDefinition = resolveRivusAgentDefinition(catalog, agent);
+			const projectSpace = agent.projectSpaceId ? options.manifest.projectSpaces?.find(({ id }) => id === agent.projectSpaceId) : void 0;
+			const definition = projectSpace ? deepFreeze({
+				...baseDefinition,
+				projectSpaceRevision: `project-space-declaration:${JSON.stringify(projectSpace)}`
+			}) : baseDefinition;
 			definitions.push(definition);
 			agentStatuses.push(Object.freeze({
 				agentId: agent.agentId,
@@ -158,6 +163,20 @@ async function loadRivusDeployment(options) {
 	});
 }
 function validateRivusDeploymentManifest(manifest) {
+	const projectSpaceIds = /* @__PURE__ */ new Set();
+	for (const projectSpace of manifest.projectSpaces ?? []) {
+		if (projectSpaceIds.has(projectSpace.id)) throw new Error(`duplicate project space: ${projectSpace.id}`);
+		projectSpaceIds.add(projectSpace.id);
+		validateRelativeProjectPath(projectSpace.root, `project space ${projectSpace.id} root`);
+		validateRelativeProjectPath(projectSpace.workingDirectory, `project space ${projectSpace.id} working directory`);
+		if (projectSpace.skills.sources.length === 0) throw new Error(`project space ${projectSpace.id} must declare at least one Skill source`);
+		const sources = /* @__PURE__ */ new Set();
+		for (const source of projectSpace.skills.sources) {
+			validateRelativeProjectPath(source, `project space ${projectSpace.id} Skill source`);
+			if (sources.has(source)) throw new Error(`project space ${projectSpace.id} contains duplicate Skill source: ${source}`);
+			sources.add(source);
+		}
+	}
 	const pluginIds = /* @__PURE__ */ new Set();
 	for (const plugin of manifest.plugins) {
 		if (pluginIds.has(plugin.id)) throw new Error(`duplicate plugin declaration: ${plugin.id}`);
@@ -170,6 +189,7 @@ function validateRivusDeploymentManifest(manifest) {
 		if (agentIds.has(agent.agentId)) throw new Error(`duplicate agent deployment: ${agent.agentId}`);
 		agentIds.add(agent.agentId);
 		if (!pluginIds.has(agent.pluginId)) throw new Error(`agent ${agent.agentId} references undeclared plugin: ${agent.pluginId}`);
+		if (agent.projectSpaceId && !projectSpaceIds.has(agent.projectSpaceId)) throw new Error(`agent ${agent.agentId} references unknown project space: ${agent.projectSpaceId}`);
 		agentById.set(agent.agentId, agent);
 	}
 	const automationIds = /* @__PURE__ */ new Set();
@@ -204,6 +224,9 @@ function validateRivusDeploymentManifest(manifest) {
 	if (defaultEndpoint.agentId !== defaultAgent.agentId) throw new Error("default endpoint is not bound to the default agent");
 	if (!defaultEndpoint.enabled) throw new Error("default endpoint must be enabled");
 }
+function validateRelativeProjectPath(value, owner) {
+	if (value.trim() === "" || isAbsolute(value) || value.includes("\0")) throw new Error(`${owner} must be a non-empty relative path`);
+}
 function validateModuleSpecifier(moduleSpecifier) {
 	if (moduleSpecifier.trim() === "" || isAbsolute(moduleSpecifier) || /^[a-z][a-z+.-]*:/i.test(moduleSpecifier) || moduleSpecifier.includes("\0")) throw new Error(`invalid plugin module specifier: ${moduleSpecifier}`);
 	if ((moduleSpecifier.startsWith("./") || moduleSpecifier.startsWith("../")) && moduleSpecifier.split(/[\\/]/).includes("..")) throw new Error(`plugin module escapes deployment root: ${moduleSpecifier}`);
@@ -321,8 +344,9 @@ function parseManifest(value) {
 		"defaultAgentId",
 		"defaultEndpointId",
 		"endpoints",
-		"plugins"
-	], "manifest", ["automations"]);
+		"plugins",
+		"projectSpaces"
+	], "manifest", ["automations", "projectSpaces"]);
 	const plugins = array(root.plugins, "manifest.plugins").map((entry, index) => {
 		const plugin = record(entry, `manifest.plugins[${index}]`);
 		exactKeys(plugin, [
@@ -344,9 +368,10 @@ function parseManifest(value) {
 			"memory",
 			"pluginId",
 			"profileId",
+			"projectSpaceId",
 			"skills",
 			"tools"
-		], `manifest.agents[${index}]`, ["memory"]);
+		], `manifest.agents[${index}]`, ["memory", "projectSpaceId"]);
 		const memory = agent.memory === void 0 ? void 0 : record(agent.memory, `manifest.agents[${index}].memory`);
 		if (memory) exactKeys(memory, ["scopes", "tool"], `manifest.agents[${index}].memory`);
 		const skills = record(agent.skills, `manifest.agents[${index}].skills`);
@@ -362,6 +387,7 @@ function parseManifest(value) {
 			}) } : {},
 			pluginId: string(agent.pluginId, `manifest.agents[${index}].pluginId`),
 			profileId: string(agent.profileId, `manifest.agents[${index}].profileId`),
+			...agent.projectSpaceId === void 0 ? {} : { projectSpaceId: string(agent.projectSpaceId, `manifest.agents[${index}].projectSpaceId`) },
 			skills: Object.freeze({ allow: Object.freeze(array(skills.allow, `manifest.agents[${index}].skills.allow`).map((item, itemIndex) => string(item, `manifest.agents[${index}].skills.allow[${itemIndex}]`))) }),
 			tools: Object.freeze({ allow: Object.freeze(array(tools.allow, `manifest.agents[${index}].tools.allow`).map((item, itemIndex) => string(item, `manifest.agents[${index}].tools.allow[${itemIndex}]`))) })
 		});
@@ -428,13 +454,31 @@ function parseManifest(value) {
 			timeZone: string(automation.timeZone, `manifest.automations[${index}].timeZone`)
 		});
 	});
+	const projectSpaces = array(root.projectSpaces ?? [], "manifest.projectSpaces").map((entry, index) => {
+		const projectSpace = record(entry, `manifest.projectSpaces[${index}]`);
+		exactKeys(projectSpace, [
+			"id",
+			"root",
+			"skills",
+			"workingDirectory"
+		], `manifest.projectSpaces[${index}]`);
+		const skills = record(projectSpace.skills, `manifest.projectSpaces[${index}].skills`);
+		exactKeys(skills, ["sources"], `manifest.projectSpaces[${index}].skills`);
+		return Object.freeze({
+			id: string(projectSpace.id, `manifest.projectSpaces[${index}].id`),
+			root: string(projectSpace.root, `manifest.projectSpaces[${index}].root`),
+			skills: Object.freeze({ sources: Object.freeze(array(skills.sources, `manifest.projectSpaces[${index}].skills.sources`).map((item, itemIndex) => string(item, `manifest.projectSpaces[${index}].skills.sources[${itemIndex}]`))) }),
+			workingDirectory: string(projectSpace.workingDirectory, `manifest.projectSpaces[${index}].workingDirectory`)
+		});
+	});
 	return Object.freeze({
 		agents: Object.freeze(agents),
 		automations: Object.freeze(automations),
 		defaultAgentId: string(root.defaultAgentId, "manifest.defaultAgentId"),
 		defaultEndpointId: string(root.defaultEndpointId, "manifest.defaultEndpointId"),
 		endpoints: Object.freeze(endpoints),
-		plugins: Object.freeze(plugins)
+		plugins: Object.freeze(plugins),
+		projectSpaces: Object.freeze(projectSpaces)
 	});
 }
 function record(value, path) {
@@ -458,7 +502,7 @@ function positiveInteger(value, path) {
 	return value;
 }
 function memoryScope(value, path) {
-	if (typeof value !== "string" || !MEMORY_SCOPES.includes(value)) throw new Error(`${path} must be conversation, agent-private, or shared-user-profile`);
+	if (typeof value !== "string" || !MEMORY_SCOPES.includes(value)) throw new Error(`${path} must be conversation, agent-private, project, or shared-user-profile`);
 	return value;
 }
 function groupPolicy(value, path) {
@@ -796,6 +840,9 @@ function createAgentInstanceRegistry(options = {}) {
 		const runtimeGenerationId = createStableId("generation", {
 			agentId: definition.agentId,
 			profileRevision: definition.profileRevision,
+			projectSpaceId: definition.projectSpaceId ?? null,
+			projectSpaceRevision: definition.projectSpaceRevision ?? null,
+			skillGrantRevision: definition.skillGrantSet.revision,
 			toolGrantRevision: definition.toolGrantSet.revision
 		});
 		const bindingId = binding.kind === "endpoint" ? binding.endpointId : binding.automationId;
@@ -955,16 +1002,26 @@ var RivusDeploymentAutomationReadinessError = class extends Error {
 };
 async function createRivusDeploymentDaemon(options) {
 	const deployment = await loadRivusDeployment(options);
+	if ((deployment.manifest.projectSpaces?.length ?? 0) > 0 && !options.resolveProjectSpace) throw new RivusDeploymentDaemonLifecycleError("deployment bootstrap does not provide a Project Space resolver");
+	const projectSpaces = new Map(await Promise.all((deployment.manifest.projectSpaces ?? []).map(async (declaration) => {
+		const projectSpace = await options.resolveProjectSpace({
+			declaration,
+			deploymentRoot: options.deploymentRoot
+		});
+		return [projectSpace.id, projectSpace];
+	})));
 	const definitions = new Map(deployment.definitions.map((definition) => [definition.agentId, definition]));
 	const automationDefinitions = new Map(deployment.automationDefinitions.map((definition) => [definition.id, definition]));
 	const runtimePool = createAgentRuntimePool({
 		createRuntime: (instance) => {
 			const definition = instance.binding.kind === "automation" ? automationDefinitions.get(instance.binding.automationId)?.runtimeDefinition : definitions.get(instance.agentId);
 			if (!definition) throw new RivusDeploymentDaemonLifecycleError(`runtime instance references unknown agent: ${instance.agentId}`);
+			const projectSpace = definition.projectSpaceId ? projectSpaces.get(definition.projectSpaceId) : void 0;
 			return options.createRuntime({
 				...instance,
 				catalog: deployment.catalog,
-				definition
+				definition,
+				...projectSpace ? { projectSpace } : {}
 			});
 		},
 		registry: createAgentInstanceRegistry(options.initialInstanceRecords ? { initialRecords: options.initialInstanceRecords } : {})
@@ -1063,7 +1120,8 @@ async function createRivusDeploymentDaemon(options) {
 					definition: slot.definition,
 					endpointId: slot.definition.id,
 					handle: (input) => handleEndpoint(slot.definition.id, input),
-					instanceId: host.resolveEndpoint(slot.definition.id).instanceId
+					instanceId: host.resolveEndpoint(slot.definition.id).instanceId,
+					...definitions.get(slot.definition.agentId)?.projectSpaceId ? { projectSpaceId: definitions.get(slot.definition.agentId).projectSpaceId } : {}
 				}));
 				degraded ||= slotDegraded;
 			}
@@ -1171,6 +1229,79 @@ async function stopSlots(slots, errors) {
 	}
 }
 //#endregion
+//#region src/domain/project-space.ts
+var InvalidRivusProjectSpace = class extends Error {
+	name = "InvalidRivusProjectSpace";
+};
+//#endregion
+//#region src/infrastructure/workspace/rivus-project-space.ts
+async function resolveRivusProjectSpace(input) {
+	const root = await resolveContainedDirectory(await resolveExistingDirectory(input.deploymentRoot, "deployment root"), input.declaration.root, "Project Space root");
+	const workingDirectory = await resolveContainedDirectory(root, input.declaration.workingDirectory, "Project Space working directory");
+	const skillPaths = await Promise.all(input.declaration.skills.sources.map((source) => resolveContainedPath(root, source, "Project Space Skill source")));
+	await Promise.all(skillPaths.map((path) => assertTreeContainsNoSymbolicLinks(path)));
+	return Object.freeze({
+		id: input.declaration.id,
+		revision: createStableId("project-space", {
+			id: input.declaration.id,
+			root,
+			skillPaths,
+			workingDirectory
+		}),
+		root,
+		skillPaths: Object.freeze(skillPaths),
+		workingDirectory
+	});
+}
+async function assertTreeContainsNoSymbolicLinks(path) {
+	const metadata = await lstat(path);
+	if (metadata.isSymbolicLink()) throw new InvalidRivusProjectSpace(`Project Space Skill source contains a symbolic link: ${path}`);
+	if (!metadata.isDirectory()) return;
+	for (const entry of await readdir(path, { withFileTypes: true })) {
+		const child = resolve(path, entry.name);
+		if (entry.isSymbolicLink()) throw new InvalidRivusProjectSpace(`Project Space Skill source contains a symbolic link: ${child}`);
+		if (entry.isDirectory()) await assertTreeContainsNoSymbolicLinks(child);
+	}
+}
+async function resolveContainedDirectory(base, path, owner) {
+	const resolved = await resolveContainedPath(base, path, owner);
+	if (!(await stat(resolved)).isDirectory()) throw new InvalidRivusProjectSpace(`${owner} must be a directory: ${path}`);
+	return resolved;
+}
+async function resolveContainedPath(base, path, owner) {
+	validateRelativePath(path, owner);
+	const candidate = resolve(base, path);
+	assertContained(base, candidate, owner);
+	let resolved;
+	try {
+		resolved = await realpath(candidate);
+	} catch (cause) {
+		throw new InvalidRivusProjectSpace(`${owner} does not exist: ${path}`, { cause });
+	}
+	assertContained(base, resolved, owner);
+	const metadata = await stat(resolved);
+	if (!metadata.isDirectory() && !metadata.isFile()) throw new InvalidRivusProjectSpace(`${owner} must be a file or directory: ${path}`);
+	return resolved;
+}
+async function resolveExistingDirectory(path, owner) {
+	let resolved;
+	try {
+		resolved = await realpath(path);
+	} catch (cause) {
+		throw new InvalidRivusProjectSpace(`${owner} does not exist`, { cause });
+	}
+	if (!(await stat(resolved)).isDirectory()) throw new InvalidRivusProjectSpace(`${owner} must be a directory`);
+	return resolved;
+}
+function validateRelativePath(path, owner) {
+	if (!path.trim() || path.includes("\0") || isAbsolute(path)) throw new InvalidRivusProjectSpace(`${owner} must be a non-empty relative path`);
+}
+function assertContained(base, candidate, owner) {
+	const relation = relative(base, candidate);
+	if (relation === "" || !relation.startsWith("..") && !isAbsolute(relation)) return;
+	throw new InvalidRivusProjectSpace(`${owner} escapes its trusted root`);
+}
+//#endregion
 //#region src/infrastructure/runtime/configured-rivus-deployment-daemon.ts
 async function createConfiguredRivusDeploymentDaemon(options) {
 	const manifest = await loadRivusDeploymentManifest(options.manifestPath, options.manifestOptions);
@@ -1181,7 +1312,8 @@ async function createConfiguredRivusDeploymentDaemon(options) {
 		deploymentRoot: dirname(options.manifestPath),
 		...options.initialInstanceRecords ? { initialInstanceRecords: options.initialInstanceRecords } : {},
 		loadModule: loadNodeRivusPluginModule,
-		manifest
+		manifest,
+		resolveProjectSpace: (input) => resolveRivusProjectSpace(input)
 	});
 }
 //#endregion
@@ -1284,6 +1416,7 @@ async function createRivusDeploymentCliProcess(factory, context) {
 						memory: {
 							audience: "private",
 							...context.env.RIVUS_LOCAL_CONVERSATION_ID?.trim() ? { conversationId: context.env.RIVUS_LOCAL_CONVERSATION_ID.trim() } : {},
+							...daemon.deployment.definitions.find(({ agentId }) => agentId === daemon.deployment.manifest.defaultAgentId)?.projectSpaceId ? { projectId: daemon.deployment.definitions.find(({ agentId }) => agentId === daemon.deployment.manifest.defaultAgentId).projectSpaceId } : {},
 							subjectId: context.env.RIVUS_LOCAL_SUBJECT_ID?.trim() || "local-operator",
 							tenantId: context.env.RIVUS_MEMORY_TENANT_ID?.trim() || "local"
 						},
@@ -2627,4 +2760,4 @@ function hasRecoveryRunner(daemon) {
 	return typeof daemon.openRecoveryControl === "function";
 }
 //#endregion
-export { loadRivusDeployment as A, resolveNodeRivusPluginModulePath as C, resolveFeishuEndpointCredentials as D, FeishuEndpointCredentialError as E, loadMergedLocalEnvFile as O, loadNodeRivusPluginModule as S, loadRivusDeploymentManifest as T, OpenClawEnvImportError as _, RivusDeploymentDaemonLifecycleError as a, RivusDaemonConfigError as b, InvalidRivusEndpointBinding as c, AgentRuntimeDisposed as d, createAgentRuntimePool as f, createRivusDaemonShutdownController as g, createStableId as h, RivusDeploymentAutomationReadinessError as i, validateRivusDeploymentManifest as j, RivusPluginLoadError as k, createRivusAgentHost as l, createAgentInstanceRegistry as m, createRivusDeploymentCliProcess as n, RivusDeploymentReadinessError as o, AgentInstanceConflict as p, createConfiguredRivusDeploymentDaemon as r, createRivusDeploymentDaemon as s, runRivusDaemonCli as t, AgentInstanceBusy as u, createRivusEnvFromOpenClawConfig as v, RivusDeploymentManifestError as w, loadRivusDaemonConfig as x, formatRivusEnvFile as y };
+export { loadMergedLocalEnvFile as A, loadRivusDaemonConfig as C, loadRivusDeploymentManifest as D, RivusDeploymentManifestError as E, loadRivusDeployment as M, validateRivusDeploymentManifest as N, FeishuEndpointCredentialError as O, RivusDaemonConfigError as S, resolveNodeRivusPluginModulePath as T, createStableId as _, InvalidRivusProjectSpace as a, createRivusEnvFromOpenClawConfig as b, RivusDeploymentReadinessError as c, createRivusAgentHost as d, AgentInstanceBusy as f, createAgentInstanceRegistry as g, AgentInstanceConflict as h, resolveRivusProjectSpace as i, RivusPluginLoadError as j, resolveFeishuEndpointCredentials as k, createRivusDeploymentDaemon as l, createAgentRuntimePool as m, createRivusDeploymentCliProcess as n, RivusDeploymentAutomationReadinessError as o, AgentRuntimeDisposed as p, createConfiguredRivusDeploymentDaemon as r, RivusDeploymentDaemonLifecycleError as s, runRivusDaemonCli as t, InvalidRivusEndpointBinding as u, createRivusDaemonShutdownController as v, loadNodeRivusPluginModule as w, formatRivusEnvFile as x, OpenClawEnvImportError as y };

package/dist/rivus-plugin-registry.js

@@ -15,6 +15,7 @@ var InvalidRivusPlugin = class extends Error {
 const MEMORY_SCOPES = [
 	"conversation",
 	"agent-private",
+	"project",
 	"shared-user-profile"
 ];
 const RIVUS_MEMORY_TOOL_ID = "memory";
@@ -36,6 +37,12 @@ function createMemoryNamespace(binding) {
 			binding.subjectId,
 			binding.scope
 		].map(encode).join("/");
+		case "project": return [
+			binding.tenantId,
+			binding.agentId,
+			binding.projectId ?? "",
+			binding.scope
+		].map(encode).join("/");
 		case "shared-user-profile": return [
 			binding.tenantId,
 			binding.subjectId,
@@ -44,7 +51,7 @@ function createMemoryNamespace(binding) {
 	}
 }
 function restrictMemoryScopesForAudience(scopes, audience) {
-	return audience === "group" ? scopes.filter((scope) => scope === "conversation") : [...scopes];
+	return audience === "group" ? scopes.filter((scope) => scope === "conversation" || scope === "project") : [...scopes];
 }
 function createRivusMemoryToolContract(scopes) {
 	return Object.freeze({
@@ -92,7 +99,7 @@ function createRivusMemoryToolContract(scopes) {
 					type: "string"
 				},
 				...scopes.length === 0 ? {} : { scope: {
-					description: "Optional Host-granted scope for search or propose. Shared User Profile is read-only to the model.",
+					description: "Optional Host-granted scope for search or propose. Confirmed Project and Shared User Profile Memory are read-only to the model.",
 					enum: [...scopes],
 					type: "string"
 				} }
@@ -250,6 +257,7 @@ function resolveRivusAgentDefinition(catalog, deployment) {
 		model: profile.model,
 		pluginId: deployment.pluginId,
 		profileId: deployment.profileId,
+		...deployment.projectSpaceId ? { projectSpaceId: deployment.projectSpaceId } : {},
 		profileRevision,
 		skillGrantSet,
 		skills,

package/dist/rivus-plugin-testkit.d.ts

@@ -118,6 +118,7 @@ interface RivusAgentDeployment {
   readonly agentId: string;
   readonly pluginId: string;
   readonly profileId: string;
+  readonly projectSpaceId?: string;
   readonly endpointIds: ReadonlyArray<string>;
   readonly memory?: {
     readonly scopes: ReadonlyArray<MemoryScope>;
@@ -152,6 +153,8 @@ interface ResolvedRivusAgentDefinition {
   readonly agentId: string;
   readonly pluginId: string;
   readonly profileId: string;
+  readonly projectSpaceId?: string;
+  readonly projectSpaceRevision?: string;
   readonly endpointIds: ReadonlyArray<string>;
   readonly profileRevision: string;
   readonly systemPrompt: string;

package/examples/pi-feishu-deployment.bootstrap.ts

@@ -1,6 +1,6 @@
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { createHash } from "node:crypto";
-import { join } from "node:path";
+import { join, relative } from "node:path";
 import { Effect } from "effect";
 import * as Lark from "@larksuiteoapi/node-sdk";
 import {
@@ -35,6 +35,7 @@ import {
   createLangfuseAgentTelemetry,
   createLazyFeishuWebSocketEventDispatcher,
   createPiAgentLoop,
+  createProjectMemoryPromptPreparer,
   createPiSkillRuntime,
   createPiToolNameResolver,
   createPiToolProxyDefinitions,
@@ -54,6 +55,8 @@ import {
   openJsonlRecoveryControl,
   resolveFeishuEndpointCredentials,
   resolveLangfuseTelemetryConfig,
+  validateProjectSkillCatalog,
+  validateProjectSkillCommand,
   type CreateRivusDeploymentEndpointInput,
   type CreateRivusDeploymentAutomationInput,
   type CreateRivusDeploymentRuntimeInput,
@@ -63,6 +66,7 @@ import {
   type RivusDeploymentBootstrapContext,
   type RivusThinkingLevel
 } from "@rivus/agent";
+import { createPiProjectSkillReadTool } from "@rivus/agent/pi";
 
 type PiSessionOptions = NonNullable<Parameters<typeof createAgentSession>[0]>;
 
@@ -88,12 +92,6 @@ export async function createRivusDeploymentAdapters(context: RivusDeploymentBoot
       request: (input) => request(input).pipe(Effect.map((response) => response as ConfiguredFeishuOpenApiResponse))
     });
   const interactionRegistry = createHumanInteractionEndpointRegistry();
-  const workspaceInstructions = await createAgentsMdInstructionsProvider().resolve({
-    maxBytes: 64 * 1024,
-    workingDirectory: ".",
-    workspaceRoot: await createWorkspaceRootHandle(process.cwd())
-  });
-
   return {
     dispose: () => telemetry?.shutdown(),
     createRecoveryControl: () =>
@@ -240,6 +238,7 @@ export async function createRivusDeploymentAdapters(context: RivusDeploymentBoot
         interactions,
         maxPendingMessages: 100,
         memoryTenantId,
+        ...(input.projectSpaceId ? { projectSpaceId: input.projectSpaceId } : {}),
         onCapacityExceeded: (payload) =>
           replies.reply(payload.event.message.message_id, "Rivus is busy. Please retry in a moment."),
         prepareRun: createFeishuPresentationPreparation({
@@ -278,10 +277,33 @@ export async function createRivusDeploymentAdapters(context: RivusDeploymentBoot
       });
       const resolveToolName = createPiToolNameResolver(input.definition.tools);
       const skillRuntime = createPiSkillRuntime(input.definition.skills);
+      const workingDirectory = input.projectSpace?.workingDirectory ?? process.cwd();
+      const workspaceRoot = input.projectSpace?.root ?? process.cwd();
+      const workspaceInstructions = await createAgentsMdInstructionsProvider().resolve({
+        maxBytes: 64 * 1024,
+        workingDirectory: relative(workspaceRoot, workingDirectory) || ".",
+        workspaceRoot: await createWorkspaceRootHandle(workspaceRoot)
+      });
+      const prepareProjectMemory =
+        input.projectSpace && input.definition.memory.scopes.includes("project")
+          ? createProjectMemoryPromptPreparer({
+              agentId: input.agentId,
+              memory,
+              projectId: input.projectSpace.id
+            })
+          : undefined;
       const sessionRegistry = createPiSessionRegistry({
         createSession: async (firstInput) => {
           let activeInput = firstInput;
           const customTools = [
+            ...(input.projectSpace
+              ? [
+                  createPiProjectSkillReadTool({
+                    cwd: input.projectSpace.workingDirectory,
+                    skillPaths: input.projectSpace.skillPaths
+                  })
+                ]
+              : []),
             ...createPiToolProxyDefinitions({
               agentId: input.agentId,
               approvals: createHumanInteractionToolApprovalGateway({ registry: interactionRegistry }),
@@ -296,9 +318,10 @@ export async function createRivusDeploymentAdapters(context: RivusDeploymentBoot
           ];
           const resourceLoader = new DefaultResourceLoader({
             agentDir: PI_AGENT_DIR,
+            ...(input.projectSpace ? { additionalSkillPaths: [...input.projectSpace.skillPaths] } : {}),
             appendSystemPromptOverride: () =>
               [workspaceInstructions.content, skillRuntime.prompt].filter((content) => content.length > 0),
-            cwd: process.cwd(),
+            cwd: workingDirectory,
             noContextFiles: true,
             noExtensions: true,
             noPromptTemplates: true,
@@ -307,11 +330,14 @@ export async function createRivusDeploymentAdapters(context: RivusDeploymentBoot
             systemPromptOverride: () => input.definition.systemPrompt
           });
           await resourceLoader.reload();
+          const nativeSkillNames = input.projectSpace
+            ? validateProjectSkillCatalog(resourceLoader.getSkills())
+            : new Set<string>();
           const result = await createAgentSession({
             ...piOptions,
             customTools,
             resourceLoader,
-            sessionManager: SessionManager.create(process.cwd(), join(instanceState, "sessions")),
+            sessionManager: SessionManager.create(workingDirectory, join(instanceState, "sessions")),
             tools: customTools.map(({ name }) => name)
           });
           return {
@@ -319,6 +345,10 @@ export async function createRivusDeploymentAdapters(context: RivusDeploymentBoot
               activeInput = loopInput;
             },
             dispose: () => result.session.dispose(),
+            preparePrompt: async (loopInput) => {
+              validateProjectSkillCommand(loopInput.text, nativeSkillNames);
+              return prepareProjectMemory ? prepareProjectMemory(loopInput) : loopInput.text;
+            },
             resolveToolName,
             session: result.session
           };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rivus/agent",
-  "version": "0.4.1",
+  "version": "0.5.1",
   "description": "A local agent daemon core built around a usable agent harness and domain events.",
   "type": "module",
   "license": "MIT",
@@ -34,6 +34,10 @@
       "types": "./dist/acp.d.ts",
       "import": "./dist/acp.js"
     },
+    "./pi": {
+      "types": "./dist/pi.d.ts",
+      "import": "./dist/pi.js"
+    },
     "./testing": {
       "types": "./dist/testing/index.d.ts",
       "import": "./dist/testing/index.js"