loadout-ai 0.5.8 → 0.6.0

package/dist/src/core/intelligence-feed.js

@@ -1,353 +0,0 @@
-import { createHash, createPublicKey } from "node:crypto";
-import { readFile, rm, stat } from "node:fs/promises";
-import { dirname, join, resolve } from "node:path";
-import { z } from "zod";
-import { writeFileAtomically } from "./atomic-file.js";
-import { compatibilityNoticeSchema } from "./compatibility-intelligence.js";
-import { fetchBoundedJson } from "./discovery-connector.js";
-import { withFileLock } from "./file-lock.js";
-import { loadoutHome } from "./paths.js";
-import { publicKeyFingerprint, signPayload, verifyEnvelope, } from "./signing.js";
-const MAX_FEED_BYTES = 2 * 1024 * 1024;
-const MAX_KEY_BYTES = 64 * 1024;
-const DEFAULT_MAX_AGE_MS = 48 * 60 * 60 * 1000;
-const DEFAULT_MAX_STALE_MS = 7 * 24 * 60 * 60 * 1000;
-const timestamp = z.string().datetime({ offset: true });
-const httpsUrl = z
-    .string()
-    .url()
-    .refine((value) => {
-    const url = new URL(value);
-    return url.protocol === "https:" && !url.username && !url.password;
-}, "credential-free HTTPS URL required");
-const identifier = z
-    .string()
-    .min(1)
-    .max(200)
-    .regex(/^[A-Za-z0-9][A-Za-z0-9._:/@+-]*$/);
-const discoveryObservationSchema = z
-    .object({
-    id: identifier,
-    source: z.enum([
-        "github",
-        "hacker-news",
-        "skills-sh",
-        "official-mcp-registry",
-    ]),
-    observedAt: timestamp,
-    sourceUrl: httpsUrl,
-    identityKey: z.string().min(1).max(300),
-    signal: z.string().min(1).max(300),
-})
-    .strict();
-const candidateSummarySchema = z
-    .object({
-    id: identifier,
-    repository: z.string().regex(/^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/),
-    commit: z.string().regex(/^[a-f0-9]{40}$/),
-    observedAt: timestamp,
-    status: z.enum(["inspected", "candidate", "rejected"]),
-    summary: z.string().min(1).max(500),
-    dossierSha256: z.string().regex(/^[a-f0-9]{64}$/),
-})
-    .strict();
-const benchmarkChangeSchema = z
-    .object({
-    evidenceId: identifier,
-    candidateId: identifier,
-    taskFamily: identifier,
-    change: z.enum(["added", "superseded", "withdrawn"]),
-    evidenceSha256: z.string().regex(/^[a-f0-9]{64}$/),
-})
-    .strict();
-const catalogPointerSchema = z
-    .object({
-    url: httpsUrl,
-    createdAt: timestamp,
-    signerFingerprint: z.string().regex(/^sha256:[a-f0-9]{64}$/),
-    envelopeSha256: z.string().regex(/^[a-f0-9]{64}$/),
-})
-    .strict();
-export const intelligenceFeedPayloadSchema = z
-    .object({
-    schemaVersion: z.literal(1),
-    sequence: z.number().int().positive().max(Number.MAX_SAFE_INTEGER),
-    createdAt: timestamp,
-    expiresAt: timestamp,
-    publicDataOnly: z.literal(true),
-    discoveryObservations: z.array(discoveryObservationSchema).max(5_000),
-    compatibilityNotices: z.array(compatibilityNoticeSchema).max(2_000),
-    candidateSummaries: z.array(candidateSummarySchema).max(2_000),
-    benchmarkChanges: z.array(benchmarkChangeSchema).max(2_000),
-    catalogRelease: catalogPointerSchema.optional(),
-})
-    .strict();
-const envelopeSchema = z
-    .object({
-    schemaVersion: z.literal(1),
-    algorithm: z.literal("Ed25519"),
-    createdAt: timestamp,
-    publicKeyFingerprint: z.string().regex(/^sha256:[a-f0-9]{64}$/),
-    payload: intelligenceFeedPayloadSchema,
-    signature: z.string().min(1).max(1024),
-})
-    .strict();
-function defaultStatePath() {
-    return join(loadoutHome(), "intelligence", "trust.json");
-}
-function defaultCachePath() {
-    return join(loadoutHome(), "intelligence", "latest.json");
-}
-function feedLockPath(statePath) {
-    return join(dirname(statePath), "feed.lock");
-}
-async function readBounded(path, maximum, label) {
-    const info = await stat(path);
-    if (!info.isFile() || info.size > maximum)
-        throw new Error(`${label} exceeds its byte limit`);
-    const content = await readFile(path, "utf8");
-    if (Buffer.byteLength(content) > maximum)
-        throw new Error(`${label} exceeds its byte limit`);
-    return content;
-}
-async function readTrustState(path) {
-    try {
-        const value = JSON.parse(await readBounded(path, 64 * 1024, "Intelligence trust state"));
-        const state = value;
-        if (!value ||
-            typeof value !== "object" ||
-            Array.isArray(value) ||
-            state.schemaVersion !== 1 ||
-            typeof state.fingerprint !== "string" ||
-            !/^sha256:[a-f0-9]{64}$/.test(state.fingerprint) ||
-            !Number.isSafeInteger(state.highWaterSequence) ||
-            Number(state.highWaterSequence) < 0 ||
-            typeof state.highWaterCreatedAt !== "string" ||
-            !Number.isFinite(Date.parse(state.highWaterCreatedAt)) ||
-            (state.pendingRotationFingerprint !== undefined &&
-                !/^sha256:[a-f0-9]{64}$/.test(state.pendingRotationFingerprint)))
-            throw new Error("Intelligence trust state is invalid");
-        return state;
-    }
-    catch (error) {
-        if (error.code === "ENOENT")
-            return undefined;
-        throw error;
-    }
-}
-async function readSource(source, fetcher) {
-    if (/^https:\/\//i.test(source))
-        return (await fetchBoundedJson(source, { fetcher, maximumBytes: MAX_FEED_BYTES })).value;
-    if (/^[a-z]+:\/\//i.test(source))
-        throw new Error("Remote intelligence feeds must use HTTPS");
-    return JSON.parse(await readBounded(resolve(source), MAX_FEED_BYTES, "Intelligence feed"));
-}
-function envelopeHash(envelope) {
-    return createHash("sha256").update(JSON.stringify(envelope)).digest("hex");
-}
-function validateFreshness(payload, now, maxAgeMs) {
-    const created = Date.parse(payload.createdAt);
-    const expires = Date.parse(payload.expiresAt);
-    if (expires <= created)
-        throw new Error("Intelligence feed expiry must follow creation");
-    if (created > now.getTime() + 5 * 60 * 1000)
-        throw new Error("Intelligence feed is dated in the future");
-    if (now.getTime() - created > maxAgeMs || expires <= now.getTime())
-        throw new Error("Intelligence feed is stale");
-}
-export function createSignedIntelligenceFeed(payload, privateKeyPem) {
-    const validated = intelligenceFeedPayloadSchema.parse(payload);
-    return signPayload(validated, privateKeyPem, validated.createdAt);
-}
-/** Preview is read-only: it verifies but never installs, promotes, executes, or changes trust. */
-export async function previewIntelligenceFeed(options) {
-    const statePath = resolve(options.statePath ?? defaultStatePath());
-    const cachePath = resolve(options.cachePath ?? defaultCachePath());
-    const [rawEnvelope, publicKeyPem, state] = await Promise.all([
-        readSource(options.source, options.fetcher),
-        readBounded(resolve(options.publicKeyPath), MAX_KEY_BYTES, "Intelligence public key"),
-        readTrustState(statePath),
-    ]);
-    const envelope = envelopeSchema.parse(rawEnvelope);
-    const verification = verifyEnvelope(envelope, publicKeyPem);
-    if (!verification.valid)
-        throw new Error("Intelligence feed signature is invalid");
-    if (envelope.createdAt !== envelope.payload.createdAt)
-        throw new Error("Intelligence envelope and payload creation times differ");
-    validateFreshness(envelope.payload, options.now ?? new Date(), options.maxAgeMs ?? DEFAULT_MAX_AGE_MS);
-    const keyRotation = Boolean(state && verification.fingerprint !== state.fingerprint);
-    if (keyRotation &&
-        verification.fingerprint !== state?.pendingRotationFingerprint)
-        throw new Error("Intelligence signer does not match the pinned or explicitly authorized next key");
-    if (state && envelope.payload.sequence <= state.highWaterSequence)
-        throw new Error("Refusing replayed or downgraded intelligence sequence");
-    if (state &&
-        Date.parse(envelope.payload.createdAt) <=
-            Date.parse(state.highWaterCreatedAt))
-        throw new Error("Refusing intelligence older than the trust high-water mark");
-    return {
-        source: options.source,
-        status: "current",
-        fingerprint: verification.fingerprint,
-        payload: envelope.payload,
-        envelope,
-        envelopeSha256: envelopeHash(envelope),
-        firstPin: !state,
-        keyRotation,
-        cachePath,
-        statePath,
-        publicKeyPem,
-        summary: {
-            discoveryObservations: envelope.payload.discoveryObservations.length,
-            compatibilityNotices: envelope.payload.compatibilityNotices.length,
-            candidateSummaries: envelope.payload.candidateSummaries.length,
-            benchmarkChanges: envelope.payload.benchmarkChanges.length,
-            hasCatalogPointer: Boolean(envelope.payload.catalogRelease),
-        },
-        boundary: "read-only-intelligence-no-install-promotion-or-execution",
-    };
-}
-/** Apply only caches verified public intelligence and advances replay protection. */
-export async function applyIntelligenceFeed(preview) {
-    return withFileLock(feedLockPath(preview.statePath), async () => {
-        const verification = verifyEnvelope(preview.envelope, preview.publicKeyPem);
-        if (!verification.valid || verification.fingerprint !== preview.fingerprint)
-            throw new Error("Intelligence preview signature no longer verifies");
-        const state = await readTrustState(preview.statePath);
-        if (state && preview.payload.sequence <= state.highWaterSequence)
-            throw new Error("Refusing replayed or downgraded intelligence sequence");
-        const allowed = !state ||
-            verification.fingerprint === state.fingerprint ||
-            verification.fingerprint === state.pendingRotationFingerprint;
-        if (!allowed)
-            throw new Error("Intelligence signer is not pinned or authorized for rotation");
-        const next = {
-            schemaVersion: 1,
-            fingerprint: verification.fingerprint,
-            highWaterSequence: preview.payload.sequence,
-            highWaterCreatedAt: preview.payload.createdAt,
-        };
-        await writeFileAtomically(preview.cachePath, `${JSON.stringify(preview.envelope, null, 2)}\n`);
-        await writeFileAtomically(preview.statePath, `${JSON.stringify(next, null, 2)}\n`);
-        return { cachePath: preview.cachePath, sequence: preview.payload.sequence };
-    });
-}
-/** Explicitly authorize one new key; no feed can rotate trust merely by claiming it. */
-export async function authorizeIntelligenceFeedKeyRotation(options) {
-    const statePath = resolve(options.statePath ?? defaultStatePath());
-    return withFileLock(feedLockPath(statePath), async () => {
-        const [state, currentPem, nextPem] = await Promise.all([
-            readTrustState(statePath),
-            readBounded(resolve(options.currentPublicKeyPath), MAX_KEY_BYTES, "Current public key"),
-            readBounded(resolve(options.nextPublicKeyPath), MAX_KEY_BYTES, "Next public key"),
-        ]);
-        if (!state)
-            throw new Error("Cannot rotate an intelligence key before first pin");
-        if (publicKeyFingerprint(currentPem) !== state.fingerprint)
-            throw new Error("Current rotation key does not match pinned trust");
-        const pendingRotationFingerprint = publicKeyFingerprint(nextPem);
-        if (pendingRotationFingerprint === state.fingerprint)
-            throw new Error("Next intelligence key must differ from the pinned key");
-        await writeFileAtomically(statePath, `${JSON.stringify({ ...state, pendingRotationFingerprint }, null, 2)}\n`);
-        return pendingRotationFingerprint;
-    });
-}
-/** Explicit compromise recovery removes only feed trust/cache; catalog trust is separate. */
-export async function resetIntelligenceFeedTrust(options) {
-    if (!options.acknowledgeCompromiseRecovery)
-        throw new Error("Compromise recovery requires explicit acknowledgement");
-    await Promise.all([
-        rm(resolve(options.statePath ?? defaultStatePath()), { force: true }),
-        rm(resolve(options.cachePath ?? defaultCachePath()), { force: true }),
-    ]);
-}
-/** On refresh failure, return only a previously verified bounded cache and mark it stale. */
-export async function loadIntelligenceFeed(options) {
-    try {
-        const preview = await previewIntelligenceFeed(options);
-        return {
-            status: "current",
-            payload: preview.payload,
-            fingerprint: preview.fingerprint,
-            stale: false,
-            boundary: preview.boundary,
-        };
-    }
-    catch (error) {
-        const statePath = resolve(options.statePath ?? defaultStatePath());
-        const cachePath = resolve(options.cachePath ?? defaultCachePath());
-        const [state, publicKeyPem, cached] = await Promise.all([
-            readTrustState(statePath),
-            readBounded(resolve(options.publicKeyPath), MAX_KEY_BYTES, "Intelligence public key"),
-            readBounded(cachePath, MAX_FEED_BYTES, "Cached intelligence feed"),
-        ]);
-        if (!state)
-            throw error;
-        const envelope = envelopeSchema.parse(JSON.parse(cached));
-        const verification = verifyEnvelope(envelope, publicKeyPem);
-        if (!verification.valid || verification.fingerprint !== state.fingerprint)
-            throw new Error("Cached intelligence feed no longer verifies against pinned trust");
-        if ((options.now ?? new Date()).getTime() -
-            Date.parse(envelope.payload.createdAt) >
-            (options.maxStaleMs ?? DEFAULT_MAX_STALE_MS))
-            throw new Error("Cached intelligence feed exceeds the stale fallback limit");
-        return {
-            status: "stale-cache",
-            payload: envelope.payload,
-            fingerprint: verification.fingerprint,
-            stale: true,
-            issue: error instanceof Error ? error.message : String(error),
-            boundary: "read-only-intelligence-no-install-promotion-or-execution",
-        };
-    }
-}
-/** Read the last explicitly applied feed and verify it against pinned local trust. */
-export async function readCachedIntelligenceFeed(options) {
-    const statePath = resolve(options.statePath ?? defaultStatePath());
-    const cachePath = resolve(options.cachePath ?? defaultCachePath());
-    const [state, publicKeyPem, cached] = await Promise.all([
-        readTrustState(statePath),
-        readBounded(resolve(options.publicKeyPath), MAX_KEY_BYTES, "Intelligence public key"),
-        readBounded(cachePath, MAX_FEED_BYTES, "Cached intelligence feed"),
-    ]);
-    if (!state)
-        throw new Error("No pinned intelligence feed is available");
-    const envelope = envelopeSchema.parse(JSON.parse(cached));
-    const verification = verifyEnvelope(envelope, publicKeyPem);
-    if (!verification.valid || verification.fingerprint !== state.fingerprint)
-        throw new Error("Cached intelligence feed does not verify against pinned trust");
-    if (envelope.payload.sequence !== state.highWaterSequence)
-        throw new Error("Cached intelligence sequence does not match trust state");
-    const stale = Date.parse(envelope.payload.expiresAt) <=
-        (options.now ?? new Date()).getTime();
-    return {
-        status: stale ? "stale-cache" : "current",
-        payload: envelope.payload,
-        fingerprint: verification.fingerprint,
-        stale,
-        ...(stale ? { issue: "Cached intelligence feed is expired" } : {}),
-        boundary: "read-only-intelligence-no-install-promotion-or-execution",
-    };
-}
-export function intelligenceFeedPublicFields() {
-    return Object.keys(intelligenceFeedPayloadSchema.shape).sort();
-}
-export function validateIntelligencePublicBoundary(value) {
-    const serialized = JSON.stringify(value).toLowerCase();
-    for (const forbidden of [
-        "prompt",
-        "projectpath",
-        "projectsource",
-        "private repository",
-        "credentialvalue",
-        "apikeyvalue",
-    ])
-        if (serialized.includes(forbidden))
-            throw new Error(`Public intelligence feed contains forbidden private field marker: ${forbidden}`);
-    return intelligenceFeedPayloadSchema.parse(value);
-}
-export function intelligencePublicKeySpkiSha256(publicKeyPem) {
-    return createHash("sha256")
-        .update(createPublicKey(publicKeyPem).export({ type: "spki", format: "der" }))
-        .digest("hex");
-}

package/dist/src/core/registry-api.js

@@ -1,97 +0,0 @@
-import { createServer, } from "node:http";
-import { randomBytes, timingSafeEqual } from "node:crypto";
-import { mkdtemp, rm } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { createRegistryBundle, importRegistryBundle, publishLocalPackage, resolveRegistryPackage, } from "./registry.js";
-function send(response, status, value) {
-    const body = JSON.stringify(value);
-    response.writeHead(status, {
-        "content-type": "application/json; charset=utf-8",
-        "content-length": Buffer.byteLength(body),
-        "cache-control": "no-store",
-        "x-content-type-options": "nosniff",
-    });
-    response.end(body);
-}
-function tokenMatches(request, token) {
-    const header = request.headers.authorization;
-    if (!header?.startsWith("Bearer "))
-        return false;
-    const provided = Buffer.from(header.slice(7));
-    const expected = Buffer.from(token);
-    return (provided.length === expected.length && timingSafeEqual(provided, expected));
-}
-async function requestJson(request) {
-    const chunks = [];
-    let size = 0;
-    for await (const chunk of request) {
-        const value = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
-        size += value.length;
-        if (size > 35_000_000)
-            throw new Error("Request exceeds registry limit");
-        chunks.push(value);
-    }
-    return JSON.parse(Buffer.concat(chunks).toString("utf8"));
-}
-export async function startRegistryServer(options = {}) {
-    const host = options.host ?? "127.0.0.1";
-    const port = options.port ?? 0;
-    const token = options.token ?? randomBytes(32).toString("hex");
-    if (host !== "127.0.0.1" && host !== "::1" && !options.token)
-        throw new Error("A publish token is required when binding beyond loopback");
-    const server = createServer(async (request, response) => {
-        try {
-            const url = new URL(request.url ?? "/", "http://registry.local");
-            const match = url.pathname.match(/^\/v1\/packages\/([a-z0-9][a-z0-9._-]*)\/([^/]+)$/);
-            if (request.method === "GET" && match) {
-                const resolved = await resolveRegistryPackage(match[1], decodeURIComponent(match[2]));
-                send(response, 200, await createRegistryBundle(resolved.path));
-                return;
-            }
-            if (request.method === "POST" && url.pathname === "/v1/packages") {
-                if (!tokenMatches(request, token)) {
-                    request.resume();
-                    await new Promise((resolve) => request.once("end", resolve));
-                    send(response, 401, { error: "Invalid registry token" });
-                    return;
-                }
-                const temporary = await mkdtemp(join(tmpdir(), "loadout-registry-upload-"));
-                try {
-                    const packed = await importRegistryBundle(await requestJson(request), join(temporary, "package"));
-                    const published = await publishLocalPackage(packed.root, {
-                        approveRisk: request.headers["x-loadout-approve-risk"] === "true",
-                    });
-                    send(response, 201, {
-                        name: published.descriptor.name,
-                        version: published.descriptor.version,
-                        digest: published.digest,
-                    });
-                }
-                finally {
-                    await rm(temporary, { recursive: true, force: true });
-                }
-                return;
-            }
-            send(response, 404, { error: "Not found" });
-        }
-        catch (error) {
-            send(response, 400, {
-                error: error instanceof Error ? error.message : String(error),
-            });
-        }
-    });
-    await new Promise((resolve, reject) => {
-        server.once("error", reject);
-        server.listen(port, host, resolve);
-    });
-    const address = server.address();
-    if (!address || typeof address === "string")
-        throw new Error("Could not determine registry address");
-    return {
-        server,
-        host,
-        port: address.port,
-        close: () => new Promise((resolve, reject) => server.close((error) => (error ? reject(error) : resolve()))),
-    };
-}

package/dist/src/core/release-claims.js

@@ -1,175 +0,0 @@
-import { existsSync } from "node:fs";
-import { access } from "node:fs/promises";
-import { dirname, join, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-export const RELEASE_CLAIMS = [
-    {
-        id: "catalog-immutable-attribution",
-        status: "supported",
-        statement: "The bundled catalog records immutable Git commits and upstream credit links.",
-        boundary: "A pin proves source identity; it does not prove safety, license permission, usefulness, or future compatibility.",
-        evidence: {
-            files: [
-                "catalog/packages.json",
-                "docs/CATALOG.md",
-                "scripts/check-catalog-attribution.mjs",
-            ],
-            commands: ["npm run check:evidence"],
-            sources: [],
-        },
-    },
-    {
-        id: "stable-bounded-profile",
-        status: "bounded",
-        statement: "Stable selects 30 skill directories from four pinned SPDX-identified sources.",
-        boundary: "Recommended means the bounded Loadout policy default, not universal task superiority.",
-        evidence: {
-            files: [
-                "src/core/profiles.ts",
-                "tests/profiles.test.ts",
-                "tests/catalog-install.test.ts",
-            ],
-            commands: ["npm test -- --run"],
-            sources: [],
-        },
-    },
-    {
-        id: "transactional-managed-mutations",
-        status: "bounded",
-        statement: "Managed installation batches use snapshot-backed filesystem transactions and rollback.",
-        boundary: "This is not database-grade power-loss durability and never authorizes mutation of unmanaged content.",
-        evidence: {
-            files: [
-                "src/core/transaction.ts",
-                "src/core/snapshot.ts",
-                "tests/transaction.test.ts",
-                "tests/snapshot.test.ts",
-                "tests/native-filesystem-smoke.test.ts",
-            ],
-            commands: ["npm run test:e2e:cli"],
-            sources: [],
-        },
-    },
-    {
-        id: "daily-read-only-autopilot",
-        status: "bounded",
-        statement: "Autopilot schedules read-only discovery and update checks on supported native schedulers.",
-        boundary: "Scheduled jobs do not install, promote, execute, or update candidate content.",
-        evidence: {
-            files: ["src/core/scheduler.ts", "tests/scheduler.test.ts"],
-            commands: ["npm test -- --run tests/scheduler.test.ts"],
-            sources: [],
-        },
-    },
-    {
-        id: "benchmark-performance-evidence",
-        status: "not-established",
-        statement: "Loadout has a deterministic evaluation protocol and model-free campaign planner.",
-        boundary: "No bundled source is benchmarked until isolated real trials, signed evidence, and human promotion approval exist.",
-        evidence: {
-            files: [
-                "docs/EVALUATION_PROTOCOL_V1.md",
-                "src/core/benchmark-campaign.ts",
-                "tests/benchmark-campaign.test.ts",
-                "tests/benchmark-cli.test.ts",
-            ],
-            commands: [
-                "npm test -- --run tests/benchmark-campaign.test.ts tests/benchmark-cli.test.ts",
-            ],
-            sources: [],
-        },
-    },
-    {
-        id: "privacy-safe-sharing",
-        status: "bounded",
-        statement: "Cards, reports, comparisons, and badges expose aggregate local evidence without project content or credentials.",
-        boundary: "Users must review generated artifacts before sharing; scores do not establish universal quality.",
-        evidence: {
-            files: [
-                "src/core/share-report.ts",
-                "src/core/loadout-card.ts",
-                "src/core/loadout-badge.ts",
-                "tests/share-report.test.ts",
-                "tests/loadout-card.test.ts",
-                "tests/loadout-badge.test.ts",
-            ],
-            commands: ["npm test -- --run"],
-            sources: [],
-        },
-    },
-];
-export function releaseEvidenceRoot() {
-    const moduleDirectory = dirname(fileURLToPath(import.meta.url));
-    const candidates = [
-        join(moduleDirectory, "..", ".."),
-        join(moduleDirectory, "..", "..", ".."),
-        process.cwd(),
-    ];
-    return (candidates.find((candidate) => existsSync(join(candidate, "README.md"))) ??
-        candidates[0]);
-}
-const FORBIDDEN_PUBLIC_CLAIMS = [
-    /\buniversally best\b/i,
-    /\bguaranteed safe\b/i,
-    /\bzero[- ]risk\b/i,
-    /\bperfect(?:ly)? compatible\b/i,
-    /\bproves? task improvement\b/i,
-    /\bevery (?:skill|repository) is (?:safe|reviewed|benchmarked)\b/i,
-];
-function portableEvidencePath(path) {
-    return (path.length > 0 &&
-        !path.startsWith("/") &&
-        !path.includes("\\") &&
-        !path.split("/").includes(".."));
-}
-export async function auditReleaseClaims(options) {
-    const claims = [...(options.claims ?? RELEASE_CLAIMS)];
-    const blockers = [];
-    const ids = new Set();
-    for (const claim of claims) {
-        if (ids.has(claim.id))
-            blockers.push(`duplicate claim id: ${claim.id}`);
-        ids.add(claim.id);
-        if (!claim.statement.trim() || !claim.boundary.trim())
-            blockers.push(`claim ${claim.id} lacks statement or boundary`);
-        if (!claim.evidence.files.length)
-            blockers.push(`claim ${claim.id} has no evidence files`);
-        for (const path of claim.evidence.files) {
-            if (!portableEvidencePath(path)) {
-                blockers.push(`claim ${claim.id} has unsafe evidence path: ${path}`);
-                continue;
-            }
-            if (options.verifyEvidenceFiles !== false)
-                try {
-                    await access(resolve(options.root, path));
-                }
-                catch {
-                    blockers.push(`claim ${claim.id} evidence is missing: ${path}`);
-                }
-        }
-    }
-    for (const pattern of FORBIDDEN_PUBLIC_CLAIMS)
-        if (pattern.test(options.readme))
-            blockers.push(`README contains forbidden release claim: ${pattern}`);
-    const catalogPhrase = `${options.catalogCount} credited public repositories`;
-    if (!options.readme.includes(catalogPhrase))
-        blockers.push(`README catalog count is stale or missing; expected '${catalogPhrase}'`);
-    if (!/does not claim there is one universally [“"]best[”"] configuration/i.test(options.readme))
-        blockers.push("README lacks the universal-best claim boundary");
-    if (!/no bundled source is called benchmarked/i.test(options.readme))
-        blockers.push("README lacks the no-bundled-benchmark-evidence boundary");
-    return {
-        schemaVersion: 1,
-        policyVersion: "p16-17-v1",
-        claims,
-        releaseBlocked: blockers.length > 0,
-        blockers,
-    };
-}
-export function formatReleaseEvidenceIndex(index) {
-    return [
-        `Release claim gate: ${index.releaseBlocked ? "BLOCKED" : "PASS"} (${index.claims.length} claim(s))`,
-        ...index.claims.map((claim) => `${claim.status === "supported" ? "✓" : claim.status === "bounded" ? "△" : "○"} ${claim.id} — ${claim.statement}\n  Boundary: ${claim.boundary}`),
-        ...index.blockers.map((blocker) => `BLOCKER: ${blocker}`),
-    ].join("\n");
-}