@prodero/curator 0.0.0-stage → 0.1.0

package/dist/core/telemetry.js

@@ -0,0 +1,64 @@
+import { parseObservationAnnotations } from "./format.js";
+export const TOKEN_COUNT_METHOD = "estimated-utf8-bytes-div-4-v1";
+export const DEFAULT_CONTEXT_BUDGET_TOKENS = 6_000;
+export const DEFAULT_REQUIRED_CONTEXT_BUDGET_TOKENS = 2_000;
+export const MAX_CANONICAL_ITEM_TOKENS = 2_000;
+export const STALE_STATE_AFTER_DAYS = 180;
+/**
+ * Deterministic local approximation: ceil(UTF-8 byte length / 4).
+ * It is deliberately model-neutral and must never be presented as provider billing usage.
+ */
+export function estimateTokens(value) {
+    return value ? Math.ceil(Buffer.byteLength(value, "utf8") / 4) : 0;
+}
+export function knowledgeText(item) {
+    return `${item.title}\n${item.content}`;
+}
+export function safeRatio(numerator, denominator) {
+    if (!Number.isFinite(numerator) || !Number.isFinite(denominator) || denominator <= 0)
+        return 0;
+    return Math.max(0, numerator) / denominator;
+}
+export function contextPressure(requiredTokens, budgetTokens) {
+    const ratio = safeRatio(requiredTokens, budgetTokens);
+    return ratio >= 0.75 ? "high" : ratio >= 0.5 ? "moderate" : "normal";
+}
+export function memoryCompression(rawTokens, canonicalTokens) {
+    if (rawTokens <= 0)
+        return { kind: "unavailable", ratio: null };
+    if (canonicalTokens < rawTokens)
+        return { kind: "compression", ratio: 1 - canonicalTokens / rawTokens };
+    if (canonicalTokens > rawTokens)
+        return { kind: "expansion", ratio: canonicalTokens / rawTokens - 1 };
+    return { kind: "unchanged", ratio: 0 };
+}
+const SECTION_TYPES = {
+    Decisions: "decision",
+    Lessons: "lesson",
+    Discoveries: "discovery",
+    "Project State Changes": "state_change",
+    "Global Instruction Candidates": "global_instruction_candidate",
+    "Skill Candidates": "skill_candidate",
+};
+export function summarizeSessionMemory(session) {
+    const byType = {
+        decision: 0, lesson: 0, discovery: 0, state_change: 0, global_instruction_candidate: 0, skill_candidate: 0,
+    };
+    let observations = 0;
+    let rawSessionTokens = 0;
+    for (const [section, entries] of Object.entries(session.sections)) {
+        const type = SECTION_TYPES[section];
+        if (!type)
+            continue;
+        for (const raw of entries) {
+            const content = parseObservationAnnotations(raw).content;
+            if (!content)
+                continue;
+            observations += 1;
+            byType[type] += 1;
+            rawSessionTokens += estimateTokens(content);
+        }
+    }
+    return { observations, byType, rawSessionTokens };
+}
+//# sourceMappingURL=telemetry.js.map

package/dist/core/templates.js

@@ -0,0 +1,53 @@
+import { fileURLToPath } from "node:url";
+import { MANAGED_END, MANAGED_START, PRODERO_SCHEMA_VERSION } from "./constants.js";
+// The same relative location works from src/core (dev) and dist/core (installed).
+export const AGENT_INSTRUCTIONS_PATH = fileURLToPath(new URL("../../instructions/AGENTS.md", import.meta.url));
+export const AGENTS_BLOCK = `${MANAGED_START}
+Read and follow the instructions returned by prodero_instructions_read from the connected Prodero MCP server.
+${MANAGED_END}`;
+export const INDEX_TEMPLATE = `---
+prodero_schema: ${PRODERO_SCHEMA_VERSION}
+kind: project-index
+generated: true
+---
+
+# Prodero · Project Intelligence
+
+> Compact router for progressive context loading. Open only references relevant to the current task.
+
+## Required Global Context
+
+_No required global knowledge._
+
+## Contextual Knowledge
+
+_No contextual knowledge._
+
+## Local Knowledge
+
+- [Developer-local knowledge](local/index.md) — ignored by Git and retrieved together with Versioned Knowledge.
+
+## Project Skills
+
+_No project skills._
+
+## Loading Rules
+
+1. Use bounded context resolution; required global knowledge is priority-ranked and budgeted.
+2. Follow only bounded graph relationships selected by context resolution; never recursively load the graph or unrelated scopes.
+3. Load relevant project skills; do not recursively load \`.prodero/\`.
+4. Use session memory for agent-inferred observations; normal learning and conversational remember default to Local Knowledge.
+5. Use the promotion review workflow for Versioned Knowledge. Review repository changes before committing or pushing; Prodero does neither.
+`;
+export function replaceManagedBlock(existing) {
+    const start = existing.indexOf(MANAGED_START);
+    const end = existing.indexOf(MANAGED_END);
+    if (start >= 0 && end >= start) {
+        const before = existing.slice(0, start).trimEnd();
+        const after = existing.slice(end + MANAGED_END.length).trimStart();
+        return `${before}${before ? "\n\n" : ""}${AGENTS_BLOCK}${after ? `\n${after}` : "\n"}`;
+    }
+    const prefix = existing.trimEnd();
+    return `${prefix}${prefix ? "\n\n" : ""}${AGENTS_BLOCK}\n`;
+}
+//# sourceMappingURL=templates.js.map

package/dist/core/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/core/update.js

@@ -0,0 +1,320 @@
+import { publicDiagnostic } from "./diagnostics.js";
+import crypto from "node:crypto";
+import { spawn } from "node:child_process";
+import { lstatSync, readFileSync, readdirSync } from "node:fs";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { z } from "zod";
+import { PRODERO_SCHEMA_VERSION, PRODERO_VERSION } from "./constants.js";
+import { writeFileAtomic } from "./storage.js";
+const semverPattern = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/;
+const versionSchema = z.string().regex(semverPattern, "Expected a valid semantic version");
+export const releaseMetadataSchema = z.object({
+    version: versionSchema,
+    schemaVersion: z.number().int().positive(),
+    releaseId: z.string().regex(/^[A-Za-z0-9._-]+$/).max(200),
+    publishedAt: z.string().datetime().optional(),
+    notes: z.string().max(4_000).optional(),
+    artifact: z.object({ locator: z.string().trim().min(1), integrity: z.string().regex(/^sha256:[a-f0-9]{64}$/) }).strict(),
+}).strict();
+export const MANUAL_UPDATE_COMMAND = "npm install --global @prodero/curator@latest";
+export class ReleaseSourceUnavailableError extends Error {
+}
+function parseVersion(value) {
+    const match = semverPattern.exec(value);
+    if (!match)
+        throw new Error(`Invalid semantic version: ${value}`);
+    return { core: [Number(match[1]), Number(match[2]), Number(match[3])], prerelease: match[4]?.split(".") ?? [] };
+}
+/** Compare strict SemVer values. Build metadata does not affect precedence. */
+export function compareVersions(left, right) {
+    const a = parseVersion(left), b = parseVersion(right);
+    for (let index = 0; index < 3; index += 1)
+        if (a.core[index] !== b.core[index])
+            return a.core[index] > b.core[index] ? 1 : -1;
+    if (!a.prerelease.length || !b.prerelease.length)
+        return a.prerelease.length === b.prerelease.length ? 0 : a.prerelease.length ? -1 : 1;
+    for (let index = 0; index < Math.max(a.prerelease.length, b.prerelease.length); index += 1) {
+        const av = a.prerelease[index], bv = b.prerelease[index];
+        if (av === undefined || bv === undefined)
+            return av === bv ? 0 : av === undefined ? -1 : 1;
+        if (av === bv)
+            continue;
+        const an = /^\d+$/.test(av), bn = /^\d+$/.test(bv);
+        if (an && bn)
+            return Number(av) > Number(bv) ? 1 : -1;
+        if (an !== bn)
+            return an ? -1 : 1;
+        return av > bv ? 1 : -1;
+    }
+    return 0;
+}
+export class UnconfiguredReleaseSource {
+    id = "unconfigured";
+    async latest() { return null; }
+    async stage() { throw new Error("No Prodero release source is configured."); }
+}
+const LOCAL_RELEASE_FILES = ["package.json", "package-lock.json", "prodero.release.json", "tsconfig.json", "vite.config.ts", "src", "scripts", "bin", "plugins"];
+const MAX_LOCAL_RELEASE_FILES = 5_000;
+const MAX_LOCAL_RELEASE_BYTES = 64 * 1024 * 1024;
+function localCheckoutDigest(root) {
+    const digest = crypto.createHash("sha256");
+    let files = 0, bytes = 0;
+    const visit = (relative) => {
+        const absolute = path.join(root, relative);
+        let stat;
+        try {
+            stat = lstatSync(absolute);
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                return;
+            throw error;
+        }
+        if (stat.isSymbolicLink())
+            throw new Error(`Local release source contains a symlink: ${relative}`);
+        if (stat.isDirectory()) {
+            for (const name of readdirSync(absolute).sort())
+                visit(path.join(relative, name));
+            return;
+        }
+        if (!stat.isFile())
+            return;
+        files += 1;
+        bytes += stat.size;
+        if (files > MAX_LOCAL_RELEASE_FILES || bytes > MAX_LOCAL_RELEASE_BYTES)
+            throw new Error("Local release source exceeds the bounded release snapshot.");
+        digest.update(`F\0${relative.split(path.sep).join("/")}\0${stat.size}\0`);
+        digest.update(readFileSync(absolute));
+        digest.update("\0");
+    };
+    for (const relative of LOCAL_RELEASE_FILES)
+        visit(relative);
+    return digest.digest("hex");
+}
+async function runLocalBuild(root, signal) {
+    await new Promise((resolve, reject) => {
+        const child = spawn(process.platform === "win32" ? "npm.cmd" : "npm", ["run", "build"], { cwd: root, stdio: ["ignore", "pipe", "pipe"] });
+        let output = "";
+        const append = (chunk) => { output = `${output}${chunk.toString("utf8")}`.slice(-8_000); };
+        child.stdout.on("data", append);
+        child.stderr.on("data", append);
+        const abort = () => child.kill("SIGTERM");
+        signal?.addEventListener("abort", abort, { once: true });
+        child.once("error", reject);
+        child.once("exit", (code, terminationSignal) => {
+            signal?.removeEventListener("abort", abort);
+            if (signal?.aborted)
+                reject(new InterruptedUpdateError("Local release build was interrupted."));
+            else if (code === 0)
+                resolve();
+            else
+                reject(new Error(`Local release build failed with ${terminationSignal ? `signal ${terminationSignal}` : `exit code ${code ?? "unknown"}`}.${output.trim() ? `\n${output.trim()}` : ""}`));
+        });
+    });
+}
+/** One-click adapter for an MCP runtime launched from a development checkout. */
+export class LocalCheckoutReleaseSource {
+    root;
+    id = "local-checkout";
+    installedReleaseId;
+    constructor(root) {
+        this.root = root;
+        this.installedReleaseId = `local-${localCheckoutDigest(root)}`;
+    }
+    async latest() {
+        const identity = JSON.parse(await fs.readFile(path.join(this.root, "package.json"), "utf8"));
+        const releaseIdentity = z.object({ formatVersion: z.literal(1), schemaVersion: z.number().int().positive() }).strict().parse(JSON.parse(await fs.readFile(path.join(this.root, "prodero.release.json"), "utf8")));
+        const version = versionSchema.parse(identity.version);
+        const hash = localCheckoutDigest(this.root);
+        return { version, schemaVersion: releaseIdentity.schemaVersion, releaseId: `local-${hash}`, artifact: { locator: ".", integrity: `sha256:${hash}` } };
+    }
+    async stage(release, signal) {
+        const before = await this.latest();
+        if (before.releaseId !== release.releaseId || before.artifact.integrity !== release.artifact.integrity)
+            throw new InterruptedUpdateError("Local release source changed after update review; check again.");
+        await runLocalBuild(this.root, signal);
+        const after = await this.latest();
+        if (after.releaseId !== release.releaseId || after.artifact.integrity !== release.artifact.integrity)
+            throw new InterruptedUpdateError("Local release source changed while it was being built; no activation was recorded.");
+        return { restartRequired: true, detail: `Local checkout ${this.root} built and verified successfully.` };
+    }
+}
+const localManifestSchema = z.object({
+    formatVersion: z.literal(1), release: z.unknown().nullable(),
+    simulation: z.object({ outcome: z.enum(["success", "failed", "interrupted"]), message: z.string().optional() }).strict().optional(),
+}).strict();
+class InterruptedUpdateError extends Error {
+}
+/** Deterministic source used for local development and contract tests. */
+export class LocalManifestReleaseSource {
+    manifestPath;
+    stateDirectory;
+    id = "local-manifest";
+    constructor(manifestPath, stateDirectory = path.join(path.dirname(manifestPath), ".prodero-update-state")) {
+        this.manifestPath = manifestPath;
+        this.stateDirectory = stateDirectory;
+    }
+    async manifest() { return localManifestSchema.parse(JSON.parse(await fs.readFile(this.manifestPath, "utf8"))); }
+    async latest() { return (await this.manifest()).release; }
+    async stage(release, signal) {
+        signal?.throwIfAborted();
+        const manifest = await this.manifest();
+        const simulation = manifest.simulation?.outcome ?? "success";
+        if (simulation === "failed")
+            throw new Error(manifest.simulation?.message ?? "Local release installation failed.");
+        if (simulation === "interrupted")
+            throw new InterruptedUpdateError(manifest.simulation?.message ?? "Local release installation was interrupted.");
+        const manifestDirectory = path.dirname(this.manifestPath);
+        const artifactPath = path.resolve(manifestDirectory, release.artifact.locator);
+        if (path.isAbsolute(release.artifact.locator) || (artifactPath !== manifestDirectory && !artifactPath.startsWith(`${manifestDirectory}${path.sep}`)))
+            throw new Error("Release artifact must stay inside the local manifest directory.");
+        const artifact = await fs.readFile(artifactPath);
+        const integrity = `sha256:${crypto.createHash("sha256").update(artifact).digest("hex")}`;
+        if (integrity !== release.artifact.integrity)
+            throw new Error("Release artifact integrity verification failed.");
+        await fs.mkdir(this.stateDirectory, { recursive: true });
+        const stagedPath = path.join(this.stateDirectory, `${release.releaseId}.artifact`);
+        const temporary = `${stagedPath}.partial-${process.pid}`;
+        try {
+            await fs.writeFile(temporary, artifact, { flag: "wx" });
+            signal?.throwIfAborted();
+            await fs.rename(temporary, stagedPath);
+            await writeFileAtomic(path.join(this.stateDirectory, "pending.json"), `${JSON.stringify({ formatVersion: 1, release, stagedPath, stagedAt: new Date().toISOString() }, null, 2)}\n`);
+        }
+        catch (error) {
+            await fs.rm(temporary, { force: true }).catch(() => { });
+            throw error;
+        }
+        return { restartRequired: true, detail: `Release ${release.version} was verified and staged at ${stagedPath}.` };
+    }
+}
+/** npm is read-only here: package installation always belongs to the user's package manager. */
+export class NpmReleaseSource {
+    request;
+    id = "npm";
+    constructor(request = fetch) {
+        this.request = request;
+    }
+    async latest(signal) {
+        try {
+            const response = await this.request("https://registry.npmjs.org/@prodero%2fcurator/latest", { signal, redirect: "error" });
+            if (response.status === 404)
+                return null;
+            if (!response.ok)
+                throw new Error("Registry unavailable");
+            return await response.json();
+        }
+        catch {
+            throw new ReleaseSourceUnavailableError("Cannot reach the public npm release source. Installed knowledge is unaffected.");
+        }
+    }
+    async stage() { throw new Error(`Use ${MANUAL_UPDATE_COMMAND}`); }
+}
+export function configuredReleaseSource(environment = process.env) {
+    if (environment.PRODERO_RELEASE_SOURCE === "none")
+        return new UnconfiguredReleaseSource();
+    if (environment.PRODERO_DEV_UPDATE === "1") {
+        const manifest = environment.PRODERO_RELEASE_MANIFEST?.trim();
+        if (manifest)
+            return new LocalManifestReleaseSource(path.resolve(manifest), environment.PRODERO_UPDATE_STATE_DIR?.trim());
+        const checkout = environment.PRODERO_LOCAL_RELEASE_CHECKOUT?.trim();
+        if (checkout)
+            return new LocalCheckoutReleaseSource(path.resolve(checkout));
+        return new UnconfiguredReleaseSource();
+    }
+    return new NpmReleaseSource();
+}
+function updateAvailable(source, release, installedVersion) {
+    const precedence = compareVersions(release.version, installedVersion);
+    return precedence > 0 || (precedence === 0 && Boolean(source.installedReleaseId) && source.installedReleaseId !== release.releaseId);
+}
+async function checkReleaseUpdate(source = configuredReleaseSource(), installedVersion = PRODERO_VERSION) {
+    let raw;
+    try {
+        versionSchema.parse(installedVersion);
+        raw = await source.latest(AbortSignal.timeout(2_500));
+    }
+    catch (error) {
+        const status = error instanceof ReleaseSourceUnavailableError || (error instanceof DOMException && ["AbortError", "TimeoutError"].includes(error.name)) ? "unavailable" : "invalid";
+        return { current: installedVersion, latest: null, available: false, source: source.id, status, installedSchemaVersion: PRODERO_SCHEMA_VERSION, availableSchemaVersion: null, error: publicDiagnostic(error) };
+    }
+    if (raw === null)
+        return { current: installedVersion, latest: null, available: false, source: source.id, status: "unavailable", installedSchemaVersion: PRODERO_SCHEMA_VERSION, availableSchemaVersion: null };
+    try {
+        const release = releaseMetadataSchema.parse(raw);
+        if (release.schemaVersion < PRODERO_SCHEMA_VERSION)
+            throw new Error(`Release schema v${release.schemaVersion} is older than installed schema v${PRODERO_SCHEMA_VERSION}.`);
+        const available = updateAvailable(source, release, installedVersion);
+        return { current: installedVersion, latest: release.version, available, source: source.id, status: available ? "update-available" : "current", installedSchemaVersion: PRODERO_SCHEMA_VERSION, availableSchemaVersion: release.schemaVersion };
+    }
+    catch (error) {
+        return { current: installedVersion, latest: null, available: false, source: source.id, status: "invalid", installedSchemaVersion: PRODERO_SCHEMA_VERSION, availableSchemaVersion: null, error: publicDiagnostic(error) };
+    }
+}
+export async function checkForUpdate(source = configuredReleaseSource(), installedVersion = PRODERO_VERSION) {
+    if (!(source instanceof NpmReleaseSource)) {
+        const result = await checkReleaseUpdate(source, installedVersion);
+        return { ...result, manualUpdateCommand: MANUAL_UPDATE_COMMAND, developmentOnly: source.id !== "unconfigured",
+            ...(result.status === "unavailable" && !result.error ? { error: "No production release source is configured or no release is available." } : {}) };
+    }
+    const base = { current: installedVersion, latest: null, available: false, source: source.id, installedSchemaVersion: PRODERO_SCHEMA_VERSION, availableSchemaVersion: null, manualUpdateCommand: MANUAL_UPDATE_COMMAND, developmentOnly: false };
+    try {
+        const raw = await source.latest(AbortSignal.timeout(2_500));
+        if (raw === null)
+            return { ...base, status: "unavailable", error: "No public npm release is available yet." };
+        const { version } = z.object({ version: versionSchema }).parse(raw);
+        const available = compareVersions(version, installedVersion) > 0;
+        return { ...base, latest: version, available, status: available ? "update-available" : "current" };
+    }
+    catch (error) {
+        return { ...base, status: error instanceof ReleaseSourceUnavailableError ? "unavailable" : "invalid", error: error instanceof ReleaseSourceUnavailableError ? error.message : "Invalid version metadata from the npm release source." };
+    }
+}
+export async function installLatest(source = configuredReleaseSource(), installedVersion = PRODERO_VERSION) {
+    if (source instanceof NpmReleaseSource || source instanceof UnconfiguredReleaseSource) {
+        const check = await checkForUpdate(source, installedVersion);
+        return { ok: true, status: "manual-update", installedVersion, availableVersion: check.latest, source: source.id, restartRequired: false,
+            message: `${check.error ? `${check.error} ` : ""}Run: ${MANUAL_UPDATE_COMMAND}. Then restart your MCP host. This tool has not installed or changed anything. Project knowledge remains in the project .prodero directory.` };
+    }
+    let raw;
+    try {
+        raw = await source.latest(AbortSignal.timeout(2_500));
+    }
+    catch (error) {
+        if (error instanceof ReleaseSourceUnavailableError || (error instanceof DOMException && ["AbortError", "TimeoutError"].includes(error.name)))
+            return unavailable(source, installedVersion, error);
+        return failure("invalid", source, installedVersion, null, error);
+    }
+    if (raw === null)
+        return { ok: false, status: "unavailable", installedVersion, availableVersion: null, source: source.id, restartRequired: false, message: "No Prodero release source is configured or no release is available." };
+    let release;
+    try {
+        release = releaseMetadataSchema.parse(raw);
+        compareVersions(release.version, installedVersion);
+        if (release.schemaVersion < PRODERO_SCHEMA_VERSION)
+            throw new Error(`Release schema v${release.schemaVersion} is older than installed schema v${PRODERO_SCHEMA_VERSION}.`);
+    }
+    catch (error) {
+        return failure("invalid", source, installedVersion, null, error);
+    }
+    if (!updateAvailable(source, release, installedVersion))
+        return { ok: true, status: "current", installedVersion, availableVersion: release.version, source: source.id, restartRequired: false, message: `Prodero ${installedVersion} is already current.` };
+    try {
+        const staged = await source.stage(release, AbortSignal.timeout(30_000));
+        return { ok: true, status: "restart-required", installedVersion, availableVersion: release.version, source: source.id, restartRequired: staged.restartRequired, message: `${staged.detail ?? `Prodero ${release.version} was staged.`} Development-only staging. Restart the Prodero MCP runtime after a checkout rebuild; manifest simulation has no production activation consumer.` };
+    }
+    catch (error) {
+        const interrupted = error instanceof InterruptedUpdateError || (error instanceof DOMException && ["AbortError", "TimeoutError"].includes(error.name));
+        return failure(interrupted ? "interrupted" : "failed", source, installedVersion, release.version, error);
+    }
+}
+function unavailable(source, installedVersion, error) {
+    const detail = publicDiagnostic(error);
+    return { ok: false, status: "unavailable", installedVersion, availableVersion: null, source: source.id, restartRequired: false, message: `Prodero release source is unavailable: ${detail}` };
+}
+function failure(status, source, installedVersion, availableVersion, error) {
+    const detail = publicDiagnostic(error);
+    return { ok: false, status, installedVersion, availableVersion, source: source.id, restartRequired: false, message: `Prodero update ${status}: ${detail}` };
+}
+//# sourceMappingURL=update.js.map

package/dist/curation-review-adapter.js

@@ -0,0 +1,92 @@
+/** App review is a workflow safeguard, not authentication of human consent.
+ * The adapter validates the saved review before issuing an exact Core grant;
+ * MCP Apps visibility/capability does not authenticate a physical user action.
+ * Future interactive text confirmation can call this same executor after its own
+ * protocol response; the public text gateway must never dispatch here directly. */
+import { assertSafeCurationData } from './core/curation-evidence.js';
+import { withSyncLock, recoverSyncTransaction } from './core/sync-transaction.js';
+import { listCheckpoints } from './core/storage.js';
+import { buildIndex } from './core/index.js';
+import { planKnowledgeCuration, curationReviewEntries, applyKnowledgeCuration, StaleCurationPlanError } from './core/knowledge-curation.js';
+import { withTrustedKnowledgeBatch } from './core/knowledge-authority.js';
+import { curationReceiptProjection, curationReviewView, assertCurationHead, ensureCurationSuccessor, validateRevisionReceipt, reserveSuccessorCapacity, loadCurationReview, selectedCurationProposals, curationOperationId, CurationReviewError } from './core/curation-review.js';
+import { validateRevision, deterministicBaseline, curationSelectionHash, selectionProblems, revisionHash } from './core/curation-revision.js';
+import { semanticReviewStatus } from './core/curation-semantic-jobs.js';
+import path from 'node:path';
+import fs from 'node:fs/promises';
+export async function executeCurationReview(root, input) {
+    const selected = [...input.selectedIds].sort();
+    if (!/^review_[a-zA-Z0-9_]+$/.test(input.reviewId) || !selected.length || new Set(selected).size !== selected.length)
+        throw new CurationReviewError('invalid_selection', 'Select a valid, non-empty set of suggestions.');
+    const operationId = curationOperationId(input.reviewId, selected, input.reviewRevisionId, input.selectionHash);
+    return withSyncLock(root, async () => {
+        await recoverSyncTransaction(root);
+        const history = await listCheckpoints(root);
+        const prior = history.find(c => c.curation?.review?.operationId === operationId);
+        const result = (receipt, checkpointId, replayed) => ({ status: 'applied', ...receipt, checkpointId, appliedGroupCount: receipt.reviewSnapshot?.units.filter(u => u.proposalIds.every(id => receipt.applied.includes(id))).length ?? receipt.applied.length, historyPath: path.join(path.resolve(root), '.prodero', 'checkpoints', `${checkpointId}.json`), replayed });
+        if (prior) {
+            const stored = prior.curation;
+            assertSafeCurationData(stored);
+            if (stored.plan.project !== path.resolve(root) || stored.review.planHash !== input.planHash || stored.review.projectIdentity !== await fs.realpath(root))
+                throw new CurationReviewError('review_changed', 'This request does not match the completed review.');
+            if (stored.review.reviewRevisionId) {
+                validateRevisionReceipt(stored.review);
+                if (input.reviewRevisionId !== stored.review.reviewRevisionId || input.decisionRevision !== stored.review.decisionRevision || input.selectionHash !== stored.review.selectionHash || JSON.stringify(selected) !== JSON.stringify(stored.review.selectedIds))
+                    throw new CurationReviewError('review_changed', 'This request does not match the completed revision.');
+            }
+            await buildIndex(root);
+            const successor = await ensureCurationSuccessor(root, stored.review);
+            return { ...result(stored.review, prior.id, true), successor, projection: successor ? (await curationReviewView(root, successor.snapshot.plan, successor)).projection : curationReceiptProjection(stored.plan, stored.review) };
+        }
+        const review = await loadCurationReview(root, input.reviewId);
+        if (review.snapshot.plan.memorySyncSources)
+            throw new CurationReviewError('invalid_selection', 'Sync analysis is read-only; continue its owning Sync Memory operation.');
+        if (review.snapshot.planHash !== input.planHash)
+            throw new CurationReviewError('stale_review', 'Knowledge changed since this review.');
+        if (review.state.revision !== input.decisionRevision)
+            throw new CurationReviewError('review_changed', 'Your review changed in another window. Reload your decisions.');
+        const revision = review.snapshot.revision;
+        if (revision) {
+            validateRevision(revision);
+            if (input.reviewRevisionId !== revision.id)
+                throw new CurationReviewError('stale_review', 'Apply requires the exact review revision.');
+            if (input.selectionHash !== curationSelectionHash(revision.id, input.decisionRevision, selected))
+                throw new CurationReviewError('invalid_selection', 'Apply selection hash changed.');
+            if (history.some(c => c.curation?.review?.reviewRevisionId === revision.id))
+                throw new CurationReviewError('stale_review', 'This revision was applied. Review its successor.');
+        }
+        else if (input.reviewRevisionId || input.selectionHash)
+            throw new CurationReviewError('invalid_review', 'Legacy review has no revision binding.');
+        if (revision)
+            await assertCurationHead(root, review);
+        const derived = selectedCurationProposals(review);
+        if (revision ? selected.some(id => !derived.includes(id)) : JSON.stringify(derived) !== JSON.stringify(selected))
+            throw new CurationReviewError('invalid_selection', 'Apply must match your saved review decisions.');
+        if (revision) {
+            const problems = selectionProblems(revision.dependencies, selected);
+            if (problems.length)
+                throw new CurationReviewError('dependency_blocked', 'Selected changes require unresolved information or additional reviewed groups.', { problems });
+        }
+        if (revision) {
+            const semantic = await semanticReviewStatus(root, review);
+            if (revision.dependencies.groups.some(g => semantic.blockedGroupIds.includes(g.id) && g.proposalIds.some(id => selected.includes(id))))
+                throw new CurationReviewError('dependency_blocked', 'Selected changes await semantic analysis or updated answers.');
+        }
+        // Validate selection, including dependency closure, independently of the UI.
+        const entries = curationReviewEntries(review.snapshot.plan, selected, revision);
+        const current = await planKnowledgeCuration(root).catch(() => { throw new CurationReviewError('stale_review', 'Knowledge can no longer be validated against this review. Review updated changes.'); });
+        if (current.planId !== (revision ? deterministicBaseline(revision).planId : review.snapshot.planHash) || current.fingerprint !== review.snapshot.plan.fingerprint)
+            throw new CurationReviewError('stale_review', 'Knowledge changed since this review.');
+        if (revision)
+            await reserveSuccessorCapacity(root);
+        const receipt = { ...(revision ? { reviewRevisionId: revision.id, selectionHash: input.selectionHash, reviewSnapshot: review.snapshot, reviewState: review.state, executionHash: revisionHash([review.snapshot.snapshotHash, review.state, selected]) } : {}), projectIdentity: review.snapshot.projectIdentity, decisions: review.state.decisions, reviewId: input.reviewId, planHash: input.planHash, operationId, decisionRevision: input.decisionRevision, selectedIds: selected, applied: selected, unselected: review.snapshot.plan.proposals.filter(p => !selected.includes(p.id) && !p.attention.length).map(p => p.id), unresolved: review.snapshot.plan.proposals.filter(p => p.attention.length).map(p => p.id) };
+        const applied = await withTrustedKnowledgeBatch(root, entries, `app-review:${operationId}`, () => applyKnowledgeCuration(root, review.snapshot.plan, selected, receipt)).catch(error => {
+            if (error instanceof StaleCurationPlanError)
+                throw new CurationReviewError('stale_review', 'Knowledge changed since this review.');
+            throw error;
+        });
+        const successor = await ensureCurationSuccessor(root, receipt);
+        return { ...result(receipt, applied.checkpoint, false), successor, projection: successor ? (await curationReviewView(root, successor.snapshot.plan, successor)).projection : curationReceiptProjection(review.snapshot.plan, receipt) };
+    }, { waitMs: 2000 });
+}
+//# sourceMappingURL=curation-review-adapter.js.map

package/dist/diagnostic-boundary.js

@@ -0,0 +1,54 @@
+import { publicDiagnostic } from "./core/diagnostics.js";
+// Preserve only known protocol states, with fixed public prose. Never forward
+// arbitrary plugin error payloads or client-supplied diagnostics.
+const reviewMessages = {
+    semantic_invalid: 'Semantic reasoning input or saved state is invalid.',
+    semantic_limit: 'Semantic reasoning reached its bounded limit. Saved state was preserved.',
+    semantic_stale: 'Semantic reasoning input is obsolete. Inspect the current review.',
+    dependency_blocked: 'Selected changes require unresolved information or additional reviewed groups.',
+    unsupported_review_schema: 'This review uses a newer format. Update Prodero.',
+    review_retention_full: 'Saved review decisions reached the retention limit. No decisions were deleted.',
+    review_paused: 'Resume this review before applying changes.',
+    stale_review: 'Knowledge changed since this review.',
+    invalid_review: 'Review is unavailable. Analyze knowledge again.',
+    invalid_selection: 'Apply must match valid saved review decisions and complete groups.',
+    project_mismatch: 'Review belongs to another project.',
+    review_changed: 'Your review changed in another window. Reload your decisions.',
+    review_too_large: 'Review is too large. Reduce the review scope first.',
+    recovery_required: 'Finish the pending transaction before starting a new review.',
+    review_unavailable: 'This connection does not advertise MCP Apps support. Knowledge review is preview-only.',
+};
+/** Wrap the public request registration API, including SDK validation before tool handlers. */
+export function installDiagnosticBoundary(server) {
+    const register = server.server.setRequestHandler.bind(server.server);
+    server.server.setRequestHandler = (schema, handler) => register(schema, async (request, extra) => {
+        try {
+            const result = await handler(request, extra);
+            if (result && typeof result === "object" && "isError" in result && result.isError) {
+                const raw = result;
+                const state = raw.structuredContent;
+                if (state?.action === 'curation-review-error' && typeof state.code === 'string' && Object.hasOwn(reviewMessages, state.code)) {
+                    const message = reviewMessages[state.code];
+                    return { isError: true, content: [{ type: 'text', text: message }], structuredContent: { ok: false, action: 'curation-review-error', code: state.code, error: message, message, ...(state.code === 'dependency_blocked' ? { details: safeDependencyDetails(state.details) } : {}) } };
+                }
+                const message = raw.structuredContent?.error ?? raw.content?.find(item => item.type === "text")?.text;
+                const safe = publicDiagnostic(message);
+                // Drop arbitrary plugin error payloads too: they may contain rejected input.
+                return { isError: true, content: [{ type: "text", text: safe }], structuredContent: { ok: false, error: safe, message: safe, ...(safe.startsWith("POLICY_REVIEW_REQUIRED:") ? { policyTransition: { decision: "review_required", blocking: true, preserved: true } } : {}) } };
+            }
+            return result;
+        }
+        catch (error) {
+            if (error && typeof error === 'object' && 'code' in error && typeof error.code === 'string' && Object.hasOwn(reviewMessages, error.code)) {
+                const message = reviewMessages[error.code];
+                return { isError: true, content: [{ type: 'text', text: message }], structuredContent: { ok: false, action: 'curation-review-error', code: error.code, error: message, message } };
+            }
+            throw new Error(publicDiagnostic(error));
+        }
+    });
+}
+function safeDependencyDetails(value) {
+    const problems = value?.problems;
+    return { problems: Array.isArray(problems) ? problems.slice(0, 1000).flatMap((raw) => typeof raw?.groupId === 'string' && /^item_[a-f0-9]{24}$/.test(raw.groupId) && ['incomplete', 'blocked', 'requires', 'partial_group'].includes(raw.reason) ? [{ groupId: raw.groupId, reason: raw.reason, missing: Array.isArray(raw.missing) ? raw.missing.filter((v) => typeof v === 'string' && /^(?:item|issue)_[a-f0-9]{24}$/.test(v)) : [] }] : []) : [] };
+}
+//# sourceMappingURL=diagnostic-boundary.js.map

package/dist/filesystem/permissions.js

@@ -0,0 +1,39 @@
+import fs from 'node:fs/promises';
+import { constants } from 'node:fs';
+// Shared with host integration state. Windows uses its native ACL/inheritance model.
+export const PRIVATE_DIRECTORY_MODE = 0o700;
+export const PRIVATE_FILE_MODE = 0o600;
+/** Tighten only the explicitly addressed inode, never a linked file or another owner's data. */
+export async function tightenPrivateMode(target) {
+    if (process.platform === 'win32')
+        return;
+    const stat = await fs.lstat(target).catch(error => { if (error.code === 'ENOENT')
+        return null; throw error; });
+    if (!stat)
+        return;
+    // A concurrent lock release can unlink an inode while lstat is resolving it.
+    // Accept only a vanished, owned regular file; any replacement still fails closed.
+    if (stat.isFile() && stat.nlink === 0 && process.getuid && stat.uid === process.getuid()) {
+        const remaining = await fs.lstat(target).catch(error => { if (error.code === 'ENOENT')
+            return null; throw error; });
+        if (!remaining)
+            return;
+    }
+    if (stat.isSymbolicLink() || (!stat.isDirectory() && !stat.isFile()) || (stat.isFile() && stat.nlink !== 1)
+        || (process.getuid && stat.uid !== process.getuid()))
+        throw new Error('Unsafe private state permissions target');
+    const mode = stat.isDirectory() ? PRIVATE_DIRECTORY_MODE : PRIVATE_FILE_MODE;
+    if ((stat.mode & 0o7777) === mode)
+        return;
+    const handle = await fs.open(target, constants.O_RDONLY | constants.O_NOFOLLOW);
+    try {
+        const current = await handle.stat();
+        if (current.dev !== stat.dev || current.ino !== stat.ino || current.nlink !== stat.nlink || current.uid !== stat.uid)
+            throw new Error('Private state changed while tightening permissions');
+        await handle.chmod(mode);
+    }
+    finally {
+        await handle.close();
+    }
+}
+//# sourceMappingURL=permissions.js.map