@sema-agent/core/dist/prompt-assembly/epoch.js

Stateless, task-oriented AI agent core

import { createHash } from "node:crypto";
export function canonical(node) {
    if (Array.isArray(node))
        return `[${node.map(canonical).join(",")}]`;
    if (node === null || typeof node !== "object")
        return JSON.stringify(node);
    const keys = Object.keys(node).sort();
    return `{${keys.map((k) => `${JSON.stringify(k)}:${canonical(node[k])}`).join(",")}}`;
}
const PROBE_FACTS_OFF = {
    policyEnabled: false,
    hooksEnabled: false,
    isolationEnabled: false,
    withinTaskCompactionEnabled: false,
    supervisorEnabled: false,
    orchestrationEnabled: false,
    awarenessEnabled: false,
    goalEnabled: false,
    worktreeIsolated: false,
    teammateEnabled: false,
    orchestrationDeferred: false,
    isSubagent: false,
    promptProfile: "simple",
    fableMitigations: false,
    readFaceOpen: false,
    writeFaceOpen: false,
    reminderMark: undefined,
};
const PROBE_FACTS_ON = {
    policyEnabled: true,
    hooksEnabled: true,
    isolationEnabled: true,
    withinTaskCompactionEnabled: true,
    supervisorEnabled: true,
    orchestrationEnabled: true,
    awarenessEnabled: true,
    goalEnabled: true,
    worktreeIsolated: true,
    teammateEnabled: true,
    orchestrationDeferred: true,
    isSubagent: true,
    promptProfile: "classic",
    fableMitigations: true,
    readFaceOpen: true,
    writeFaceOpen: true,
    reminderMark: "PROBE-FIXED-MARK-AXIS0",
};
const PROBE_VECTORS = [
    PROBE_FACTS_OFF,
    PROBE_FACTS_ON,
    ...Object.keys(PROBE_FACTS_OFF).map((k) => ({ ...PROBE_FACTS_OFF, [k]: PROBE_FACTS_ON[k] })),
];
const PROBE_INPUTS_BASE = {
    roleBase: "\u0000probe-role\u0000",
    roleAppend: "\u0000probe-append\u0000",
    mcpInstructionsBlock: "\u0000probe-mcp\u0000",
    environmentBlock: "\u0000probe-env@2\u0000",
    memoryBlock: "\u0000probe-memory\u0000",
    modelGuidance: "\u0000probe-guidance\u0000",
};
export function computeBundledArtifactDigest(pack, declared) {
    const probeSection = (s) => PROBE_VECTORS.map((facts) => {
        const inputs = { ...PROBE_INPUTS_BASE, facts };
        try {
            if (s.admit && !s.admit(inputs))
                return null;
            return s.content(inputs) ?? null;
        }
        catch {
            return " probe-threw ";
        }
    });
    const payload = {
        packId: pack.packId,
        assemblyApi: pack.assemblyApi,
        ...(declared !== undefined && declared.length > 0
            ? { declaredSections: declared.map((d) => ({ id: d.id, slot: d.slot, chars: d.chars, ...(d.contentHash !== undefined ? { contentHash: d.contentHash } : {}) })) }
            : {}),
        sections: [...pack.sections].sort((a, b) => a.rank - b.rank).map((s) => ({
            id: s.id,
            slot: s.slot,
            rank: s.rank,
            owner: s.owner,
            trust: s.trust,
            mutability: s.mutability,
            cadence: s.cadence,
            cacheClass: s.cacheClass,
            carrier: s.carrier,
            legacyBlockId: s.blockId,
            probes: probeSection(s),
        })),
    };
    return `sha256:${createHash("sha256").update(canonical(payload)).digest("hex")}`;
}
export function mintSessionStartEpoch(pack, declared) {
    return {
        epoch: 1,
        artifactDigest: computeBundledArtifactDigest(pack, declared),
        packId: pack.packId,
        assemblyApi: pack.assemblyApi,
        activatedBy: "session_start",
    };
}
export function selectCompactionEpoch(current, pack, declared, centerAdoption) {
    const digest = computeBundledArtifactDigest(pack, declared);
    if (centerAdoption === undefined && current && current.artifactDigest === digest) {
        return { ...current, activatedBy: "compaction" };
    }
    return {
        epoch: (current?.epoch ?? 0) + 1,
        artifactDigest: digest,
        packId: pack.packId,
        assemblyApi: pack.assemblyApi,
        activatedBy: "compaction",
        ...(centerAdoption !== undefined
            ? "clear" in centerAdoption
                ? {}
                : {
                    centerArtifactDigest: centerAdoption.centerArtifactDigest,
                    ...(centerAdoption.sourceRevision !== undefined ? { sourceRevision: centerAdoption.sourceRevision } : {}),
                }
            : current?.centerArtifactDigest !== undefined
                ? {
                    centerArtifactDigest: current.centerArtifactDigest,
                    ...(current.sourceRevision !== undefined ? { sourceRevision: current.sourceRevision } : {}),
                }
                : {}),
    };
}
export function resolveEpochAgainstBundled(pinned, pack, declared) {
    const digest = computeBundledArtifactDigest(pack, declared);
    if (pinned && pinned.artifactDigest === digest && pinned.packId === pack.packId && pinned.assemblyApi === pack.assemblyApi) {
        return { descriptor: pinned, migrated: false };
    }
    return {
        descriptor: {
            epoch: (pinned?.epoch ?? 0) + 1,
            artifactDigest: digest,
            packId: pack.packId,
            assemblyApi: pack.assemblyApi,
            activatedBy: "legacy_migration",
        },
        migrated: true,
    };
}
export function normalizePromptEpoch(raw) {
    if (raw === null || typeof raw !== "object")
        return undefined;
    const r = raw;
    if (typeof r.epoch !== "number" || !Number.isInteger(r.epoch) || r.epoch < 1 || r.epoch > 1_000_000_000)
        return undefined;
    if (typeof r.artifactDigest !== "string" || !/^sha256:[0-9a-f]{64}$/.test(r.artifactDigest))
        return undefined;
    if (typeof r.packId !== "string" || !r.packId.trim() || r.packId.length > 200)
        return undefined;
    if (r.assemblyApi !== 1)
        return undefined;
    if (r.activatedBy !== "session_start" && r.activatedBy !== "compaction" && r.activatedBy !== "legacy_migration")
        return undefined;
    const centerArtifactDigest = typeof r.centerArtifactDigest === "string" && /^sha256:[0-9a-f]{64}$/.test(r.centerArtifactDigest) ? r.centerArtifactDigest : undefined;
    const sourceRevision = typeof r.sourceRevision === "string" && r.sourceRevision.length > 0 && r.sourceRevision.length <= 500 ? r.sourceRevision : undefined;
    return {
        epoch: r.epoch,
        artifactDigest: r.artifactDigest,
        packId: r.packId,
        assemblyApi: 1,
        activatedBy: r.activatedBy,
        ...(centerArtifactDigest !== undefined ? { centerArtifactDigest } : {}),
        ...(centerArtifactDigest !== undefined && sourceRevision !== undefined ? { sourceRevision } : {}),
    };
}