@lebronj/pi-suite 0.1.16 → 0.1.18

package/vendor/pi-memory/src/paths/resolve-roots.ts

@@ -0,0 +1,155 @@
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+
+export type PiAgentEnv = Partial<
+	Record<
+		| "PI_AGENT_ROOT"
+		| "PI_MEMORY_DIR"
+		| "PI_SKILL_DRAFTS_DIR"
+		| "PI_AGENT_INBOX_DIR"
+		| "PI_AGENT_SHARED_CACHE_DIR"
+		| "PI_AGENT_PROFILE_DIR"
+		| "PI_AGENT_FEEDBACK_DIR"
+		| "PI_AGENT_SYNC_QUEUE_DIR"
+		| "MULTICA_WORKSPACES_ROOT"
+		| "MULTICA_WORKSPACE_ID"
+		| "MULTICA_AGENT_ID"
+		| "MULTICA_RUN_ID"
+		| "HOME"
+		| "USERPROFILE"
+		| "HOMEDRIVE"
+		| "HOMEPATH",
+		string | undefined
+	>
+>;
+
+export type ResolvedAgentRoots = {
+	agentRoot?: string;
+	memoryDir: string;
+	skillDraftsDir: string;
+	skillsDir: string;
+	inboxDir?: string;
+	sharedCacheDir?: string;
+	profileDir?: string;
+	feedbackDir?: string;
+	syncQueueDir?: string;
+	workspaceId?: string;
+	agentId?: string;
+};
+
+function homeDir(env: PiAgentEnv): string {
+	return env.HOME ?? env.USERPROFILE ?? (env.HOMEDRIVE && env.HOMEPATH ? `${env.HOMEDRIVE}${env.HOMEPATH}` : undefined) ?? "~";
+}
+
+function expandHome(input: string, env: PiAgentEnv): string {
+	if (input === "~") return homeDir(env);
+	if (input.startsWith("~/")) return join(homeDir(env), input.slice(2));
+	return input;
+}
+
+function cleanSegment(value: string | undefined): string | undefined {
+	const trimmed = value?.trim();
+	if (!trimmed) return undefined;
+	return trimmed.replace(/[\\/\0]/g, "-");
+}
+
+export function resolveAgentRoot(env: PiAgentEnv = process.env): string | undefined {
+	if (env.PI_AGENT_ROOT?.trim()) return resolve(expandHome(env.PI_AGENT_ROOT.trim(), env));
+	const workspaceId = cleanSegment(env.MULTICA_WORKSPACE_ID);
+	const agentId = cleanSegment(env.MULTICA_AGENT_ID);
+	if (!workspaceId || !agentId) return undefined;
+	const workspacesRoot = resolve(expandHome(env.MULTICA_WORKSPACES_ROOT || "~/multica_workspaces", env));
+	return join(workspacesRoot, workspaceId, ".pi", "agents", agentId);
+}
+
+export function resolveMemoryRoot(env: PiAgentEnv = process.env): string {
+	if (env.PI_MEMORY_DIR?.trim()) return resolve(expandHome(env.PI_MEMORY_DIR.trim(), env));
+	const agentRoot = resolveAgentRoot(env);
+	if (agentRoot) return join(agentRoot, "memory");
+	return join(homeDir(env), ".pi", "agent", "memory");
+}
+
+export function resolveSkillDraftRoot(env: PiAgentEnv = process.env): string {
+	if (env.PI_SKILL_DRAFTS_DIR?.trim()) return resolve(expandHome(env.PI_SKILL_DRAFTS_DIR.trim(), env));
+	const agentRoot = resolveAgentRoot(env);
+	if (agentRoot) return join(agentRoot, "skills", "drafts");
+	return join(homeDir(env), ".pi", "agent", "skill-drafts");
+}
+
+function resolveAgentSubdir(envName: keyof PiAgentEnv, fallbackName: string, env: PiAgentEnv): string | undefined {
+	const explicit = env[envName];
+	if (explicit?.trim()) return resolve(expandHome(explicit.trim(), env));
+	const agentRoot = resolveAgentRoot(env);
+	return agentRoot ? join(agentRoot, fallbackName) : undefined;
+}
+
+export function resolveInboxDir(env: PiAgentEnv = process.env): string | undefined {
+	return resolveAgentSubdir("PI_AGENT_INBOX_DIR", "inbox", env);
+}
+
+export function resolveSharedCacheDir(env: PiAgentEnv = process.env): string | undefined {
+	return resolveAgentSubdir("PI_AGENT_SHARED_CACHE_DIR", "shared-cache", env);
+}
+
+export function resolveProfileDir(env: PiAgentEnv = process.env): string | undefined {
+	return resolveAgentSubdir("PI_AGENT_PROFILE_DIR", "profile", env);
+}
+
+export function resolveFeedbackDir(env: PiAgentEnv = process.env): string | undefined {
+	return resolveAgentSubdir("PI_AGENT_FEEDBACK_DIR", "feedback", env);
+}
+
+export function resolveSyncQueueDir(env: PiAgentEnv = process.env): string | undefined {
+	return resolveAgentSubdir("PI_AGENT_SYNC_QUEUE_DIR", "sync_queue", env);
+}
+
+export function resolveAgentRoots(env: PiAgentEnv = process.env): ResolvedAgentRoots {
+	const agentRoot = resolveAgentRoot(env);
+	const memoryDir = resolveMemoryRoot(env);
+	const skillDraftsDir = resolveSkillDraftRoot(env);
+	return {
+		agentRoot,
+		memoryDir,
+		skillDraftsDir,
+		skillsDir: agentRoot ? join(agentRoot, "skills") : dirname(skillDraftsDir),
+		inboxDir: resolveInboxDir(env),
+		sharedCacheDir: resolveSharedCacheDir(env),
+		profileDir: resolveProfileDir(env),
+		feedbackDir: resolveFeedbackDir(env),
+		syncQueueDir: resolveSyncQueueDir(env),
+		workspaceId: cleanSegment(env.MULTICA_WORKSPACE_ID),
+		agentId: cleanSegment(env.MULTICA_AGENT_ID),
+	};
+}
+
+function ensureFile(filePath: string, content = ""): void {
+	if (existsSync(filePath)) return;
+	mkdirSync(dirname(filePath), { recursive: true });
+	writeFileSync(filePath, content, "utf-8");
+}
+
+export function ensureAgentRoot(rootOrEnv: string | PiAgentEnv = process.env): ResolvedAgentRoots {
+	const roots = typeof rootOrEnv === "string" ? resolveAgentRoots({ ...process.env, PI_AGENT_ROOT: rootOrEnv }) : resolveAgentRoots(rootOrEnv);
+	mkdirSync(roots.memoryDir, { recursive: true });
+	mkdirSync(join(roots.memoryDir, "daily"), { recursive: true });
+	mkdirSync(join(roots.memoryDir, "audit"), { recursive: true });
+	for (const name of ["MEMORY.md", "USER.md", "STATE.md", "REVIEW.md"]) ensureFile(join(roots.memoryDir, name));
+	ensureFile(join(roots.memoryDir, "SCRATCHPAD.md"), "# Scratchpad\n");
+	ensureFile(join(roots.memoryDir, ".curator-state.json"), "{}\n");
+	mkdirSync(roots.skillDraftsDir, { recursive: true });
+
+	if (roots.agentRoot) {
+		mkdirSync(join(roots.agentRoot, "skills", "generated"), { recursive: true });
+		mkdirSync(join(roots.agentRoot, "skills", "enabled"), { recursive: true });
+		mkdirSync(join(roots.agentRoot, "inbox", "memory"), { recursive: true });
+		mkdirSync(join(roots.agentRoot, "inbox", "skills"), { recursive: true });
+		mkdirSync(join(roots.agentRoot, "shared-cache", "memory"), { recursive: true });
+		mkdirSync(join(roots.agentRoot, "shared-cache", "skills"), { recursive: true });
+		mkdirSync(join(roots.agentRoot, "profile"), { recursive: true });
+		mkdirSync(join(roots.agentRoot, "sync_queue"), { recursive: true });
+		mkdirSync(join(roots.agentRoot, "feedback"), { recursive: true });
+		ensureFile(join(roots.agentRoot, "feedback", "feedback.jsonl"));
+	}
+
+	return roots;
+}

package/vendor/pi-memory/src/profile/generator.ts

@@ -0,0 +1,45 @@
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { resolveAgentRoots, type PiAgentEnv } from "../paths/resolve-roots.ts";
+import { detectSensitivity, redactLocalPaths } from "../sync/sensitivity.ts";
+
+export type ProfileGenerationResult = {
+	written: string[];
+};
+
+export function generateProfiles(env: PiAgentEnv = process.env): ProfileGenerationResult {
+	const roots = resolveAgentRoots(env);
+	if (!roots.profileDir) throw new Error("profile generation requires PI_AGENT_ROOT or Multica agent env");
+	mkdirSync(roots.profileDir, { recursive: true });
+	const memory = readSafe(join(roots.memoryDir, "MEMORY.md"));
+	const user = readSafe(join(roots.memoryDir, "USER.md"));
+	const review = readSafe(join(roots.memoryDir, "REVIEW.md"));
+	const profileInputs = redactLocalPaths([memory, user, review].filter(Boolean).join("\n\n"));
+	const safeInputs = detectSensitivity(profileInputs) === "secret" ? "Secret-like content omitted from profile." : profileInputs;
+	const written: string[] = [];
+	written.push(writeProfile(roots.profileDir, "user-profile.md", ["# User Profile", excerpt(user || safeInputs)]));
+	written.push(writeProfile(roots.profileDir, "agent-profile.md", ["# Agent Profile", `Workspace: ${roots.workspaceId || "standalone"}`, `Agent: ${roots.agentId || "standalone"}`]));
+	written.push(writeProfile(roots.profileDir, "task-profile.md", ["# Task Profile", excerpt(review || memory)]));
+	written.push(writeProfile(roots.profileDir, "capability-profile.md", ["# Capability Profile", "- Memory tools: available", "- Skill drafts: available", "- Multica scoped root: " + (roots.agentRoot ? "yes" : "no")]));
+	return { written };
+}
+
+function readSafe(filePath: string): string {
+	try {
+		return readFileSync(filePath, "utf-8");
+	} catch {
+		return "";
+	}
+}
+
+function excerpt(value: string): string {
+	const trimmed = value.trim();
+	if (!trimmed) return "No stable evidence yet.";
+	return trimmed.split("\n").filter(Boolean).slice(0, 80).join("\n");
+}
+
+function writeProfile(profileDir: string, name: string, lines: string[]): string {
+	const filePath = join(profileDir, name);
+	writeFileSync(filePath, `${lines.join("\n").trim()}\n`, "utf-8");
+	return filePath;
+}

package/vendor/pi-memory/src/service-controller.ts

@@ -1,7 +1,8 @@
 import { execFileSync, spawnSync } from "node:child_process";
-import { accessSync, constants, existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
+import { resolveMemoryRoot, type PiAgentEnv } from "./paths/resolve-roots.ts";
 
 export type CuratorServiceBackend = "systemd-user" | "cron" | "none";
 
@@ -17,6 +18,17 @@ export type CuratorServiceState = {
 	lastError?: string;
 };
 
+export type CuratorManagerServiceState = Omit<CuratorServiceState, "memoryDir"> & {
+	registryPath: string;
+};
+
+export type CuratorManagerServiceResult = {
+	ok: boolean;
+	backend: CuratorServiceBackend;
+	message: string;
+	state: CuratorManagerServiceState;
+};
+
 export type CuratorServiceResult = {
 	ok: boolean;
 	backend: CuratorServiceBackend;
@@ -25,32 +37,38 @@ export type CuratorServiceResult = {
 };
 
 const SERVICE_NAME = "jhp-pi-memory-curator";
+const MANAGER_SERVICE_NAME = "jhp-pi-memory-curator-manager";
 const DEFAULT_SCHEDULE = "03:00";
+const DEFAULT_MANAGER_SCHEDULE = "0 */6 * * *";
 const CRON_MARKER = "# jhp-pi-memory-curator";
+const MANAGER_CRON_MARKER = "# jhp-pi-memory-curator-manager";
 
 function resolveHome(): string {
 	return process.env.HOME ?? process.env.USERPROFILE ?? homedir();
 }
 
-export function resolveMemoryDir(env: NodeJS.ProcessEnv = process.env): string {
-	if (env.PI_MEMORY_DIR) return env.PI_MEMORY_DIR;
-	return join(resolveHome(), ".pi", "agent", "memory");
+export function resolveMemoryDir(env: PiAgentEnv = process.env): string {
+	return resolveMemoryRoot(env);
 }
 
 function statePath(memoryDir: string): string {
 	return join(memoryDir, ".curator-service.json");
 }
 
+function managerStatePath(registryPath: string): string {
+	return join(dirname(registryPath), ".curator-manager-service.json");
+}
+
 function systemdUserDir(): string {
 	return join(resolveHome(), ".config", "systemd", "user");
 }
 
-function servicePath(): string {
-	return join(systemdUserDir(), `${SERVICE_NAME}.service`);
+function servicePath(serviceName = SERVICE_NAME): string {
+	return join(systemdUserDir(), `${serviceName}.service`);
 }
 
-function timerPath(): string {
-	return join(systemdUserDir(), `${SERVICE_NAME}.timer`);
+function timerPath(serviceName = SERVICE_NAME): string {
+	return join(systemdUserDir(), `${serviceName}.timer`);
 }
 
 function defaultState(memoryDir: string, cliPath: string): CuratorServiceState {
@@ -79,30 +97,34 @@ function writeState(state: CuratorServiceState): void {
 	writeFileSync(statePath(state.memoryDir), `${JSON.stringify(state, null, 2)}\n`, "utf-8");
 }
 
-function commandPath(command: string): string | undefined {
-	if (command.includes("/")) {
-		try {
-			accessSync(command, constants.X_OK);
-			return command;
-		} catch {
-			return undefined;
-		}
-	}
-	for (const dir of (process.env.PATH || "").split(":")) {
-		if (!dir) continue;
-		const candidate = join(dir, command);
-		try {
-			accessSync(candidate, constants.X_OK);
-			return candidate;
-		} catch {
-			// keep searching PATH
-		}
+function defaultManagerState(registryPath: string, cliPath: string): CuratorManagerServiceState {
+	return {
+		enabled: false,
+		backend: "none",
+		schedule: DEFAULT_MANAGER_SCHEDULE,
+		serviceName: MANAGER_SERVICE_NAME,
+		registryPath,
+		cliPath,
+	};
+}
+
+function readManagerState(registryPath: string, cliPath: string): CuratorManagerServiceState {
+	const path = managerStatePath(registryPath);
+	if (!existsSync(path)) return defaultManagerState(registryPath, cliPath);
+	try {
+		return { ...defaultManagerState(registryPath, cliPath), ...(JSON.parse(readFileSync(path, "utf-8")) as Partial<CuratorManagerServiceState>) };
+	} catch {
+		return defaultManagerState(registryPath, cliPath);
 	}
-	return undefined;
+}
+
+function writeManagerState(state: CuratorManagerServiceState): void {
+	mkdirSync(dirname(managerStatePath(state.registryPath)), { recursive: true });
+	writeFileSync(managerStatePath(state.registryPath), `${JSON.stringify(state, null, 2)}\n`, "utf-8");
 }
 
 function hasCommand(command: string): boolean {
-	return commandPath(command) !== undefined || spawnSync(command, ["--version"], { stdio: "ignore" }).status === 0;
+	return spawnSync(command, ["--version"], { stdio: "ignore" }).status === 0;
 }
 
 function canUseSystemdUser(): boolean {
@@ -115,29 +137,6 @@ function shellQuote(value: string): string {
 	return `'${value.replace(/'/g, `'"'"'`)}'`;
 }
 
-function systemdQuote(value: string): string {
-	if (/^[A-Za-z0-9_@%+=:,./-]+$/.test(value)) return value;
-	return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\$/g, "\\$")}"`;
-}
-
-type CliInvocation = {
-	command: string;
-	args: string[];
-};
-
-function resolveCliInvocation(cliPath: string): CliInvocation {
-	const normalized = cliPath.replace(/\\/g, "/");
-	const isNodeModulesTypeScript = normalized.endsWith(".ts") && normalized.includes("/node_modules/");
-	if (!isNodeModulesTypeScript) return { command: process.execPath, args: [cliPath] };
-
-	const bunPath = commandPath("bun");
-	if (bunPath) return { command: bunPath, args: [cliPath] };
-	const tsxPath = commandPath("tsx");
-	if (tsxPath) return { command: tsxPath, args: [cliPath] };
-
-	throw new Error(`Cannot install memory curator service: Node cannot run TypeScript files under node_modules (${cliPath}). Install Bun or tsx, or publish a compiled JavaScript curator CLI.`);
-}
-
 function parseSchedule(schedule: string): { hour: string; minute: string } {
 	const match = /^(\d{1,2}):(\d{2})$/.exec(schedule);
 	if (!match) throw new Error(`Invalid schedule '${schedule}'. Expected HH:MM.`);
@@ -147,38 +146,54 @@ function parseSchedule(schedule: string): { hour: string; minute: string } {
 	return { hour: String(hour), minute: String(minute) };
 }
 
+function parseCronSchedule(schedule: string): string[] {
+	const fields = schedule.trim().split(/\s+/);
+	if (fields.length !== 5) throw new Error(`Invalid cron schedule '${schedule}'. Expected five cron fields.`);
+	return fields;
+}
+
 function systemdCalendar(schedule: string): string {
+	const fields = schedule.trim().split(/\s+/);
+	if (fields.length === 5) {
+		const [minute, hour, dayOfMonth, month, dayOfWeek] = fields;
+		if (dayOfMonth !== "*" || month !== "*" || dayOfWeek !== "*") throw new Error(`Unsupported systemd schedule '${schedule}'. Use HH:MM or an every-N-hours cron like '0 */6 * * *'.`);
+		if (!/^\d{1,2}$/.test(minute)) throw new Error(`Unsupported systemd schedule minute '${minute}'.`);
+		const mm = minute.padStart(2, "0");
+		if (/^\d{1,2}$/.test(hour)) return `*-*-* ${hour.padStart(2, "0")}:${mm}:00`;
+		const step = /^\*\/(\d{1,2})$/.exec(hour)?.[1];
+		if (step) return `*-*-* 00/${step}:${mm}:00`;
+		if (hour === "*") return `*-*-* *:${mm}:00`;
+		throw new Error(`Unsupported systemd schedule hour '${hour}'.`);
+	}
 	const { hour, minute } = parseSchedule(schedule);
 	return `*-*-* ${hour.padStart(2, "0")}:${minute.padStart(2, "0")}:00`;
 }
 
-function writeSystemdUnits(memoryDir: string, cliPath: string, schedule: string): void {
+function writeSystemdUnits(options: { serviceName: string; description: string; execStart: string; schedule: string }): void {
 	mkdirSync(systemdUserDir(), { recursive: true });
-	const invocation = resolveCliInvocation(cliPath);
-	const execStart = [invocation.command, ...invocation.args, "run-once", "--memory-dir", memoryDir, "--reason", "systemd-timer"].map(systemdQuote).join(" ");
 	writeFileSync(
-		servicePath(),
+		servicePath(options.serviceName),
 		[
 			"[Unit]",
-			"Description=JHP pi memory curator",
+			`Description=${options.description}`,
 			"",
 			"[Service]",
 			"Type=oneshot",
-			`ExecStart=${execStart}`,
+			`ExecStart=${options.execStart}`,
 			"",
 		].join("\n"),
 		"utf-8",
 	);
 	writeFileSync(
-		timerPath(),
+		timerPath(options.serviceName),
 		[
 			"[Unit]",
-			"Description=Run JHP pi memory curator daily",
+			`Description=Run ${options.description}`,
 			"",
 			"[Timer]",
-			`OnCalendar=${systemdCalendar(schedule)}`,
+			`OnCalendar=${systemdCalendar(options.schedule)}`,
 			"Persistent=true",
-			"Unit=jhp-pi-memory-curator.service",
+			`Unit=${options.serviceName}.service`,
 			"",
 			"[Install]",
 			"WantedBy=timers.target",
@@ -188,16 +203,16 @@ function writeSystemdUnits(memoryDir: string, cliPath: string, schedule: string)
 	);
 }
 
-function enableSystemd(memoryDir: string, cliPath: string, schedule: string): void {
-	writeSystemdUnits(memoryDir, cliPath, schedule);
+function enableSystemd(serviceName: string, description: string, execStart: string, schedule: string): void {
+	writeSystemdUnits({ serviceName, description, execStart, schedule });
 	execFileSync("systemctl", ["--user", "daemon-reload"], { stdio: "ignore" });
-	execFileSync("systemctl", ["--user", "enable", "--now", `${SERVICE_NAME}.timer`], { stdio: "ignore" });
+	execFileSync("systemctl", ["--user", "enable", "--now", `${serviceName}.timer`], { stdio: "ignore" });
 }
 
-function disableSystemd(): void {
+function disableSystemd(serviceName = SERVICE_NAME): void {
 	if (!hasCommand("systemctl")) return;
-	spawnSync("systemctl", ["--user", "disable", "--now", `${SERVICE_NAME}.timer`], { stdio: "ignore" });
-	for (const path of [servicePath(), timerPath()]) {
+	spawnSync("systemctl", ["--user", "disable", "--now", `${serviceName}.timer`], { stdio: "ignore" });
+	for (const path of [servicePath(serviceName), timerPath(serviceName)]) {
 		try {
 			if (existsSync(path)) unlinkSync(path);
 		} catch {
@@ -218,25 +233,28 @@ function installCrontab(content: string): void {
 	if (result.status !== 0) throw new Error(result.stderr || "failed to install crontab");
 }
 
-function removeCronLine(): void {
+function removeCronLine(marker = CRON_MARKER): void {
 	if (!hasCommand("crontab")) return;
 	const existing = currentCrontab();
 	const next = existing
 		.split(/\r?\n/)
-		.filter((line) => !line.includes(CRON_MARKER))
+		.filter((line) => !line.includes(marker))
 		.join("\n")
 		.trim();
 	installCrontab(next ? `${next}\n` : "");
 }
 
-function enableCron(memoryDir: string, cliPath: string, schedule: string): void {
+function enableCron(command: string, schedule: string, marker = CRON_MARKER): void {
 	if (!hasCommand("crontab")) throw new Error("Neither systemd user timers nor crontab are available.");
-	const { hour, minute } = parseSchedule(schedule);
-	removeCronLine();
-	const invocation = resolveCliInvocation(cliPath);
-	const command = [invocation.command, ...invocation.args, "run-once", "--memory-dir", memoryDir, "--reason", "cron"].map(shellQuote).join(" ");
+	const fields = schedule.includes(":") && schedule.trim().split(/\s+/).length === 1
+		? (() => {
+			const { hour, minute } = parseSchedule(schedule);
+			return [minute, hour, "*", "*", "*"];
+		})()
+		: parseCronSchedule(schedule);
+	removeCronLine(marker);
 	const existing = currentCrontab().trim();
-	const next = `${existing ? `${existing}\n` : ""}${minute} ${hour} * * * ${command} ${CRON_MARKER}\n`;
+	const next = `${existing ? `${existing}\n` : ""}${fields.join(" ")} ${command} ${marker}\n`;
 	installCrontab(next);
 }
 
@@ -245,13 +263,15 @@ export function enableCuratorService(options: { memoryDir?: string; cliPath: str
 	const schedule = options.schedule || DEFAULT_SCHEDULE;
 	const baseState = { ...defaultState(memoryDir, options.cliPath), schedule };
 	try {
+		const command = `${shellQuote(process.execPath)} ${shellQuote(options.cliPath)} run-once --memory-dir ${shellQuote(memoryDir)} --reason cron`;
 		if (canUseSystemdUser()) {
-			enableSystemd(memoryDir, options.cliPath, schedule);
+			const execStart = `${process.execPath} ${options.cliPath} run-once --memory-dir ${memoryDir} --reason systemd-timer`;
+			enableSystemd(SERVICE_NAME, "JHP pi memory curator", execStart, schedule);
 			const state: CuratorServiceState = { ...baseState, enabled: true, backend: "systemd-user", installedAt: new Date().toISOString() };
 			writeState(state);
-			return { ok: true, backend: "systemd-user", message: `Enabled systemd user timer for daily ${schedule} memory curation.`, state };
+			return { ok: true, backend: "systemd-user", message: `Enabled systemd user timer for memory curation (${schedule}).`, state };
 		}
-		enableCron(memoryDir, options.cliPath, schedule);
+		enableCron(command, schedule, CRON_MARKER);
 		const state: CuratorServiceState = { ...baseState, enabled: true, backend: "cron", installedAt: new Date().toISOString() };
 		writeState(state);
 		return { ok: true, backend: "cron", message: "Enabled cron job for daily memory curation.", state };
@@ -266,9 +286,9 @@ export function enableCuratorService(options: { memoryDir?: string; cliPath: str
 export function disableCuratorService(options: { memoryDir?: string; cliPath: string }): CuratorServiceResult {
 	const memoryDir = options.memoryDir || resolveMemoryDir();
 	const previous = readState(memoryDir, options.cliPath);
-	disableSystemd();
+	disableSystemd(SERVICE_NAME);
 	try {
-		removeCronLine();
+		removeCronLine(CRON_MARKER);
 	} catch {
 		// best effort cleanup
 	}
@@ -277,6 +297,60 @@ export function disableCuratorService(options: { memoryDir?: string; cliPath: st
 	return { ok: true, backend: previous.backend, message: "Disabled memory curator service.", state };
 }
 
+export function enableCuratorManagerService(options: { registryPath: string; cliPath: string; schedule?: string }): CuratorManagerServiceResult {
+	const schedule = options.schedule || DEFAULT_MANAGER_SCHEDULE;
+	const baseState = { ...defaultManagerState(options.registryPath, options.cliPath), schedule };
+	try {
+		mkdirSync(dirname(options.registryPath), { recursive: true });
+		const command = `${shellQuote(process.execPath)} ${shellQuote(options.cliPath)} manager-scan --registry ${shellQuote(options.registryPath)}`;
+		if (canUseSystemdUser()) {
+			const execStart = `${process.execPath} ${options.cliPath} manager-scan --registry ${options.registryPath}`;
+			enableSystemd(MANAGER_SERVICE_NAME, "JHP pi memory curator manager", execStart, schedule);
+			const state: CuratorManagerServiceState = { ...baseState, enabled: true, backend: "systemd-user", installedAt: new Date().toISOString() };
+			writeManagerState(state);
+			return { ok: true, backend: "systemd-user", message: `Enabled systemd user timer for local curator manager (${schedule}).`, state };
+		}
+		enableCron(command, schedule, MANAGER_CRON_MARKER);
+		const state: CuratorManagerServiceState = { ...baseState, enabled: true, backend: "cron", installedAt: new Date().toISOString() };
+		writeManagerState(state);
+		return { ok: true, backend: "cron", message: `Enabled cron job for local curator manager (${schedule}).`, state };
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		const state: CuratorManagerServiceState = { ...baseState, enabled: false, backend: "none", lastError: message };
+		writeManagerState(state);
+		return { ok: false, backend: "none", message, state };
+	}
+}
+
+export function disableCuratorManagerService(options: { registryPath: string; cliPath: string }): CuratorManagerServiceResult {
+	const previous = readManagerState(options.registryPath, options.cliPath);
+	disableSystemd(MANAGER_SERVICE_NAME);
+	try {
+		removeCronLine(MANAGER_CRON_MARKER);
+	} catch {
+		// best effort cleanup
+	}
+	const state: CuratorManagerServiceState = { ...previous, enabled: false, backend: "none", disabledAt: new Date().toISOString() };
+	writeManagerState(state);
+	return { ok: true, backend: previous.backend, message: "Disabled local curator manager service.", state };
+}
+
+export function getCuratorManagerServiceStatus(options: { registryPath: string; cliPath: string }): CuratorManagerServiceResult {
+	const state = readManagerState(options.registryPath, options.cliPath);
+	const parts = [
+		`Local curator manager service: ${state.enabled ? "enabled" : "disabled"}`,
+		`Backend: ${state.backend}`,
+		`Schedule: ${state.schedule}`,
+		`Registry: ${state.registryPath}`,
+	];
+	if (state.lastError) parts.push(`Last error: ${state.lastError}`);
+	if (state.backend === "systemd-user" && hasCommand("systemctl")) {
+		const active = spawnSync("systemctl", ["--user", "is-active", `${MANAGER_SERVICE_NAME}.timer`], { encoding: "utf-8" });
+		parts.push(`systemd timer active: ${active.stdout.trim() || "unknown"}`);
+	}
+	return { ok: true, backend: state.backend, message: parts.join("\n"), state };
+}
+
 export function getCuratorServiceStatus(options: { memoryDir?: string; cliPath: string }): CuratorServiceResult {
 	const memoryDir = options.memoryDir || resolveMemoryDir();
 	const state = readState(memoryDir, options.cliPath);
@@ -288,10 +362,8 @@ export function getCuratorServiceStatus(options: { memoryDir?: string; cliPath:
 	];
 	if (state.lastError) parts.push(`Last error: ${state.lastError}`);
 	if (state.backend === "systemd-user" && hasCommand("systemctl")) {
-		const timerActive = spawnSync("systemctl", ["--user", "is-active", `${SERVICE_NAME}.timer`], { encoding: "utf-8" });
-		const serviceActive = spawnSync("systemctl", ["--user", "is-active", `${SERVICE_NAME}.service`], { encoding: "utf-8" });
-		parts.push(`systemd timer active: ${timerActive.stdout.trim() || "unknown"}`);
-		parts.push(`systemd service active: ${serviceActive.stdout.trim() || "unknown"}`);
+		const active = spawnSync("systemctl", ["--user", "is-active", `${SERVICE_NAME}.timer`], { encoding: "utf-8" });
+		parts.push(`systemd timer active: ${active.stdout.trim() || "unknown"}`);
 	}
 	return { ok: true, backend: state.backend, message: parts.join("\n"), state };
 }