@lebronj/pi-suite 0.1.0

package/vendor/pi-memory/package.json

@@ -0,0 +1,68 @@
+{
+	"name": "@jhp/pi-memory",
+	"version": "0.3.12",
+	"description": "Pi coding agent extension for structured time-aware memory with qmd-powered search and curator support",
+	"main": "index.ts",
+	"bin": {
+		"jhp-pi-memory-curator": "./src/cli.ts"
+	},
+	"type": "module",
+	"keywords": [
+		"pi",
+		"pi-coding-agent",
+		"pi-package",
+		"memory",
+		"search",
+		"qmd",
+		"curator",
+		"time-aware-memory",
+		"scratchpad",
+		"daily-log"
+	],
+	"pi": {
+		"extensions": [
+			"./index.ts"
+		]
+	},
+	"author": "JHP",
+	"license": "MIT",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/jhp/pi-memory.git"
+	},
+	"bugs": {
+		"url": "https://github.com/jhp/pi-memory/issues"
+	},
+	"homepage": "https://github.com/jhp/pi-memory#readme",
+	"files": [
+		"index.ts",
+		"src",
+		"scripts",
+		"README.md",
+		"LICENSE"
+	],
+	"publishConfig": {
+		"access": "public"
+	},
+	"scripts": {
+		"postinstall": "node scripts/postinstall.cjs",
+		"build": "tsc -p tsconfig.json --noEmit",
+		"lint": "biome check .",
+		"test": "tsx --test test/*.test.ts",
+		"pack:check": "npm pack --dry-run"
+	},
+	"devDependencies": {
+		"@biomejs/biome": "2.4.0",
+		"tsx": "4.0.0",
+		"typescript": "5.9.3"
+	},
+	"peerDependencies": {
+		"@earendil-works/pi-ai": "*",
+		"@earendil-works/pi-coding-agent": "*",
+		"typebox": "*"
+	},
+	"overrides": {
+		"rimraf": "6.1.3",
+		"glob": "13.0.3"
+	}
+}

package/vendor/pi-memory/scripts/postinstall.cjs

@@ -0,0 +1,44 @@
+const { spawnSync } = require("node:child_process");
+const path = require("node:path");
+
+function hasQmd() {
+	const result = spawnSync("qmd", ["status"], {
+		stdio: "ignore",
+		shell: process.platform === "win32",
+	});
+	return result.status === 0;
+}
+
+function memoryDir() {
+	const home = process.env.HOME ?? process.env.USERPROFILE ?? "~";
+	return path.join(home, ".pi", "agent", "memory");
+}
+
+function configureGitHooks() {
+	const result = spawnSync("git", ["rev-parse", "--is-inside-work-tree"], {
+		stdio: "ignore",
+		shell: process.platform === "win32",
+	});
+
+	if (result.status !== 0) {
+		return;
+	}
+
+	spawnSync("git", ["config", "core.hooksPath", ".githooks"], {
+		stdio: "ignore",
+		shell: process.platform === "win32",
+	});
+}
+
+configureGitHooks();
+
+if (!hasQmd()) {
+	const dir = memoryDir();
+	console.log("\npi-memory: qmd not found (required for `memory_search`).\n");
+	console.log("Install qmd (requires Bun):");
+	console.log("  bun install -g https://github.com/tobi/qmd");
+	console.log("  # ensure ~/.bun/bin is in your PATH\n");
+	console.log("Then set up the collection (one-time):");
+	console.log(`  qmd collection add ${dir} --name pi-memory`);
+	console.log("  qmd embed\n");
+}

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

@@ -0,0 +1,79 @@
+#!/usr/bin/env node
+import { JsonlAuditLog } from "./curator-core/audit.ts";
+import { runMemoryCuratorOnce } from "./curator-core/curate.ts";
+import { FileMemoryStore } from "./curator-store/file-store.ts";
+import { disableCuratorService, enableCuratorService, getCuratorServiceStatus, resolveMemoryDir } from "./service-controller.ts";
+
+function cliPath(): string {
+	return new URL(import.meta.url).pathname;
+}
+
+function readOption(args: string[], name: string): string | undefined {
+	const index = args.indexOf(name);
+	if (index < 0) return undefined;
+	return args[index + 1];
+}
+
+function hasFlag(args: string[], name: string): boolean {
+	return args.includes(name);
+}
+
+function usage(): string {
+	return [
+		"Usage:",
+		"  jhp-pi-memory-curator run-once [--memory-dir <path>] [--reason <text>] [--dry-run] [--json]",
+		"  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>]",
+	].join("\n");
+}
+
+async function main(): Promise<void> {
+	const [command, ...args] = process.argv.slice(2);
+	const memoryDir = readOption(args, "--memory-dir") || resolveMemoryDir();
+
+	if (!command || command === "help" || command === "--help" || command === "-h") {
+		console.log(usage());
+		return;
+	}
+
+	if (command === "run-once") {
+		const result = await runMemoryCuratorOnce({
+			memoryStore: new FileMemoryStore(memoryDir),
+			auditLog: new JsonlAuditLog(memoryDir),
+			reason: readOption(args, "--reason") || "cli",
+			dryRun: hasFlag(args, "--dry-run"),
+		});
+		if (hasFlag(args, "--json")) console.log(JSON.stringify(result, null, 2));
+		else console.log(result.summary);
+		return;
+	}
+
+	if (command === "enable" || command === "install-service") {
+		const result = enableCuratorService({ memoryDir, cliPath: cliPath(), schedule: readOption(args, "--schedule") });
+		console.log(result.message);
+		process.exitCode = result.ok ? 0 : 1;
+		return;
+	}
+
+	if (command === "disable" || command === "uninstall-service") {
+		const result = disableCuratorService({ memoryDir, cliPath: cliPath() });
+		console.log(result.message);
+		process.exitCode = result.ok ? 0 : 1;
+		return;
+	}
+
+	if (command === "status") {
+		const result = getCuratorServiceStatus({ memoryDir, cliPath: cliPath() });
+		console.log(result.message);
+		return;
+	}
+
+	console.error(`Unknown command: ${command}\n\n${usage()}`);
+	process.exitCode = 1;
+}
+
+main().catch((error: unknown) => {
+	console.error(error instanceof Error ? error.message : String(error));
+	process.exitCode = 1;
+});

package/vendor/pi-memory/src/curator-core/audit.ts

@@ -0,0 +1,45 @@
+import { mkdirSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import type { MemoryPatch } from "./patch.ts";
+import type { MemoryTarget } from "../curator-store/types.ts";
+
+export interface AuditLog {
+	write(entry: AuditEntry): Promise<void>;
+}
+
+export type AuditEntry = {
+	runId: string;
+	target: MemoryTarget;
+	operation: MemoryPatch["operation"];
+	old?: string;
+	new?: string;
+	reason: string;
+	reviewedAt: string;
+	actor: "pi-memory-curator";
+};
+
+export class JsonlAuditLog implements AuditLog {
+	readonly path: string;
+
+	constructor(memoryDir: string, auditPath?: string) {
+		this.path = auditPath || join(memoryDir, "audit", "curator.jsonl");
+	}
+
+	async write(entry: AuditEntry): Promise<void> {
+		mkdirSync(dirname(this.path), { recursive: true });
+		writeFileSync(this.path, `${JSON.stringify(entry)}\n`, { encoding: "utf-8", flag: "a" });
+	}
+}
+
+export function auditEntryFromPatch(runId: string, patch: MemoryPatch, reviewedAt: string): AuditEntry {
+	return {
+		runId,
+		target: patch.target,
+		operation: patch.operation,
+		old: patch.oldText,
+		new: patch.newText,
+		reason: patch.reason,
+		reviewedAt,
+		actor: "pi-memory-curator",
+	};
+}

package/vendor/pi-memory/src/curator-core/curate.ts

@@ -0,0 +1,90 @@
+import { auditEntryFromPatch, type AuditLog } from "./audit.ts";
+import type { CuratorPolicy } from "./policy.ts";
+import { createLifecyclePatches } from "./policy.ts";
+import type { MemoryPatch } from "./patch.ts";
+import { validateMemoryPatch } from "./patch.ts";
+import { MEMORY_TARGETS, type MemoryStore, type MemoryTarget } from "../curator-store/types.ts";
+
+export type RunMemoryCuratorOnceOptions = {
+	memoryStore: MemoryStore;
+	auditLog?: AuditLog;
+	policy?: CuratorPolicy;
+	now?: () => Date;
+	dryRun?: boolean;
+	reason?: string;
+};
+
+export type CuratorRunResult = {
+	runId: string;
+	changed: number;
+	reviewed: number;
+	deduped: number;
+	patches: MemoryPatch[];
+	summary: string;
+	dryRun: boolean;
+};
+
+export async function runMemoryCuratorOnce(options: RunMemoryCuratorOnceOptions): Promise<CuratorRunResult> {
+	const now = options.now?.() || new Date();
+	const runId = now.toISOString();
+	const entriesByTarget = new Map<MemoryTarget, string[]>();
+	const patches: MemoryPatch[] = [];
+	let deduped = 0;
+
+	for (const target of MEMORY_TARGETS) {
+		if (target === "review") continue;
+		const entries = await options.memoryStore.readEntries(target);
+		entriesByTarget.set(target, entries);
+		const dedupedEntries = dedupeEntries(entries);
+		if (dedupedEntries.length !== entries.length) {
+			deduped += entries.length - dedupedEntries.length;
+			patches.push({ target, operation: "dedupe", reason: "duplicate exact entries", confidence: "high" });
+		}
+		patches.push(...createLifecyclePatches(target, dedupedEntries, now, options.policy));
+	}
+
+	const errors = patches.flatMap((patch) => validateMemoryPatch(patch).map((error) => `${patch.operation}: ${error}`));
+	if (errors.length) throw new Error(`Invalid curator patch: ${errors.join("; ")}`);
+
+	if (!options.dryRun && patches.length > 0) {
+		await applyPatches(options.memoryStore, entriesByTarget, patches);
+		const reviewedAt = now.toISOString();
+		for (const patch of patches) await options.auditLog?.write(auditEntryFromPatch(runId, patch, reviewedAt));
+	}
+
+	const changed = patches.filter((patch) => patch.operation === "replace").length + deduped;
+	const reviewed = patches.filter((patch) => patch.operation === "append_review").length;
+	const summary = `Curated memory: ${changed} updated, ${reviewed} review item(s), ${runId}`;
+	if (!options.dryRun && patches.length > 0) await options.memoryStore.saveState({ lastRunAt: runId, lastRunSummary: summary });
+	return { runId, changed, reviewed, deduped, patches, summary, dryRun: Boolean(options.dryRun) };
+}
+
+async function applyPatches(memoryStore: MemoryStore, entriesByTarget: Map<MemoryTarget, string[]>, patches: MemoryPatch[]): Promise<void> {
+	for (const patch of patches) {
+		if (patch.operation === "append_review") {
+			const storedReviewEntries = entriesByTarget.get("review");
+			const entries = storedReviewEntries || await memoryStore.readEntries("review");
+			if (patch.newText && !entries.includes(patch.newText)) entries.push(patch.newText);
+			entriesByTarget.set("review", entries);
+			continue;
+		}
+
+		const storedEntries = entriesByTarget.get(patch.target);
+		const entries = storedEntries || await memoryStore.readEntries(patch.target);
+		if (patch.operation === "replace") {
+			const index = entries.findIndex((entry) => entry === patch.oldText);
+			if (index < 0) throw new Error(`Patch target entry not found in ${patch.target}`);
+			entries[index] = patch.newText || "";
+		} else if (patch.operation === "dedupe") {
+			entriesByTarget.set(patch.target, dedupeEntries(entries));
+			continue;
+		}
+		entriesByTarget.set(patch.target, entries);
+	}
+
+	for (const [target, entries] of entriesByTarget) await memoryStore.writeEntries(target, dedupeEntries(entries));
+}
+
+function dedupeEntries(entries: string[]): string[] {
+	return [...new Set(entries.map((entry) => entry.trim()).filter(Boolean))];
+}

package/vendor/pi-memory/src/curator-core/metadata.ts

@@ -0,0 +1,55 @@
+export type MemoryMetadata = Record<string, string>;
+
+export type ParsedEntry = {
+	metadata: MemoryMetadata;
+	body: string;
+	raw: string;
+	hasMetadata: boolean;
+};
+
+const ORDERED_METADATA_KEYS = ["type", "provider", "status", "date", "reset", "month", "used", "limit", "ttlDays"];
+
+export function parseMetadata(line: string): MemoryMetadata | undefined {
+	const trimmed = line.trim();
+	if (!trimmed.startsWith("[") || !trimmed.endsWith("]")) return undefined;
+	const inner = trimmed.slice(1, -1).trim();
+	if (!inner) return {};
+	const metadata: MemoryMetadata = {};
+	for (const part of inner.split(/\s+/)) {
+		const index = part.indexOf(":");
+		if (index <= 0) continue;
+		const key = part.slice(0, index).trim();
+		const value = part.slice(index + 1).trim();
+		if (key && value) metadata[key] = value;
+	}
+	return metadata;
+}
+
+export function serializeMetadata(metadata: MemoryMetadata): string {
+	const keys = [
+		...ORDERED_METADATA_KEYS.filter((key) => metadata[key] !== undefined),
+		...Object.keys(metadata).filter((key) => !ORDERED_METADATA_KEYS.includes(key)).sort(),
+	];
+	return `[${keys.map((key) => `${key}:${metadata[key]}`).join(" ")}]`;
+}
+
+export function parseEntry(raw: string): ParsedEntry {
+	const trimmed = raw.trim();
+	const lines = trimmed.split("\n");
+	const metadata = parseMetadata(lines[0]);
+	if (metadata === undefined) return { metadata: {}, body: trimmed, raw: trimmed, hasMetadata: false };
+	return { metadata, body: lines.slice(1).join("\n").trim(), raw: trimmed, hasMetadata: true };
+}
+
+export function renderEntry(entry: ParsedEntry): string {
+	if (!entry.hasMetadata || Object.keys(entry.metadata).length === 0) return entry.body.trim();
+	return `${serializeMetadata(entry.metadata)}\n${entry.body.trim()}`.trim();
+}
+
+export function todayUtc(now: Date): string {
+	return now.toISOString().slice(0, 10);
+}
+
+export function currentMonth(now: Date): string {
+	return now.toISOString().slice(0, 7);
+}

package/vendor/pi-memory/src/curator-core/patch.ts

@@ -0,0 +1,24 @@
+import { MEMORY_TARGETS, type MemoryTarget } from "../curator-store/types.ts";
+
+export const MEMORY_PATCH_OPERATIONS = ["replace", "append_review", "dedupe"] as const;
+
+export type MemoryPatchOperation = (typeof MEMORY_PATCH_OPERATIONS)[number];
+
+export interface MemoryPatch {
+	target: MemoryTarget;
+	operation: MemoryPatchOperation;
+	oldText?: string;
+	newText?: string;
+	reason: string;
+	confidence: "high" | "medium" | "low";
+}
+
+export function validateMemoryPatch(patch: MemoryPatch): string[] {
+	const errors: string[] = [];
+	if (!MEMORY_TARGETS.includes(patch.target)) errors.push(`invalid target '${patch.target}'`);
+	if (!MEMORY_PATCH_OPERATIONS.includes(patch.operation)) errors.push(`invalid operation '${patch.operation}'`);
+	if (!patch.reason.trim()) errors.push("reason is required");
+	if (patch.operation === "replace" && (!patch.oldText?.trim() || !patch.newText?.trim())) errors.push("replace requires oldText and newText");
+	if (patch.operation === "append_review" && !patch.newText?.trim()) errors.push("append_review requires newText");
+	return errors;
+}

package/vendor/pi-memory/src/curator-core/policy.ts

@@ -0,0 +1,77 @@
+import { currentMonth, parseEntry, renderEntry, todayUtc } from "./metadata.ts";
+import type { MemoryPatch } from "./patch.ts";
+import type { MemoryTarget } from "../curator-store/types.ts";
+
+export type CuratorPolicy = {
+	markTodayEvents?: boolean;
+	reviewExpiredTemporary?: boolean;
+};
+
+export const DEFAULT_CURATOR_POLICY: Required<CuratorPolicy> = {
+	markTodayEvents: true,
+	reviewExpiredTemporary: true,
+};
+
+export function createLifecyclePatches(target: MemoryTarget, rawEntries: string[], now: Date, policy: CuratorPolicy = {}): MemoryPatch[] {
+	const resolvedPolicy = { ...DEFAULT_CURATOR_POLICY, ...policy };
+	const patches: MemoryPatch[] = [];
+	const today = todayUtc(now);
+	const month = currentMonth(now);
+
+	for (const raw of rawEntries) {
+		const parsed = parseEntry(raw);
+		if (!parsed.hasMetadata) continue;
+
+		if (parsed.metadata.type === "event") {
+			const date = parsed.metadata.date;
+			const status = parsed.metadata.status;
+			if (date && date < today && (status === "planned" || status === "today")) {
+				const next = parseEntry(raw);
+				next.metadata.status = "past";
+				next.body = rewritePastEventBody(next.body);
+				patches.push({ target, operation: "replace", oldText: raw, newText: renderEntry(next), reason: "event date passed", confidence: "high" });
+				continue;
+			}
+			if (resolvedPolicy.markTodayEvents && date === today && status === "planned") {
+				const next = parseEntry(raw);
+				next.metadata.status = "today";
+				patches.push({ target, operation: "replace", oldText: raw, newText: renderEntry(next), reason: "event date is today", confidence: "high" });
+				continue;
+			}
+		}
+
+		if (parsed.metadata.type === "temporary" && resolvedPolicy.reviewExpiredTemporary && parsed.metadata.date && parsed.metadata.date < today) {
+			patches.push({
+				target: "review",
+				operation: "append_review",
+				newText: `[type:review source:${target} reason:expired-temporary]\nTemporary memory may be stale: ${raw}`,
+				reason: "temporary memory date passed",
+				confidence: "high",
+			});
+		}
+
+		if (parsed.metadata.type === "quota") {
+			const reset = parsed.metadata.reset;
+			const resetReached = reset ? Date.parse(reset) <= now.getTime() : false;
+			if ((parsed.metadata.month && parsed.metadata.month !== month) || (parsed.metadata.status === "exhausted" && resetReached)) {
+				const next = parseEntry(raw);
+				next.metadata.month = month;
+				next.metadata.status = "active";
+				next.metadata.used = "0";
+				const provider = next.metadata.provider || "provider";
+				next.body = `${provider} search quota is active for ${month}.`;
+				patches.push({ target, operation: "replace", oldText: raw, newText: renderEntry(next), reason: "quota reset date reached", confidence: "high" });
+			}
+		}
+	}
+
+	return patches;
+}
+
+function rewritePastEventBody(body: string): string {
+	const rewritten = body
+		.replace(/\bUser is planning\b/i, "User had")
+		.replace(/\bUser plans\b/i, "User had planned")
+		.replace(/\bUser planned\b/i, "User had planned");
+	return /completion status unknown/i.test(rewritten) ? rewritten : `${rewritten} Completion status unknown.`;
+}

package/vendor/pi-memory/src/curator-store/file-store.ts

@@ -0,0 +1,51 @@
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { ENTRY_DELIMITER, type CuratorState, type MemoryStore, type MemoryTarget } from "./types.ts";
+
+export const DEFAULT_MEMORY_DIR = join(process.env.HOME || process.cwd(), ".pi", "agent", "memory");
+
+export class FileMemoryStore implements MemoryStore {
+	readonly memoryDir: string;
+
+	constructor(memoryDir = DEFAULT_MEMORY_DIR) {
+		this.memoryDir = memoryDir;
+	}
+
+	async readEntries(target: MemoryTarget): Promise<string[]> {
+		const path = this.pathForTarget(target);
+		if (!existsSync(path)) return [];
+		const raw = readFileSync(path, "utf-8").trim();
+		if (!raw) return [];
+		return raw.split(ENTRY_DELIMITER).map((entry) => entry.trim()).filter(Boolean);
+	}
+
+	async writeEntries(target: MemoryTarget, entries: string[]): Promise<void> {
+		this.atomicWrite(this.pathForTarget(target), entries.map((entry) => entry.trim()).filter(Boolean).join(ENTRY_DELIMITER));
+	}
+
+	async loadState(): Promise<CuratorState> {
+		const path = join(this.memoryDir, ".curator-state.json");
+		if (!existsSync(path)) return {};
+		try {
+			return JSON.parse(readFileSync(path, "utf-8")) as CuratorState;
+		} catch {
+			return {};
+		}
+	}
+
+	async saveState(state: CuratorState): Promise<void> {
+		this.atomicWrite(join(this.memoryDir, ".curator-state.json"), `${JSON.stringify(state, null, 2)}\n`);
+	}
+
+	pathForTarget(target: MemoryTarget): string {
+		const name = target === "memory" ? "MEMORY" : target === "user" ? "USER" : target === "state" ? "STATE" : "REVIEW";
+		return join(this.memoryDir, `${name}.md`);
+	}
+
+	private atomicWrite(path: string, content: string): void {
+		mkdirSync(dirname(path), { recursive: true });
+		const tmpPath = join(dirname(path), `.tmp-${process.pid}-${Date.now()}-${Math.random().toString(16).slice(2)}`);
+		writeFileSync(tmpPath, content, "utf-8");
+		renameSync(tmpPath, path);
+	}
+}

package/vendor/pi-memory/src/curator-store/types.ts

@@ -0,0 +1,21 @@
+export const ENTRY_DELIMITER = "\n§\n";
+export const MEMORY_TARGETS = ["memory", "user", "state", "review"] as const;
+
+export type MemoryTarget = (typeof MEMORY_TARGETS)[number];
+
+export type CuratorState = {
+	lastRunAt?: string;
+	lastRunSummary?: string;
+};
+
+export interface MemoryStore {
+	readEntries(target: MemoryTarget): Promise<string[]>;
+	writeEntries(target: MemoryTarget, entries: string[]): Promise<void>;
+	loadState(): Promise<CuratorState>;
+	saveState(state: CuratorState): Promise<void>;
+}
+
+export function normalizeMemoryTarget(value: string | undefined, fallback: MemoryTarget = "memory"): MemoryTarget {
+	const normalized = (value || fallback).trim().toLowerCase();
+	return MEMORY_TARGETS.includes(normalized as MemoryTarget) ? (normalized as MemoryTarget) : fallback;
+}

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

@@ -0,0 +1,35 @@
+export { auditEntryFromPatch, JsonlAuditLog, type AuditEntry, type AuditLog } from "./curator-core/audit.ts";
+export { runMemoryCuratorOnce, type CuratorRunResult, type RunMemoryCuratorOnceOptions } from "./curator-core/curate.ts";
+export { parseEntry, parseMetadata, renderEntry, serializeMetadata, todayUtc } from "./curator-core/metadata.ts";
+export {
+	createReviewCandidateId,
+	normalizeCandidateSignature,
+	parseReviewCandidate,
+	renderReviewCandidate,
+	upsertReviewCandidate,
+	validateReviewCandidateInput,
+	type ParsedReviewCandidate,
+	type ReviewCandidateInput,
+} from "./learning/candidates.ts";
+export {
+	applyReviewLifecycle,
+	approveMemoryPromotion,
+	proposeMemoryPromotions,
+	rejectReviewItem,
+	type MemoryApprovalResult,
+	type MemoryPromotionResult,
+	type ReviewLifecycleResult,
+} from "./learning/memory.ts";
+export {
+	approveSkillDraft,
+	listSkillDraftProposals,
+	proposeSkillDrafts,
+	type SkillApprovalResult,
+	type SkillProposal,
+	type SkillProposalResult,
+} from "./learning/skills.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 { 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";