@prodero/curator 0.0.0-stage → 0.2.0

package/dist/core/update.js

@@ -0,0 +1,326 @@
+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";
+import { MANUAL_UPDATE_COMMAND, UPDATE_INSTRUCTIONS } from '../update-instructions.js';
+export { MANUAL_UPDATE_COMMAND } from '../update-instructions.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();
+/** MCP/App instructions are inert for every release source, including dev adapters. */
+export function updateInstructions(source = { id: 'npm' }, installedVersion = PRODERO_VERSION) {
+    return { ok: true, action: 'update-instructions', instructionOnly: true, status: 'manual-update',
+        installedVersion, availableVersion: null, source: source.id, restartRequired: false, command: MANUAL_UPDATE_COMMAND, message: UPDATE_INSTRUCTIONS };
+}
+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()}` : ""}`));
+        });
+    });
+}
+/** Legacy internal development build adapter. Never invoked by MCP update instructions. */
+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} ` : ""}${UPDATE_INSTRUCTIONS}` };
+    }
+    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 Curate 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,55 @@
+import { renderTextError } from './text-layout.js';
+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: renderTextError(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: renderTextError(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: renderTextError(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

package/dist/hosts/adapters.js

@@ -0,0 +1,119 @@
+import { PRESENTATION_LAUNCHER } from "../presentation.js";
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { parse as parseToml } from 'smol-toml';
+import { parseTree, modify, applyEdits } from 'jsonc-parser';
+import { fail } from './files.js';
+export const MCP_START = '# prodero:mcp-start', MCP_END = '# prodero:mcp-end';
+export const GLOBAL_START = '<!-- prodero:global-start -->', GLOBAL_END = '<!-- prodero:global-end -->';
+export const LAUNCHER = `${GLOBAL_START}\n## Prodero launcher\n\n${PRESENTATION_LAUNCHER} The connected server resolves the current workspace from the host. Omit \`projectRoot\` normally; use it only to select among host-authorized roots. New projects initialize through Prodero MCP without shell setup.\n${GLOBAL_END}`;
+export function block(text, start, end) {
+    const a = text.indexOf(start), b = text.indexOf(end);
+    if (a < 0 && b < 0)
+        return null;
+    if (a < 0 || b < a || text.indexOf(start, a + start.length) >= 0 || text.indexOf(end, b + end.length) >= 0)
+        fail('HOST_CONFLICT', 'Managed boundaries are missing, duplicated or ambiguous. Review them manually.');
+    return { text: text.slice(a, b + end.length), start: a, end: b + end.length };
+}
+export function replaceBlock(text, start, end, value) {
+    const found = block(text, start, end);
+    if (found)
+        return text.slice(0, found.start) + (value ?? '') + text.slice(found.end);
+    return value === undefined ? text : text + (text && !text.endsWith('\n') ? '\n' : '') + (text ? '\n' : '') + value + '\n';
+}
+export function strictJson(text) {
+    if (!text.trim())
+        fail('HOST_INVALID_CONFIG', 'Empty JSON host configuration. Restore valid JSON before retrying.');
+    const errors = [];
+    const tree = parseTree(text, errors, { allowTrailingComma: false, disallowComments: true });
+    const check = (node) => { if (node.type === 'object') {
+        const keys = node.children?.map(c => c.children[0].value) ?? [];
+        if (new Set(keys).size !== keys.length)
+            fail('HOST_INVALID_CONFIG', 'Duplicate keys in host JSON. Resolve ambiguity before retrying.');
+    } node.children?.forEach(check); };
+    if (errors.length || !tree || tree.type !== 'object')
+        fail('HOST_INVALID_CONFIG', 'Malformed JSON host configuration. Restore valid JSON before retrying.');
+    check(tree);
+    return JSON.parse(text);
+}
+function toml(text) { try {
+    return parseToml(text);
+}
+catch {
+    fail('HOST_INVALID_CONFIG', 'Malformed or ambiguous Codex TOML. Restore valid configuration before retrying.');
+} }
+function map(value) { if (value !== undefined && (!value || typeof value !== 'object' || Array.isArray(value)))
+    fail('HOST_UNSUPPORTED_CONFIG', 'MCP settings must be an object/table. No files changed.'); return value; }
+export async function adapters(home, env, selection) {
+    // Relative overrides would make machine installation depend on the current project.
+    for (const key of (selection === 'codex' ? ['CODEX_HOME'] : selection === 'claude' ? ['CLAUDE_CONFIG_DIR'] : ['CODEX_HOME', 'CLAUDE_CONFIG_DIR']))
+        if (env[key] && !path.isAbsolute(env[key]))
+            fail('HOST_UNSUPPORTED_PATH', 'Host configuration overrides must be absolute paths inside the user home. No files changed.');
+    const codex = env.CODEX_HOME ? path.resolve(env.CODEX_HOME) : path.join(home, '.codex');
+    const claude = env.CLAUDE_CONFIG_DIR ? path.resolve(env.CLAUDE_CONFIG_DIR) : path.join(home, '.claude');
+    const launchers = [path.join(codex, 'AGENTS.md'), path.join(codex, 'AGENTS.override.md')];
+    const override = selection === 'claude' ? null : await fs.lstat(launchers[1]).catch(() => null);
+    const result = [{ id: 'codex', name: 'Codex', support: 'supported', config: path.join(codex, 'config.toml'), launchers, launcher: override && override.size > 0 ? launchers[1] : launchers[0],
+            async detect() { return await executable('codex', env) || Boolean(await fs.lstat(this.config).catch(() => null)); },
+            inspectConfig: toml, entry(text) { return map(toml(text).mcp_servers)?.prodero; },
+            alternateEntry(text) { return map(toml(text).mcp_servers)?.['prodero-dev']; },
+            removeAlternate: removeCodexDev,
+            edit(text, value) {
+                const stanza = value ? `${MCP_START}\n[mcp_servers.prodero]\ncommand = ${JSON.stringify(value.command)}\nargs = ${JSON.stringify(value.args)}\n${value.env ? `env = { ${Object.entries(value.env).map(([k, v]) => `${JSON.stringify(k)} = ${JSON.stringify(v)}`).join(", ")} }\n` : ""}${MCP_END}` : undefined;
+                const next = replaceBlock(text, MCP_START, MCP_END, stanza);
+                toml(next);
+                return next;
+            } },
+        { id: 'claude', name: 'Claude Code', support: 'experimental', config: env.CLAUDE_CONFIG_DIR ? path.join(claude, '.claude.json') : path.join(home, '.claude.json'), launchers: [path.join(claude, 'CLAUDE.md')], launcher: path.join(claude, 'CLAUDE.md'),
+            async detect() { return await executable('claude', env) || Boolean(await fs.lstat(this.config).catch(() => null)); },
+            inspectConfig: strictJson, entry(text) { return map(strictJson(text).mcpServers)?.prodero; },
+            alternateEntry(text) { return map(strictJson(text).mcpServers)?.['prodero-dev']; },
+            removeAlternate(text) { return applyEdits(text, modify(text, ['mcpServers', 'prodero-dev'], undefined, { formattingOptions: { insertSpaces: true, tabSize: 2, eol: '\n' } })); },
+            edit(text, value) { const next = applyEdits(text, modify(text, ['mcpServers', 'prodero'], value, { formattingOptions: { insertSpaces: true, tabSize: 2, eol: '\n' } })); strictJson(next); return next; }
+        }];
+    return selection && selection !== 'all' ? result.filter(host => host.id === selection) : result;
+}
+export async function executable(name, env) {
+    for (const dir of (env.PATH ?? '').split(path.delimiter).filter(d => path.isAbsolute(d))) {
+        try {
+            const p = path.join(dir, name);
+            await fs.access(p, fs.constants.X_OK);
+            if ((await fs.stat(p)).isFile())
+                return true;
+        }
+        catch { }
+    }
+    return false;
+}
+/** Migrate an unambiguous dev table and optional adjacent env table; preserve unrelated bytes. */
+function removeCodexDev(text) {
+    const before = toml(text);
+    const headers = [...text.matchAll(/^\s*\[mcp_servers\.prodero-dev\][ \t]*(?:#[^\r\n]*)?\r?$/gm)];
+    if (headers.length !== 1)
+        fail('HOST_UNSUPPORTED_CONFIG', 'Migration requires one standalone [mcp_servers.prodero-dev] table. Review other TOML forms manually.');
+    const start = headers[0].index, bodyStart = start + headers[0][0].length;
+    const rest = text.slice(bodyStart);
+    let next = /^\s*\[/m.exec(rest), end = next ? bodyStart + next.index : text.length;
+    // Native Codex configurations commonly serialize env as a separate child table.
+    // Remove only this exact adjacent child; the semantic check below rejects any
+    // remaining descendants or other structure we cannot preserve unambiguously.
+    const envHeader = /^\s*\[mcp_servers\.prodero-dev\.env\][ \t]*(?:#[^\r\n]*)?\r?$/m.exec(text.slice(end));
+    if (envHeader?.index === 0) {
+        const afterEnv = end + envHeader[0].length;
+        next = /^\s*\[/m.exec(text.slice(afterEnv));
+        end = next ? afterEnv + next.index : text.length;
+    }
+    const result = text.slice(0, start) + text.slice(end);
+    delete before.mcp_servers['prodero-dev'];
+    const after = toml(result);
+    // Empty parent maps can disappear when their last child table is removed.
+    if (before.mcp_servers && Object.keys(before.mcp_servers).length === 0)
+        delete before.mcp_servers;
+    if (after.mcp_servers && Object.keys(after.mcp_servers).length === 0)
+        delete after.mcp_servers;
+    const stable = (v) => JSON.stringify(v, (_k, value) => value && typeof value === 'object' && !Array.isArray(value) ? Object.fromEntries(Object.entries(value).sort(([a], [b]) => a.localeCompare(b))) : value);
+    if (stable(before) !== stable(after))
+        fail('HOST_UNSUPPORTED_CONFIG', 'Cannot remove the dev table without changing other TOML settings. Review the registration manually.');
+    return result;
+}
+//# sourceMappingURL=adapters.js.map