@lebronj/pi-suite 0.1.16 → 0.1.18

package/vendor/pi-memory/src/skills/lifecycle.ts

@@ -0,0 +1,205 @@
+import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { basename, dirname, join } from "node:path";
+import { resolveAgentRoots, type PiAgentEnv } from "../paths/resolve-roots.ts";
+
+export type SkillLifecycleKind = "draft" | "generated" | "enabled";
+
+export type SkillLifecycleItem = {
+	kind: SkillLifecycleKind;
+	id: string;
+	name: string;
+	description: string;
+	path: string;
+	enabled: boolean;
+	source?: string;
+	enabledAt?: string;
+};
+
+export type SkillLifecycleList = {
+	drafts: SkillLifecycleItem[];
+	generated: SkillLifecycleItem[];
+	enabled: SkillLifecycleItem[];
+};
+
+export type SkillEnableResult = {
+	source: SkillLifecycleItem;
+	enabled: SkillLifecycleItem;
+	path: string;
+	created: boolean;
+};
+
+export type SkillDisableResult = {
+	id: string;
+	path: string;
+	removed: boolean;
+};
+
+type SkillFrontmatter = {
+	name: string;
+	description: string;
+};
+
+const ENABLED_MANIFEST = ".pi-skill-enabled.json";
+
+export function listMemorySkills(env: PiAgentEnv = process.env): SkillLifecycleList {
+	const roots = resolveAgentRoots(env);
+	const skillsDir = roots.skillsDir;
+	return {
+		drafts: listSkillDir(roots.skillDraftsDir, "draft"),
+		generated: listSkillDir(join(skillsDir, "generated"), "generated"),
+		enabled: listSkillDir(join(skillsDir, "enabled"), "enabled"),
+	};
+}
+
+export function enableMemorySkill(input: string, options: { force?: boolean; env?: PiAgentEnv } = {}): SkillEnableResult {
+	const env = options.env ?? process.env;
+	const roots = resolveAgentRoots(env);
+	if (!roots.agentRoot) throw new Error("skill enable requires PI_AGENT_ROOT or Multica agent env");
+	const source = resolveSourceSkill(input, env);
+	const targetDir = join(roots.skillsDir, "enabled", source.name);
+	const targetPath = join(targetDir, "SKILL.md");
+	if (existsSync(targetPath) && !options.force) throw new Error(`enabled skill '${source.name}' already exists; pass force to replace it`);
+	if (existsSync(targetDir)) rmSync(targetDir, { recursive: true, force: true });
+	mkdirSync(targetDir, { recursive: true });
+	writeFileSync(targetPath, readFileSync(source.path, "utf-8"), "utf-8");
+	const manifest = {
+		name: source.name,
+		description: source.description,
+		source: `${source.kind}:${source.id}`,
+		sourcePath: source.path,
+		enabledAt: new Date().toISOString(),
+	};
+	writeFileSync(join(targetDir, ENABLED_MANIFEST), `${JSON.stringify(manifest, null, 2)}\n`, "utf-8");
+	appendSkillAudit(roots.memoryDir, { action: "enable", ...manifest, targetPath });
+	return {
+		source,
+		enabled: readSkillItem(targetPath, "enabled")!,
+		path: targetPath,
+		created: true,
+	};
+}
+
+export function disableMemorySkill(idOrName: string, env: PiAgentEnv = process.env): SkillDisableResult {
+	const roots = resolveAgentRoots(env);
+	if (!roots.agentRoot) throw new Error("skill disable requires PI_AGENT_ROOT or Multica agent env");
+	const enabled = listSkillDir(join(roots.skillsDir, "enabled"), "enabled");
+	const item = enabled.find((candidate) => candidate.id === idOrName || candidate.name === idOrName);
+	if (!item) throw new Error(`No enabled skill found for '${idOrName}'.`);
+	const skillDir = dirname(item.path);
+	rmSync(skillDir, { recursive: true, force: true });
+	appendSkillAudit(roots.memoryDir, { action: "disable", name: item.name, id: item.id, targetPath: item.path });
+	return { id: item.id, path: item.path, removed: true };
+}
+
+export function formatEnabledSkillsForPrompt(env: PiAgentEnv = process.env): string {
+	const enabled = listMemorySkills(env).enabled;
+	if (enabled.length === 0) return "";
+	return [
+		"<available_skills>",
+		"The following current-agent skills were explicitly enabled by pi-memory. When a task matches, use the read tool to load the SKILL.md at the listed location before applying it.",
+		...enabled.map((skill) => [
+			"  <skill>",
+			`    <name>${escapeXml(skill.name)}</name>`,
+			`    <description>${escapeXml(skill.description)}</description>`,
+			`    <location>${escapeXml(skill.path)}</location>`,
+			"  </skill>",
+		].join("\n")),
+		"</available_skills>",
+	].join("\n");
+}
+
+export function formatSkillList(list: SkillLifecycleList): string {
+	const sections: string[] = [];
+	for (const [label, items] of [["drafts", list.drafts], ["generated", list.generated], ["enabled", list.enabled]] as const) {
+		sections.push(`${label}: ${items.length}`);
+		for (const item of items) {
+			sections.push(`- ${item.kind}:${item.id} (${item.name}) ${item.description} -> ${item.path}`);
+		}
+	}
+	return sections.join("\n");
+}
+
+function resolveSourceSkill(input: string, env: PiAgentEnv): SkillLifecycleItem {
+	const roots = resolveAgentRoots(env);
+	const [rawKind, rawId] = input.includes(":") ? input.split(/:(.*)/s, 2) : ["", input];
+	const kind = rawKind === "draft" || rawKind === "generated" || rawKind === "enabled" ? rawKind : undefined;
+	if (rawKind && !kind) throw new Error(`Unknown skill source '${rawKind}'. Use draft:<id> or generated:<id>.`);
+	const candidates = [
+		...(kind === undefined || kind === "draft" ? listSkillDir(roots.skillDraftsDir, "draft") : []),
+		...(kind === undefined || kind === "generated" ? listSkillDir(join(roots.skillsDir, "generated"), "generated") : []),
+		...(kind === "enabled" ? listSkillDir(join(roots.skillsDir, "enabled"), "enabled") : []),
+	];
+	const id = rawId || rawKind;
+	const item = candidates.find((candidate) => candidate.id === id || candidate.name === id);
+	if (!item) throw new Error(`No skill found for '${input}'.`);
+	if (item.kind === "enabled") throw new Error(`Skill '${item.name}' is already enabled.`);
+	return item;
+}
+
+function listSkillDir(dir: string, kind: SkillLifecycleKind): SkillLifecycleItem[] {
+	if (!existsSync(dir)) return [];
+	const items: SkillLifecycleItem[] = [];
+	for (const entry of readdirSync(dir, { withFileTypes: true })) {
+		if (!entry.isDirectory()) continue;
+		const skillPath = join(dir, entry.name, "SKILL.md");
+		const item = readSkillItem(skillPath, kind, entry.name);
+		if (item) items.push(item);
+	}
+	return items.sort((a, b) => a.id.localeCompare(b.id));
+}
+
+function readSkillItem(skillPath: string, kind: SkillLifecycleKind, id = basename(dirname(skillPath))): SkillLifecycleItem | null {
+	if (!existsSync(skillPath)) return null;
+	const content = readFileSync(skillPath, "utf-8");
+	const frontmatter = parseSkillFrontmatter(content);
+	if (!frontmatter) return null;
+	const manifest = readManifest(dirname(skillPath));
+	return {
+		kind,
+		id,
+		name: frontmatter.name,
+		description: frontmatter.description,
+		path: skillPath,
+		enabled: kind === "enabled",
+		source: manifest?.source,
+		enabledAt: manifest?.enabledAt,
+	};
+}
+
+function parseSkillFrontmatter(content: string): SkillFrontmatter | null {
+	if (!content.startsWith("---\n")) return null;
+	const end = content.indexOf("\n---", 4);
+	if (end < 0) return null;
+	const frontmatter = content.slice(4, end).split("\n");
+	const result: Partial<SkillFrontmatter> = {};
+	for (const line of frontmatter) {
+		const index = line.indexOf(":");
+		if (index < 0) continue;
+		const key = line.slice(0, index).trim();
+		const value = line.slice(index + 1).trim().replace(/^['\"]|['\"]$/g, "");
+		if (key === "name") result.name = value;
+		if (key === "description") result.description = value;
+	}
+	if (!result.name || !result.description) return null;
+	return { name: result.name, description: result.description };
+}
+
+function readManifest(skillDir: string): { source?: string; enabledAt?: string } | null {
+	const manifestPath = join(skillDir, ENABLED_MANIFEST);
+	if (!existsSync(manifestPath)) return null;
+	try {
+		return JSON.parse(readFileSync(manifestPath, "utf-8")) as { source?: string; enabledAt?: string };
+	} catch {
+		return null;
+	}
+}
+
+function appendSkillAudit(memoryDir: string, entry: Record<string, unknown>): void {
+	const auditDir = join(memoryDir, "audit");
+	mkdirSync(auditDir, { recursive: true });
+	writeFileSync(join(auditDir, "skill-lifecycle.jsonl"), `${JSON.stringify({ timestamp: new Date().toISOString(), ...entry })}\n`, { encoding: "utf-8", flag: "a" });
+}
+
+function escapeXml(value: string): string {
+	return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/\"/g, "&quot;").replace(/'/g, "&apos;");
+}

package/vendor/pi-memory/src/sync/connector.ts

@@ -0,0 +1,146 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { resolveAgentRoots, type PiAgentEnv } from "../paths/resolve-roots.ts";
+import { receiveDelivery } from "./downflow.ts";
+import { detectSensitivity } from "./sensitivity.ts";
+import type { Delivery } from "./schemas.ts";
+
+export type SyncUploadResult = {
+	ok: boolean;
+	skipped?: string;
+	candidates: number;
+	feedback: number;
+	profiles: number;
+};
+
+export type SyncPullResult = {
+	ok: boolean;
+	skipped?: string;
+	received: number;
+	rejected: number;
+	written: string[];
+};
+
+type UploadCheckpoint = {
+	uploaded_at?: string;
+	uploadedCandidateIds?: string[];
+	feedbackLineCount?: number;
+	profiles?: number;
+};
+
+export async function syncUpload(env: PiAgentEnv & Record<string, string | undefined> = process.env): Promise<SyncUploadResult> {
+	const baseUrl = env.PI_MEMORY_REMOTE_URL?.replace(/\/+$/, "");
+	const token = env.PI_MEMORY_REMOTE_TOKEN;
+	if (!baseUrl || !token) return { ok: true, skipped: "PI_MEMORY_REMOTE_URL or PI_MEMORY_REMOTE_TOKEN not configured", candidates: 0, feedback: 0, profiles: 0 };
+	const roots = resolveAgentRoots(env);
+	if (!roots.syncQueueDir || !roots.feedbackDir || !roots.profileDir || !roots.agentId) throw new Error("memory sync upload requires PI_AGENT_ROOT or Multica agent env");
+	const checkpointPath = join(roots.syncQueueDir, ".upload-checkpoint.json");
+	const checkpoint = readCheckpoint(checkpointPath);
+	const uploadedIds = new Set(checkpoint.uploadedCandidateIds || []);
+	const memoryCandidates = readJsonl(join(roots.syncQueueDir, "memory-candidates.jsonl"));
+	const skillCandidates = readJsonl(join(roots.syncQueueDir, "skill-candidates.jsonl"));
+	const candidates = [...memoryCandidates, ...skillCandidates]
+		.filter((entry) => detectSensitivity(JSON.stringify(entry)) !== "secret")
+		.filter((entry) => !uploadedIds.has(candidateId(entry)));
+	const feedbackLines = readJsonlWithCount(join(roots.feedbackDir, "feedback.jsonl"));
+	const feedback = feedbackLines.entries
+		.slice(checkpoint.feedbackLineCount || 0)
+		.filter((entry) => detectSensitivity(JSON.stringify(entry)) !== "secret");
+	const profiles = readProfiles(roots.profileDir);
+	if (candidates.length > 0) await postJson(`${baseUrl}/api/evolution/submissions`, { candidates }, token);
+	if (Object.keys(profiles).length > 0) await postJson(`${baseUrl}/api/agents/${encodeURIComponent(roots.agentId)}/evolution-profile`, { profiles }, token);
+	if (feedback.length > 0) await postJson(`${baseUrl}/api/evolution/feedback`, { feedback }, token);
+	const nextUploadedIds = [...uploadedIds, ...candidates.map(candidateId).filter(Boolean)];
+	writeCheckpoint(checkpointPath, {
+		uploaded_at: new Date().toISOString(),
+		uploadedCandidateIds: [...new Set(nextUploadedIds)],
+		feedbackLineCount: feedbackLines.lineCount,
+		profiles: Object.keys(profiles).length,
+	});
+	return { ok: true, candidates: candidates.length, feedback: feedback.length, profiles: Object.keys(profiles).length };
+}
+
+export async function syncPull(env: PiAgentEnv & Record<string, string | undefined> = process.env, limit = 20): Promise<SyncPullResult> {
+	const baseUrl = env.PI_MEMORY_REMOTE_URL?.replace(/\/+$/, "");
+	const token = env.PI_MEMORY_REMOTE_TOKEN;
+	const roots = resolveAgentRoots(env);
+	if (!baseUrl || !token) return { ok: true, skipped: "PI_MEMORY_REMOTE_URL or PI_MEMORY_REMOTE_TOKEN not configured", received: 0, rejected: 0, written: [] };
+	if (!roots.agentId) throw new Error("memory sync pull requires MULTICA_AGENT_ID or PI_AGENT_ROOT-derived agent context");
+	const response = await fetch(`${baseUrl}/api/agents/${encodeURIComponent(roots.agentId)}/evolution-deliveries?limit=${encodeURIComponent(String(limit))}`, {
+		headers: { authorization: `Bearer ${token}` },
+	});
+	if (!response.ok) throw new Error(`pull failed: HTTP ${response.status}`);
+	const payload = await response.json() as { deliveries?: Delivery[] } | Delivery[];
+	const deliveries = Array.isArray(payload) ? payload : payload.deliveries || [];
+	let received = 0;
+	let rejected = 0;
+	const written: string[] = [];
+	for (const delivery of deliveries) {
+		const result = receiveDelivery(delivery, env);
+		if (result.accepted) {
+			received += 1;
+			written.push(...result.written);
+		} else {
+			rejected += 1;
+		}
+	}
+	return { ok: true, received, rejected, written };
+}
+
+function readJsonl(filePath: string): unknown[] {
+	return readJsonlWithCount(filePath).entries;
+}
+
+function readJsonlWithCount(filePath: string): { entries: unknown[]; lineCount: number } {
+	if (!existsSync(filePath)) return { entries: [], lineCount: 0 };
+	const entries: unknown[] = [];
+	let lineCount = 0;
+	for (const line of readFileSync(filePath, "utf-8").split("\n")) {
+		if (!line.trim()) continue;
+		lineCount += 1;
+		try {
+			entries.push(JSON.parse(line));
+		} catch {
+			// Ignore malformed queue lines; curator/audit can surface them separately.
+		}
+	}
+	return { entries, lineCount };
+}
+
+function readProfiles(profileDir: string): Record<string, string> {
+	const result: Record<string, string> = {};
+	for (const name of ["user-profile.md", "agent-profile.md", "task-profile.md", "capability-profile.md"]) {
+		const filePath = join(profileDir, name);
+		if (existsSync(filePath)) result[name] = readFileSync(filePath, "utf-8");
+	}
+	return result;
+}
+
+function candidateId(value: unknown): string {
+	if (!value || typeof value !== "object") return "";
+	const record = value as { local_unit_id?: unknown; signature?: unknown };
+	return typeof record.local_unit_id === "string" ? record.local_unit_id : typeof record.signature === "string" ? record.signature : "";
+}
+
+function readCheckpoint(filePath: string): UploadCheckpoint {
+	if (!existsSync(filePath)) return {};
+	try {
+		return JSON.parse(readFileSync(filePath, "utf-8")) as UploadCheckpoint;
+	} catch {
+		return {};
+	}
+}
+
+async function postJson(url: string, body: unknown, token: string): Promise<void> {
+	const response = await fetch(url, {
+		method: "POST",
+		headers: { authorization: `Bearer ${token}`, "content-type": "application/json" },
+		body: JSON.stringify(body),
+	});
+	if (!response.ok) throw new Error(`upload failed: HTTP ${response.status}`);
+}
+
+function writeCheckpoint(filePath: string, value: unknown): void {
+	mkdirSync(dirname(filePath), { recursive: true });
+	writeFileSync(filePath, `${JSON.stringify(value, null, 2)}\n`, "utf-8");
+}

package/vendor/pi-memory/src/sync/downflow.ts

@@ -0,0 +1,54 @@
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { resolveAgentRoots, type PiAgentEnv } from "../paths/resolve-roots.ts";
+import { detectSensitivity } from "./sensitivity.ts";
+import type { Delivery } from "./schemas.ts";
+
+export type ReceiveDeliveryResult = {
+	written: string[];
+	accepted: boolean;
+	reason?: string;
+};
+
+export function receiveDelivery(delivery: Delivery, env: PiAgentEnv = process.env): ReceiveDeliveryResult {
+	const roots = resolveAgentRoots(env);
+	if (!roots.inboxDir || !roots.sharedCacheDir || !roots.agentRoot) throw new Error("downflow receive requires PI_AGENT_ROOT or Multica agent env");
+	if (detectSensitivity(JSON.stringify(delivery)) === "secret") return { written: [], accepted: false, reason: "secret-like delivery rejected" };
+	const id = safeName(delivery.shared_unit_id || delivery.id);
+	const written: string[] = [];
+	if (delivery.unit_type === "memory") {
+		const inboxPath = join(roots.inboxDir, "memory", `${id}.json`);
+		const cachePath = join(roots.sharedCacheDir, "memory", `${id}.json`);
+		writeJsonIfChanged(inboxPath, delivery);
+		writeJsonIfChanged(cachePath, delivery);
+		written.push(inboxPath, cachePath);
+		return { written, accepted: true };
+	}
+	const inboxDir = join(roots.inboxDir, "skills", id);
+	const generatedDir = join(roots.agentRoot, "skills", "generated", id);
+	mkdirSync(inboxDir, { recursive: true });
+	mkdirSync(generatedDir, { recursive: true });
+	const skillContent = delivery.content.endsWith("\n") ? delivery.content : `${delivery.content}\n`;
+	writeTextIfChanged(join(inboxDir, "SKILL.md"), skillContent);
+	writeTextIfChanged(join(generatedDir, "SKILL.md"), skillContent);
+	writeJsonIfChanged(join(inboxDir, "delivery.json"), delivery);
+	written.push(join(inboxDir, "SKILL.md"), join(generatedDir, "SKILL.md"));
+	return { written, accepted: true };
+}
+
+function safeName(value: string): string {
+	return value.replace(/[^a-zA-Z0-9_.-]+/g, "-").replace(/^-+|-+$/g, "") || "delivery";
+}
+
+function writeJsonIfChanged(filePath: string, value: unknown): void {
+	writeTextIfChanged(filePath, `${JSON.stringify(value, null, 2)}\n`);
+}
+
+function writeTextIfChanged(filePath: string, value: string): void {
+	mkdirSync(dirname(filePath), { recursive: true });
+	if (existsSync(filePath)) {
+		// Avoid rewriting cache files on duplicate pulls.
+		return;
+	}
+	writeFileSync(filePath, value, "utf-8");
+}

package/vendor/pi-memory/src/sync/feedback.ts

@@ -0,0 +1,30 @@
+import { appendFileSync, mkdirSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { resolveAgentRoots, type PiAgentEnv } from "../paths/resolve-roots.ts";
+import { detectSensitivity } from "./sensitivity.ts";
+import type { FeedbackEvent } from "./schemas.ts";
+
+export function appendFeedbackEvent(event: FeedbackEvent, env: PiAgentEnv = process.env): string {
+	const roots = resolveAgentRoots(env);
+	if (!roots.feedbackDir) throw new Error("feedback directory requires PI_AGENT_ROOT or Multica agent env");
+	const serialized = JSON.stringify(event);
+	if (detectSensitivity(serialized) === "secret") throw new Error("feedback event appears to contain a secret");
+	const filePath = join(roots.feedbackDir, "feedback.jsonl");
+	mkdirSync(dirname(filePath), { recursive: true });
+	appendFileSync(filePath, `${serialized}\n`, "utf-8");
+	return filePath;
+}
+
+export function buildFeedbackEvent(input: Omit<FeedbackEvent, "workspace_id" | "agent_id" | "run_id" | "timestamp"> & Partial<Pick<FeedbackEvent, "workspace_id" | "agent_id" | "run_id" | "timestamp">>, env: PiAgentEnv = process.env): FeedbackEvent {
+	const roots = resolveAgentRoots(env);
+	const workspaceId = input.workspace_id || roots.workspaceId;
+	const agentId = input.agent_id || roots.agentId;
+	if (!workspaceId || !agentId) throw new Error("feedback event requires workspace_id and agent_id");
+	return {
+		...input,
+		workspace_id: workspaceId,
+		agent_id: agentId,
+		run_id: input.run_id || env.MULTICA_RUN_ID,
+		timestamp: input.timestamp || new Date().toISOString(),
+	};
+}

package/vendor/pi-memory/src/sync/queue.ts

@@ -0,0 +1,40 @@
+import { appendFileSync, existsSync, mkdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { createHash } from "node:crypto";
+import { resolveAgentRoots, type PiAgentEnv } from "../paths/resolve-roots.ts";
+import { detectSensitivity, redactLocalPaths } from "./sensitivity.ts";
+import type { EvolutionCandidate } from "./schemas.ts";
+
+export function appendEvolutionCandidate(input: Omit<EvolutionCandidate, "workspace_id" | "agent_id" | "local_unit_id" | "signature" | "created_at"> & Partial<Pick<EvolutionCandidate, "workspace_id" | "agent_id" | "local_unit_id" | "signature" | "created_at">>, env: PiAgentEnv = process.env): { path: string; candidate: EvolutionCandidate; appended: boolean } {
+	const roots = resolveAgentRoots(env);
+	if (!roots.syncQueueDir) throw new Error("sync queue requires PI_AGENT_ROOT or Multica agent env");
+	const workspaceId = input.workspace_id || roots.workspaceId;
+	const agentId = input.agent_id || roots.agentId;
+	if (!workspaceId || !agentId) throw new Error("candidate requires workspace_id and agent_id");
+	const sensitivity = input.sensitivity || detectSensitivity(input.content);
+	if (sensitivity === "secret") throw new Error("secret-like content cannot enter sync_queue");
+	const content = sensitivity === "local_path" ? redactLocalPaths(input.content) : input.content;
+	const signature = input.signature || stableHash([input.type, content, input.tags.join(",")].join("\n"));
+	const candidate: EvolutionCandidate = {
+		...input,
+		workspace_id: workspaceId,
+		agent_id: agentId,
+		local_unit_id: input.local_unit_id || `${input.type}_${signature.slice(0, 12)}`,
+		signature,
+		content,
+		sensitivity,
+		created_at: input.created_at || new Date().toISOString(),
+	};
+	const filePath = join(roots.syncQueueDir, input.type === "skill" ? "skill-candidates.jsonl" : "memory-candidates.jsonl");
+	mkdirSync(roots.syncQueueDir, { recursive: true });
+	if (existsSync(filePath)) {
+		const exists = readFileSync(filePath, "utf-8").split("\n").some((line) => line.includes(`\"local_unit_id\":\"${candidate.local_unit_id}\"`));
+		if (exists) return { path: filePath, candidate, appended: false };
+	}
+	appendFileSync(filePath, `${JSON.stringify(candidate)}\n`, "utf-8");
+	return { path: filePath, candidate, appended: true };
+}
+
+function stableHash(value: string): string {
+	return createHash("sha256").update(value).digest("hex");
+}

package/vendor/pi-memory/src/sync/schemas.ts

@@ -0,0 +1,44 @@
+export type EvolutionUnitType = "memory" | "skill" | "workflow" | "tool_pattern" | "preference";
+export type FeedbackEventType = "injected" | "used" | "ignored" | "success" | "failure" | "conflict";
+
+export type EvolutionCandidate = {
+	type: EvolutionUnitType;
+	workspace_id: string;
+	agent_id: string;
+	local_unit_id: string;
+	signature: string;
+	content: string;
+	tags: string[];
+	source: "local_curator" | "memory_review" | "manual";
+	suggested_scope: "agent" | "workspace" | "project" | "team" | "global" | "agent_type";
+	status: "candidate" | "uploaded" | "rejected";
+	sensitivity?: "none" | "local_path" | "personal" | "secret" | "unknown";
+	source_candidate_ids?: string[];
+	created_at: string;
+};
+
+export type FeedbackEvent = {
+	shared_unit_id: string;
+	unit_type: "memory" | "skill";
+	workspace_id: string;
+	agent_id: string;
+	run_id?: string;
+	task_type?: string;
+	event: FeedbackEventType;
+	outcome?: "success" | "failure" | "neutral";
+	timestamp: string;
+};
+
+export type Delivery = {
+	id: string;
+	shared_unit_id: string;
+	unit_type: "memory" | "skill";
+	content: string;
+	tags?: string[];
+	score?: number;
+	task_types?: string[];
+	tools?: string[];
+	project_types?: string[];
+	required_tools?: string[];
+	metadata?: Record<string, unknown>;
+};

package/vendor/pi-memory/src/sync/sensitivity.ts

@@ -0,0 +1,18 @@
+const SECRET_PATTERNS: RegExp[] = [
+	/\b(?:api[_-]?key|token|secret|password|passwd|authorization|cookie)\b\s*[:=]\s*[^\s]+/i,
+	/\b(?:sk|pk|ghp|gho|github_pat)_[A-Za-z0-9_]{16,}\b/,
+	/\b[A-Z0-9]{4}(?:-[A-Z0-9]{4}){3,}\b/,
+	/\b\d{6}\b.*\b(?:otp|2fa|mfa|code)\b/i,
+];
+
+export function detectSensitivity(text: string): "none" | "local_path" | "secret" {
+	if (SECRET_PATTERNS.some((pattern) => pattern.test(text))) return "secret";
+	if (/\/(?:home|Users|workspaces)\/[\w.-]+\//.test(text) || /[A-Za-z]:\\Users\\[^\\]+\\/.test(text)) return "local_path";
+	return "none";
+}
+
+export function redactLocalPaths(text: string): string {
+	return text
+		.replace(/\/(?:home|Users|workspaces)\/[\w.-]+\//g, "~/")
+		.replace(/[A-Za-z]:\\Users\\[^\\]+\\/g, "<user-home>\\");
+}

package/vendor/pi-memory/test/manager-service.test.ts

@@ -0,0 +1,17 @@
+import assert from "node:assert/strict";
+import { mkdtempSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { test } from "node:test";
+import { getCuratorManagerServiceStatus } from "../src/index.ts";
+
+test("manager service status defaults to six-hour dirty-root scan schedule", () => {
+	const root = mkdtempSync(join(tmpdir(), "pi-memory-manager-service-"));
+	const registryPath = join(root, "multica_workspaces", ".pi-curator", "registry.json");
+	const result = getCuratorManagerServiceStatus({ registryPath, cliPath: "/tmp/jhp-pi-memory-curator" });
+	assert.equal(result.ok, true);
+	assert.equal(result.state.enabled, false);
+	assert.equal(result.state.schedule, "0 */6 * * *");
+	assert.equal(result.state.registryPath, registryPath);
+	assert.match(result.message, /Local curator manager service: disabled/);
+});

package/vendor/pi-memory/test/resolve-roots.test.ts

@@ -0,0 +1,63 @@
+import assert from "node:assert/strict";
+import { existsSync, mkdtempSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { test } from "node:test";
+import { ensureAgentRoot, resolveAgentRoot, resolveMemoryRoot, resolveSkillDraftRoot } from "../src/index.ts";
+
+test("resolver keeps standalone fallback roots", () => {
+	const env = { HOME: "/home/tester" };
+	assert.equal(resolveAgentRoot(env), undefined);
+	assert.equal(resolveMemoryRoot(env), "/home/tester/.pi/agent/memory");
+	assert.equal(resolveSkillDraftRoot(env), "/home/tester/.pi/agent/skill-drafts");
+});
+
+test("resolver honors explicit memory and skill roots", () => {
+	const env = {
+		HOME: "/home/tester",
+		PI_MEMORY_DIR: "/tmp/pi-agent-a/memory",
+		PI_SKILL_DRAFTS_DIR: "/tmp/pi-agent-a/skills/drafts",
+	};
+	assert.equal(resolveMemoryRoot(env), "/tmp/pi-agent-a/memory");
+	assert.equal(resolveSkillDraftRoot(env), "/tmp/pi-agent-a/skills/drafts");
+});
+
+test("resolver derives Multica agent root without member id in v1", () => {
+	const env = {
+		HOME: "/home/tester",
+		MULTICA_WORKSPACES_ROOT: "/tmp/multica",
+		MULTICA_WORKSPACE_ID: "workspace_1",
+		MULTICA_AGENT_ID: "agent_a",
+		MULTICA_MEMBER_ID: "member_ignored",
+	};
+	assert.equal(resolveAgentRoot(env), "/tmp/multica/workspace_1/.pi/agents/agent_a");
+	assert.equal(resolveMemoryRoot(env), "/tmp/multica/workspace_1/.pi/agents/agent_a/memory");
+	assert.equal(resolveSkillDraftRoot(env), "/tmp/multica/workspace_1/.pi/agents/agent_a/skills/drafts");
+});
+
+test("ensureAgentRoot initializes Multica local self-evolution layout", () => {
+	const root = mkdtempSync(join(tmpdir(), "pi-agent-root-"));
+	const agentRoot = join(root, "workspace_1", ".pi", "agents", "agent_a");
+	ensureAgentRoot({ PI_AGENT_ROOT: agentRoot, HOME: root });
+	for (const rel of [
+		"memory/MEMORY.md",
+		"memory/USER.md",
+		"memory/STATE.md",
+		"memory/REVIEW.md",
+		"memory/SCRATCHPAD.md",
+		"memory/daily",
+		"memory/audit",
+		"skills/drafts",
+		"skills/generated",
+		"skills/enabled",
+		"inbox/memory",
+		"inbox/skills",
+		"shared-cache/memory",
+		"shared-cache/skills",
+		"profile",
+		"feedback/feedback.jsonl",
+		"sync_queue",
+	]) {
+		assert.equal(existsSync(join(agentRoot, rel)), true, rel);
+	}
+});

package/vendor/pi-memory/test/review-summary.test.ts

@@ -0,0 +1,36 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { countPendingReviewItems, formatPendingReviewList, listPendingReviewItems } from "../src/index.ts";
+
+const reviewText = [
+	`[type:review status:proposed id:mem_123 kind:memory_promotion confidence:high promotes_to:user]
+Proposal: Promote reviewed candidate to user.
+Memory: [type:preference]
+Use LSP rename for cross-file refactors.`,
+	`[type:review status:proposed id:skill_123 kind:skill_promotion confidence:high promotes_to:/tmp/skills/demo/SKILL.md]
+Title: Demo Skill
+Description: Use when repeated evidence appears.`,
+	`[type:review status:approved id:mem_done kind:memory_promotion]
+Already done.`,
+	`not valid metadata but should not throw`,
+].join("\n§\n");
+
+test("counts pending memory and skill proposals", () => {
+	assert.deepEqual(countPendingReviewItems(reviewText), { memory: 1, skill: 1, incoming: 0, total: 2 });
+});
+
+test("lists pending proposals with filters", () => {
+	const memory = listPendingReviewItems(reviewText, { type: "memory" });
+	assert.equal(memory.length, 1);
+	assert.equal(memory[0].id, "mem_123");
+	const skill = listPendingReviewItems(reviewText, { type: "skill" });
+	assert.equal(skill.length, 1);
+	assert.equal(skill[0].id, "skill_123");
+});
+
+test("formats pending review list", () => {
+	const text = formatPendingReviewList(listPendingReviewItems(reviewText), countPendingReviewItems(reviewText));
+	assert.match(text, /1 memory \/ 1 skill/);
+	assert.match(text, /mem_123/);
+	assert.match(text, /skill_123/);
+});