@lebronj/pi-suite 0.1.16 → 0.1.17

package/vendor/pi-memory/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@jhp/pi-memory",
-	"version": "0.3.12",
+	"version": "0.3.13",
 	"description": "Pi coding agent extension for structured time-aware memory with qmd-powered search and curator support",
 	"main": "index.ts",
 	"bin": {

package/vendor/pi-memory/src/cli.ts

@@ -2,8 +2,16 @@
 import { JsonlAuditLog } from "./curator-core/audit.ts";
 import { runMemoryCuratorOnce } from "./curator-core/curate.ts";
 import { FileMemoryStore } from "./curator-store/file-store.ts";
-import { pushEvolution, resolveEvolutionConfig, syncEvolutionAfterChange, createEvolutionSnapshot } from "./evolution/index.ts";
-import { disableCuratorService, enableCuratorService, getCuratorServiceStatus, resolveMemoryDir } from "./service-controller.ts";
+import { defaultRegistryPath, markCurrentRootDirty, scanDirtyRoots } from "./manager/local-curator-manager.ts";
+import {
+	disableCuratorManagerService,
+	disableCuratorService,
+	enableCuratorManagerService,
+	enableCuratorService,
+	getCuratorManagerServiceStatus,
+	getCuratorServiceStatus,
+	resolveMemoryDir,
+} from "./service-controller.ts";
 
 function cliPath(): string {
 	return new URL(import.meta.url).pathname;
@@ -23,11 +31,14 @@ function usage(): string {
 	return [
 		"Usage:",
 		"  jhp-pi-memory-curator run-once [--memory-dir <path>] [--reason <text>] [--dry-run] [--json]",
-		"  jhp-pi-memory-curator snapshot [--memory-dir <path>] [--reason <text>] [--json]",
-		"  jhp-pi-memory-curator push [--memory-dir <path>]",
 		"  jhp-pi-memory-curator enable [--memory-dir <path>] [--schedule HH:MM]",
 		"  jhp-pi-memory-curator disable [--memory-dir <path>]",
 		"  jhp-pi-memory-curator status [--memory-dir <path>]",
+		"  jhp-pi-memory-curator mark-dirty [--registry <path>]",
+		"  jhp-pi-memory-curator manager-scan [--registry <path>] [--json]",
+		"  jhp-pi-memory-curator manager-enable [--registry <path>] [--schedule '0 */6 * * *']",
+		"  jhp-pi-memory-curator manager-disable [--registry <path>]",
+		"  jhp-pi-memory-curator manager-status [--registry <path>]",
 	].join("\n");
 }
 
@@ -41,40 +52,14 @@ async function main(): Promise<void> {
 	}
 
 	if (command === "run-once") {
-		const reason = readOption(args, "--reason") || "cli";
-		const config = resolveEvolutionConfig(memoryDir);
-		if (!hasFlag(args, "--dry-run")) {
-			createEvolutionSnapshot(config, { reason: `curator before ${reason}`, trigger: "external_curator", commitMessage: "memory: snapshot before curator" });
-		}
 		const result = await runMemoryCuratorOnce({
 			memoryStore: new FileMemoryStore(memoryDir),
 			auditLog: new JsonlAuditLog(memoryDir),
-			reason,
+			reason: readOption(args, "--reason") || "cli",
 			dryRun: hasFlag(args, "--dry-run"),
 		});
-		let evolutionCommit = null;
-		if (!hasFlag(args, "--dry-run")) {
-			evolutionCommit = syncEvolutionAfterChange(config, "memory: sync after external curator");
-			if (config.autoPush) pushEvolution(config);
-		}
-		if (hasFlag(args, "--json")) console.log(JSON.stringify({ ...result, evolutionCommit }, null, 2));
-		else console.log(result.summary);
-		return;
-	}
-
-	if (command === "snapshot") {
-		const result = createEvolutionSnapshot(resolveEvolutionConfig(memoryDir), {
-			reason: readOption(args, "--reason") || "cli snapshot",
-			trigger: "cli",
-			commitMessage: "memory: manual snapshot",
-		});
 		if (hasFlag(args, "--json")) console.log(JSON.stringify(result, null, 2));
-		else console.log(result.manifest ? `Snapshot ${result.manifest.id}` : `Snapshot skipped: ${result.skipped}`);
-		return;
-	}
-
-	if (command === "push") {
-		console.log(pushEvolution(resolveEvolutionConfig(memoryDir)) || "Pushed evolution repo.");
+		else console.log(result.summary);
 		return;
 	}
 
@@ -98,6 +83,45 @@ async function main(): Promise<void> {
 		return;
 	}
 
+	if (command === "mark-dirty") {
+		const registryPath = readOption(args, "--registry") || defaultRegistryPath();
+		const record = markCurrentRootDirty(process.env, registryPath);
+		if (hasFlag(args, "--json")) console.log(JSON.stringify(record, null, 2));
+		else console.log(`Marked dirty: ${record.agent_root}`);
+		return;
+	}
+
+	if (command === "manager-scan") {
+		const registryPath = readOption(args, "--registry") || defaultRegistryPath();
+		const result = await scanDirtyRoots(registryPath);
+		if (hasFlag(args, "--json")) console.log(JSON.stringify(result, null, 2));
+		else console.log(`Local curator manager processed ${result.processed} root(s), ${result.failures} failure(s).`);
+		return;
+	}
+
+	if (command === "manager-enable") {
+		const registryPath = readOption(args, "--registry") || defaultRegistryPath();
+		const result = enableCuratorManagerService({ registryPath, cliPath: cliPath(), schedule: readOption(args, "--schedule") });
+		console.log(result.message);
+		process.exitCode = result.ok ? 0 : 1;
+		return;
+	}
+
+	if (command === "manager-disable") {
+		const registryPath = readOption(args, "--registry") || defaultRegistryPath();
+		const result = disableCuratorManagerService({ registryPath, cliPath: cliPath() });
+		console.log(result.message);
+		process.exitCode = result.ok ? 0 : 1;
+		return;
+	}
+
+	if (command === "manager-status") {
+		const registryPath = readOption(args, "--registry") || defaultRegistryPath();
+		const result = getCuratorManagerServiceStatus({ registryPath, cliPath: cliPath() });
+		console.log(result.message);
+		return;
+	}
+
 	console.error(`Unknown command: ${command}\n\n${usage()}`);
 	process.exitCode = 1;
 }

package/vendor/pi-memory/src/evolution/config.ts

@@ -21,6 +21,11 @@ type EvolutionEnv = Partial<
 		| "PI_EVOLUTION_AUTO_COMMIT"
 		| "PI_EVOLUTION_AUTO_PUSH"
 		| "PI_EVOLUTION_MAX_SNAPSHOTS"
+		| "PI_SKILL_DRAFTS_DIR"
+		| "PI_AGENT_ROOT"
+		| "MULTICA_WORKSPACES_ROOT"
+		| "MULTICA_WORKSPACE_ID"
+		| "MULTICA_AGENT_ID"
 		| "HOME"
 		| "USERPROFILE"
 		| "HOMEDRIVE"
@@ -58,8 +63,9 @@ function expandHome(input: string, env: EvolutionEnv): string {
 	return input;
 }
 
-export function resolveEvolutionConfig(memoryDir: string, env: EvolutionEnv = process.env): EvolutionConfig {
+export function resolveEvolutionConfig(memoryDir: string, env: EvolutionEnv = process.env, skillDraftsDir?: string): EvolutionConfig {
 	const agentDir = path.dirname(memoryDir);
+	const resolvedSkillDraftsDir = skillDraftsDir || env.PI_SKILL_DRAFTS_DIR || path.join(agentDir, "skill-drafts");
 	return {
 		enabled: truthy(env.PI_EVOLUTION_ENABLED, true),
 		autoCommit: truthy(env.PI_EVOLUTION_AUTO_COMMIT, true),
@@ -69,6 +75,6 @@ export function resolveEvolutionConfig(memoryDir: string, env: EvolutionEnv = pr
 		remote: env.PI_EVOLUTION_REMOTE?.trim() || null,
 		branch: env.PI_EVOLUTION_BRANCH || DEFAULT_EVOLUTION_BRANCH,
 		memoryDir,
-		skillDraftsDir: path.join(agentDir, "skill-drafts"),
+		skillDraftsDir: resolvedSkillDraftsDir,
 	};
 }

package/vendor/pi-memory/src/governance/share-candidates.ts

@@ -0,0 +1,72 @@
+import { parseEntry } from "../curator-core/metadata.ts";
+import type { MemoryStore } from "../curator-store/types.ts";
+import type { PiAgentEnv } from "../paths/resolve-roots.ts";
+import { appendEvolutionCandidate } from "../sync/queue.ts";
+
+export type ShareCandidateGenerationResult = {
+	created: number;
+	skipped: number;
+	errors: string[];
+};
+
+export async function generateShareCandidatesFromReview(memoryStore: MemoryStore, env: PiAgentEnv & Record<string, string | undefined> = process.env): Promise<ShareCandidateGenerationResult> {
+	const result: ShareCandidateGenerationResult = { created: 0, skipped: 0, errors: [] };
+	const entries = await memoryStore.readEntries("review");
+	for (const entry of entries) {
+		const parsed = parseEntry(entry);
+		if (parsed.metadata.type !== "review") continue;
+		if (!isShareable(parsed.metadata)) continue;
+		const content = extractShareableContent(parsed.body);
+		if (!content) {
+			result.skipped += 1;
+			continue;
+		}
+		try {
+			const type = parsed.metadata.kind === "skill_promotion" || parsed.metadata.target_hints?.includes("skill") ? "skill" : "memory";
+			const appended = appendEvolutionCandidate({
+				type,
+				content,
+				tags: tagsFromEntry(parsed.metadata.tags || parsed.metadata.kind || "memory"),
+				source: "local_curator",
+				suggested_scope: suggestedScope(parsed.metadata.scope),
+				status: "candidate",
+				sensitivity: parsed.metadata.sensitivity as "none" | "local_path" | "personal" | "secret" | "unknown" | undefined,
+				source_candidate_ids: (parsed.metadata.source_candidate_ids || parsed.metadata.id || "").split(",").map((id) => id.trim()).filter(Boolean),
+			}, env);
+			if (appended.appended) result.created += 1;
+			else result.skipped += 1;
+		} catch (error) {
+			result.errors.push(error instanceof Error ? error.message : String(error));
+		}
+	}
+	return result;
+}
+
+function isShareable(metadata: Record<string, string>): boolean {
+	if (metadata.sensitivity === "secret") return false;
+	if (metadata.shareability === "team_candidate" || metadata.shareability === "team_ready") return true;
+	if (["workspace", "project", "team", "global"].includes(metadata.scope || "")) return true;
+	if (metadata.decision === "promote_share_candidate") return true;
+	return false;
+}
+
+function extractShareableContent(body: string): string {
+	const lines = body.split("\n");
+	const memoryLine = lines.find((line) => line.startsWith("Memory:"));
+	if (memoryLine) {
+		const start = lines.indexOf(memoryLine);
+		return [memoryLine.slice("Memory:".length).trim(), ...lines.slice(start + 1)].join("\n").trim();
+	}
+	const draftIndex = body.indexOf("Draft content:");
+	if (draftIndex >= 0) return body.slice(draftIndex + "Draft content:".length).trim();
+	return body.trim();
+}
+
+function tagsFromEntry(value: string): string[] {
+	return value.split(/[ ,#]+/).map((tag) => tag.trim()).filter(Boolean).slice(0, 8);
+}
+
+function suggestedScope(value: string | undefined): "agent" | "workspace" | "project" | "team" | "global" | "agent_type" {
+	if (value === "workspace" || value === "project" || value === "team" || value === "global") return value;
+	return "workspace";
+}

package/vendor/pi-memory/src/index.ts

@@ -20,6 +20,29 @@ export {
 	type MemoryPromotionResult,
 	type ReviewLifecycleResult,
 } from "./learning/memory.ts";
+export { generateShareCandidatesFromReview, type ShareCandidateGenerationResult } from "./governance/share-candidates.ts";
+export { compactProcessedReviewEntries, type ReviewCompactResult } from "./learning/review-compact.ts";
+export {
+	countPendingReviewItems,
+	formatPendingReviewList,
+	formatPendingReviewSummary,
+	listPendingReviewItems,
+	type PendingReviewCounts,
+	type PendingReviewItem,
+} from "./learning/review-summary.ts";
+export {
+	defaultRegistryPath,
+	markCurrentRootDirty,
+	scanDirtyRoots,
+	type CuratorRegistry,
+	type CuratorRootRecord,
+} from "./manager/local-curator-manager.ts";
+export { generateProfiles, type ProfileGenerationResult } from "./profile/generator.ts";
+export { syncPull, syncUpload, type SyncPullResult, type SyncUploadResult } from "./sync/connector.ts";
+export { receiveDelivery, type ReceiveDeliveryResult } from "./sync/downflow.ts";
+export { appendFeedbackEvent, buildFeedbackEvent } from "./sync/feedback.ts";
+export { appendEvolutionCandidate } from "./sync/queue.ts";
+export type { Delivery, EvolutionCandidate, FeedbackEvent, FeedbackEventType, EvolutionUnitType } from "./sync/schemas.ts";
 export {
 	approveSkillDraft,
 	listSkillDraftProposals,
@@ -28,32 +51,52 @@ export {
 	type SkillProposal,
 	type SkillProposalResult,
 } from "./learning/skills.ts";
+export {
+	disableMemorySkill,
+	enableMemorySkill,
+	formatEnabledSkillsForPrompt,
+	formatSkillList,
+	listMemorySkills,
+	type SkillDisableResult,
+	type SkillEnableResult,
+	type SkillLifecycleItem,
+	type SkillLifecycleList,
+} from "./skills/lifecycle.ts";
 export { DEFAULT_CURATOR_POLICY, createLifecyclePatches, type CuratorPolicy } from "./curator-core/policy.ts";
 export { validateMemoryPatch, type MemoryPatch } from "./curator-core/patch.ts";
 export { DEFAULT_MEMORY_DIR, FileMemoryStore } from "./curator-store/file-store.ts";
+export {
+	ensureAgentRoot,
+	resolveAgentRoot,
+	resolveAgentRoots,
+	resolveFeedbackDir,
+	resolveInboxDir,
+	resolveMemoryRoot,
+	resolveProfileDir,
+	resolveSharedCacheDir,
+	resolveSkillDraftRoot,
+	resolveSyncQueueDir,
+	type PiAgentEnv,
+	type ResolvedAgentRoots,
+} from "./paths/resolve-roots.ts";
 export { ENTRY_DELIMITER, MEMORY_TARGETS, normalizeMemoryTarget, type CuratorState, type MemoryStore, type MemoryTarget } from "./curator-store/types.ts";
-export { disableCuratorService, enableCuratorService, getCuratorServiceStatus, resolveMemoryDir, type CuratorServiceBackend, type CuratorServiceResult, type CuratorServiceState } from "./service-controller.ts";
-export {
-	DEFAULT_EVOLUTION_BRANCH,
-	DEFAULT_EVOLUTION_REMOTE,
-	LEGACY_SHARED_EVOLUTION_REMOTE,
-	commitEvolutionChanges,
-	createEvolutionSnapshot,
-	createSnapshotId,
-	ensureEvolutionRepo,
-	getEvolutionGitStatus,
-	listManifests,
-	pushEvolution,
-	resolveEvolutionConfig,
-	restoreEvolutionSnapshot,
-	syncCurrentToEvolution,
-	syncEvolutionAfterChange,
-	type EvolutionConfig,
-	type EvolutionManifest,
-	type GitCommitResult,
-	type GitStatus,
-	type RestoreResult,
-	type RestoreTarget,
-	type SnapshotOptions,
-	type SnapshotResult,
-} from "./evolution/index.ts";
+export { DEFAULT_EVOLUTION_BRANCH, DEFAULT_EVOLUTION_MAX_SNAPSHOTS, DEFAULT_EVOLUTION_REMOTE, LEGACY_SHARED_EVOLUTION_REMOTE, resolveEvolutionConfig, type EvolutionConfig } from "./evolution/config.ts";
+export { commitEvolutionChanges, ensureEvolutionRepo, getEvolutionGitStatus, pushEvolution, type GitCommitResult, type GitStatus } from "./evolution/git.ts";
+export { buildManifest, createSnapshotId, listManifests, readManifest, writeManifest, type EvolutionManifest } from "./evolution/manifest.ts";
+export { restoreEvolutionSnapshot, type RestoreResult, type RestoreTarget } from "./evolution/restore.ts";
+export { createEvolutionSnapshot, syncEvolutionAfterChange, type SnapshotOptions, type SnapshotResult } from "./evolution/snapshot.ts";
+export { syncCurrentToEvolution } from "./evolution/sync.ts";
+export {
+	disableCuratorManagerService,
+	disableCuratorService,
+	enableCuratorManagerService,
+	enableCuratorService,
+	getCuratorManagerServiceStatus,
+	getCuratorServiceStatus,
+	resolveMemoryDir,
+	type CuratorManagerServiceResult,
+	type CuratorManagerServiceState,
+	type CuratorServiceBackend,
+	type CuratorServiceResult,
+	type CuratorServiceState,
+} from "./service-controller.ts";

package/vendor/pi-memory/src/learning/review-compact.ts

@@ -0,0 +1,36 @@
+import { parseEntry } from "../curator-core/metadata.ts";
+import { ENTRY_DELIMITER } from "../curator-store/types.ts";
+
+export type ReviewCompactResult = {
+	activeEntries: string[];
+	removedEntries: string[];
+	removed: number;
+};
+
+const COMPACT_STATUSES = new Set(["approved", "rejected", "archived", "merged"]);
+
+export function compactProcessedReviewEntries(reviewText: string, options: { now?: Date; compactDays?: number } = {}): ReviewCompactResult {
+	const now = options.now ?? new Date();
+	const compactDays = options.compactDays ?? 30;
+	const activeEntries: string[] = [];
+	const removedEntries: string[] = [];
+	for (const entry of reviewText.split(ENTRY_DELIMITER).map((item) => item.trim()).filter(Boolean)) {
+		if (shouldCompactEntry(entry, now, compactDays)) removedEntries.push(entry);
+		else activeEntries.push(entry);
+	}
+	return { activeEntries, removedEntries, removed: removedEntries.length };
+}
+
+function shouldCompactEntry(entry: string, now: Date, compactDays: number): boolean {
+	try {
+		const parsed = parseEntry(entry);
+		if (parsed.metadata.type !== "review" || !COMPACT_STATUSES.has(parsed.metadata.status || "")) return false;
+		const timestamp = parsed.metadata.approved_at || parsed.metadata.reviewed_at || parsed.metadata.merged_at || parsed.metadata.last_seen;
+		if (!timestamp) return compactDays <= 0;
+		const ageMs = now.getTime() - Date.parse(timestamp.includes("T") ? timestamp : `${timestamp}T00:00:00.000Z`);
+		if (!Number.isFinite(ageMs)) return false;
+		return ageMs >= compactDays * 86_400_000;
+	} catch {
+		return false;
+	}
+}

package/vendor/pi-memory/src/learning/review-summary.ts

@@ -0,0 +1,81 @@
+import { parseEntry } from "../curator-core/metadata.ts";
+
+export type PendingReviewCounts = {
+	memory: number;
+	skill: number;
+	incoming: number;
+	total: number;
+};
+
+export type PendingReviewItem = {
+	id: string;
+	kind: string;
+	status: string;
+	confidence?: string;
+	target?: string;
+	summary: string;
+};
+
+const ENTRY_DELIMITER = "\n§\n";
+
+export function countPendingReviewItems(reviewText: string): PendingReviewCounts {
+	const items = listPendingReviewItems(reviewText);
+	return {
+		memory: items.filter((item) => item.kind === "memory_promotion").length,
+		skill: items.filter((item) => item.kind === "skill_promotion").length,
+		incoming: items.filter((item) => item.kind.startsWith("incoming_")).length,
+		total: items.length,
+	};
+}
+
+export function listPendingReviewItems(reviewText: string, options: { type?: "memory" | "skill"; limit?: number } = {}): PendingReviewItem[] {
+	const limit = Math.max(0, options.limit ?? 20);
+	const entries = reviewText.split(ENTRY_DELIMITER).map((entry) => entry.trim()).filter(Boolean);
+	const items: PendingReviewItem[] = [];
+	for (const entry of entries) {
+		try {
+			const parsed = parseEntry(entry);
+			if (parsed.metadata.type !== "review" || parsed.metadata.status !== "proposed") continue;
+			const kind = parsed.metadata.kind || "review";
+			if (options.type === "memory" && kind !== "memory_promotion") continue;
+			if (options.type === "skill" && kind !== "skill_promotion") continue;
+			items.push({
+				id: parsed.metadata.id || "",
+				kind,
+				status: parsed.metadata.status || "",
+				confidence: parsed.metadata.confidence,
+				target: parsed.metadata.promotes_to,
+				summary: summarizeReviewBody(parsed.body),
+			});
+		} catch {
+			// Malformed review entries should never break startup hints or review commands.
+		}
+	}
+	return limit > 0 ? items.slice(0, limit) : [];
+}
+
+export function formatPendingReviewSummary(counts: PendingReviewCounts): string {
+	if (counts.total === 0) return "No pending memory/skill proposals.";
+	return [
+		`Curator completed: ${counts.memory} memory proposal(s) pending, ${counts.skill} skill proposal(s) pending.`,
+		"Next: run /memory-review, or approve with memory_learning_approve id=<proposal-id>, reject with memory_learning_reject id=<proposal-id>.",
+	].join("\n");
+}
+
+export function formatPendingReviewList(items: PendingReviewItem[], counts: PendingReviewCounts): string {
+	if (items.length === 0) return "No pending memory/skill proposals.";
+	const lines = [`Memory review: ${counts.memory} memory / ${counts.skill} skill proposals pending.`];
+	for (const item of items) {
+		const confidence = item.confidence ? ` confidence=${item.confidence}` : "";
+		const target = item.target ? ` target=${item.target}` : "";
+		lines.push(`- ${item.id || "<missing-id>"}: ${item.kind}${confidence}${target}`);
+		if (item.summary) lines.push(`  ${item.summary}`);
+	}
+	lines.push("Approve with /memory-review approve <id>, reject with /memory-review reject <id>, or inspect with /memory-review show <id>.");
+	return lines.join("\n");
+}
+
+function summarizeReviewBody(body: string): string {
+	const line = body.split("\n").map((candidate) => candidate.trim()).find(Boolean) || "";
+	return line.length > 180 ? `${line.slice(0, 177)}...` : line;
+}

package/vendor/pi-memory/src/manager/local-curator-manager.ts

@@ -0,0 +1,146 @@
+import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { JsonlAuditLog } from "../curator-core/audit.ts";
+import { runMemoryCuratorOnce } from "../curator-core/curate.ts";
+import { FileMemoryStore } from "../curator-store/file-store.ts";
+import { applyReviewLifecycle, proposeMemoryPromotions } from "../learning/memory.ts";
+import { proposeSkillDrafts } from "../learning/skills.ts";
+import { ensureAgentRoot, resolveAgentRoots, type PiAgentEnv } from "../paths/resolve-roots.ts";
+import { generateShareCandidatesFromReview } from "../governance/share-candidates.ts";
+import { generateProfiles } from "../profile/generator.ts";
+
+export type CuratorRootRecord = {
+	workspace_id?: string;
+	agent_id?: string;
+	agent_root: string;
+	memory_dir: string;
+	skill_dir: string;
+	dirty_since?: string;
+	last_curated_at?: string;
+	last_synced_at?: string;
+	status: "idle" | "dirty" | "running" | "error";
+	last_error?: string;
+};
+
+export type CuratorRegistry = {
+	roots: CuratorRootRecord[];
+};
+
+export function defaultRegistryPath(env: PiAgentEnv = process.env): string {
+	const roots = resolveAgentRoots(env);
+	if (env.MULTICA_WORKSPACES_ROOT) return join(env.MULTICA_WORKSPACES_ROOT, ".pi-curator", "registry.json");
+	if (roots.agentRoot) return join(dirname(dirname(dirname(dirname(roots.agentRoot)))), ".pi-curator", "registry.json");
+	return join(env.HOME || process.cwd(), ".pi", "agent", "memory-curator-manager", "registry.json");
+}
+
+export function markCurrentRootDirty(env: PiAgentEnv = process.env, registryPath = defaultRegistryPath(env)): CuratorRootRecord {
+	const roots = ensureAgentRoot(env);
+	if (!roots.agentRoot) throw new Error("dirty root tracking requires PI_AGENT_ROOT or Multica agent env");
+	const registry = readRegistry(registryPath);
+	const existing = registry.roots.find((entry) => entry.agent_root === roots.agentRoot);
+	const now = new Date().toISOString();
+	const record: CuratorRootRecord = {
+		workspace_id: roots.workspaceId,
+		agent_id: roots.agentId,
+		agent_root: roots.agentRoot,
+		memory_dir: roots.memoryDir,
+		skill_dir: roots.skillsDir,
+		dirty_since: existing?.dirty_since || now,
+		last_curated_at: existing?.last_curated_at,
+		last_synced_at: existing?.last_synced_at,
+		status: "dirty",
+	};
+	const next = registry.roots.filter((entry) => entry.agent_root !== roots.agentRoot);
+	next.push(record);
+	writeRegistry(registryPath, { roots: next });
+	return record;
+}
+
+export async function scanDirtyRoots(registryPath: string): Promise<{ processed: number; failures: number }> {
+	const managerLockPath = join(dirname(registryPath), ".manager-scan.lock");
+	if (!acquireLock(managerLockPath, 6 * 60 * 60 * 1000)) throw new Error(`curator manager lock exists for ${registryPath}`);
+	try {
+		const registry = readRegistry(registryPath);
+		let processed = 0;
+		let failures = 0;
+		for (const root of registry.roots) {
+			if (root.status !== "dirty" && !root.dirty_since) continue;
+			try {
+				await curateRoot(root);
+				root.status = "idle";
+				root.dirty_since = undefined;
+				root.last_curated_at = new Date().toISOString();
+				root.last_error = undefined;
+				processed += 1;
+			} catch (error) {
+				root.status = "error";
+				root.last_error = error instanceof Error ? error.message : String(error);
+				failures += 1;
+			}
+		}
+		writeRegistry(registryPath, registry);
+		return { processed, failures };
+	} finally {
+		releaseLock(managerLockPath);
+	}
+}
+
+async function curateRoot(root: CuratorRootRecord): Promise<void> {
+	const lockPath = join(root.agent_root, ".curator.lock");
+	mkdirSync(root.agent_root, { recursive: true });
+	if (!acquireLock(lockPath, 24 * 60 * 60 * 1000)) throw new Error(`curator lock exists for ${root.agent_root}`);
+	try {
+		const store = new FileMemoryStore(root.memory_dir);
+		await runMemoryCuratorOnce({ memoryStore: store, auditLog: new JsonlAuditLog(root.memory_dir), reason: "local-curator-manager" });
+		await applyReviewLifecycle(store);
+		await proposeMemoryPromotions(store);
+		await proposeSkillDrafts(store, { draftsDir: join(root.skill_dir, "drafts") });
+		const env = { PI_AGENT_ROOT: root.agent_root, MULTICA_WORKSPACE_ID: root.workspace_id, MULTICA_AGENT_ID: root.agent_id };
+		await generateShareCandidatesFromReview(store, env);
+		generateProfiles(env);
+	} finally {
+		try {
+			renameSync(lockPath, `${lockPath}.last`);
+		} catch {
+			releaseLock(lockPath);
+		}
+	}
+}
+
+function acquireLock(lockPath: string, staleAfterMs: number): boolean {
+	mkdirSync(dirname(lockPath), { recursive: true });
+	if (existsSync(lockPath)) {
+		try {
+			const age = Date.now() - statSync(lockPath).mtimeMs;
+			if (age > staleAfterMs) rmSync(lockPath, { force: true });
+			else return false;
+		} catch {
+			return false;
+		}
+	}
+	writeFileSync(lockPath, `${process.pid}\n${new Date().toISOString()}\n`, { encoding: "utf-8", flag: "wx" });
+	return true;
+}
+
+function releaseLock(lockPath: string): void {
+	try {
+		rmSync(lockPath, { force: true });
+	} catch {
+		// best effort cleanup
+	}
+}
+
+function readRegistry(registryPath: string): CuratorRegistry {
+	if (!existsSync(registryPath)) return { roots: [] };
+	try {
+		const parsed = JSON.parse(readFileSync(registryPath, "utf-8")) as CuratorRegistry;
+		return { roots: Array.isArray(parsed.roots) ? parsed.roots : [] };
+	} catch {
+		return { roots: [] };
+	}
+}
+
+function writeRegistry(registryPath: string, registry: CuratorRegistry): void {
+	mkdirSync(dirname(registryPath), { recursive: true });
+	writeFileSync(registryPath, `${JSON.stringify(registry, null, 2)}\n`, "utf-8");
+}