agentera 3.0.0-dev.5 → 3.0.0-dev.51

package/dist/hooks/validateArtifact/violations.js

@@ -0,0 +1,107 @@
+/**
+ * YAML-side violation orchestrators.
+ *
+ * `validateYamlContent` is the single entry point: parse, walk the
+ * schema singleton groups, run sequence validation, apply artifact-
+ * specific rules (plan, decisions), and finally run BUDGET and
+ * VALIDATION_RULES checks. Lower-level helpers live in `schema.ts`.
+ */
+import path from "node:path";
+import { parseYaml } from "../../core/yaml.js";
+import { resolveSourceRoot } from "../../core/sourceRoot.js";
+import { loadYamlMapping } from "../../core/yaml.js";
+import { expectedSequenceOrder, isMapping, sequenceInOrder, validationRuleSeverity, validateDecisionAlternatives, validateDecisionSatisfaction, validateFullPlanContract, validatePlanDependencies, validatePlanKnownFields, validateSequences, validateSingletonGroup, collectSingletonGroups, wordCount, } from "./schema.js";
+function schemasDirDefault() {
+    return path.join(resolveSourceRoot(), "skills", "agentera", "schemas", "artifacts");
+}
+export function validateYamlContent(content, schema, name) {
+    const violations = [];
+    let data;
+    try {
+        data = parseYaml(content);
+    }
+    catch (exc) {
+        return [`${name}: invalid YAML: ${exc.message}`];
+    }
+    if (!isMapping(data)) {
+        return [`${name}: root must be a mapping`];
+    }
+    for (const [group, groupLower, fields] of collectSingletonGroups(schema)) {
+        let scope;
+        if (groupLower in data && isMapping(data[groupLower])) {
+            scope = data[groupLower];
+        }
+        else if (fields.some((f) => f in data)) {
+            scope = data;
+        }
+        else {
+            continue;
+        }
+        validateSingletonGroup(violations, name, schema, group, scope, groupLower);
+    }
+    if (name === "plan") {
+        validatePlanKnownFields(data, schema, violations);
+        validateFullPlanContract(data, violations);
+        validatePlanDependencies(data, violations);
+    }
+    validateSequences(data, schema, name, violations);
+    if (name === "decisions") {
+        violations.push(...validateDecisionAlternatives(data, name));
+        violations.push(...validateDecisionSatisfaction(data, name));
+    }
+    const wordBudgetSeverity = validationRuleSeverity(schema, "word_budget");
+    for (const be of Object.values(schema.BUDGET ?? {})) {
+        if (!isMapping(be))
+            continue;
+        const mw = be.max_words;
+        const scope = be.scope ?? "";
+        if (mw && String(scope).includes("full_file") && wordBudgetSeverity === "error") {
+            const wc = wordCount(content);
+            if (wc > Number(mw))
+                violations.push(`${name}: word count (${wc}) exceeds budget (${mw})`);
+        }
+    }
+    for (const groupKey of ["VALIDATION", "VALIDATION_RULES"]) {
+        for (const ve of Object.values(schema[groupKey] ?? {})) {
+            if (!isMapping(ve))
+                continue;
+            const rule = String(ve.rule ?? "");
+            if (ve.severity !== "error")
+                continue;
+            if (rule.includes("unique") && rule.includes("number")) {
+                for (const [key, val] of Object.entries(data)) {
+                    if (Array.isArray(val)) {
+                        const nums = val
+                            .filter((e) => isMapping(e) && "number" in e)
+                            .map((e) => e.number);
+                        if (nums.length > 0) {
+                            if (nums.length !== new Set(nums).size) {
+                                violations.push(`${name}: duplicate numbers in '${key}'`);
+                            }
+                            const direction = expectedSequenceOrder(name, key);
+                            if (!sequenceInOrder(nums, direction)) {
+                                violations.push(`${name}: '${key}' not in ${direction} order`);
+                            }
+                        }
+                    }
+                }
+            }
+            else if (rule === "closure_consistency") {
+                const header = isMapping(data.header) ? data.header : {};
+                const status = data.status ?? header.status;
+                if (typeof status === "string" && status === "closed") {
+                    for (const field of ["closed_at", "final_value", "target_ref", "reason"]) {
+                        let val = data[field];
+                        if (val === null || val === undefined)
+                            val = header[field];
+                        if (val === null || val === undefined || (typeof val === "string" && !val.trim())) {
+                            violations.push(`${name}: closure field '${field}' is required when status is 'closed'`);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return violations;
+}
+export { loadYamlMapping, schemasDirDefault };

package/dist/migrate/v2HandoffManifest.js

@@ -0,0 +1,452 @@
+import fs from "node:fs";
+import path from "node:path";
+import { isLifecycleOwnershipStateDirectory } from "../runtime/lifecycleOwnershipJournal.js";
+import { AGENTERA_PROFILE_DIR_ENV, PROFILERA_PROFILE_DIR_ENV, resolveProfileDirOverride, } from "../core/envPaths.js";
+import { expanduser, isFile, pathExists, resolvePath } from "../core/paths.js";
+import { opencodeConfigDir } from "../setup/opencode.js";
+import { doctorRoots, loadSuiteVersion } from "../upgrade/appModel.js";
+import { MANAGED_APP_CONTENT_ROOT_ENTRIES } from "../upgrade/appContentRefresh.js";
+import { AGENTERA_USER_STATE_NAMES, ROOT_USER_STATE_DIR_NAMES, ROOT_USER_STATE_FILE_NAMES, } from "../upgrade/doctor.js";
+export const V2_HANDOFF_MANIFEST_FILENAME = "v3-handoff.json";
+export const V2_HANDOFF_SCHEMA_VERSION = "agentera.v3_handoff_manifest.v1";
+export const READER_PREFLIGHT_BUDGET_MS = 100;
+export const USER_DATA_CATALOG_DIRS = [
+    "benchmarks",
+    "intermediate",
+    "sessions",
+    "history",
+    "corpus",
+];
+export const PROFILE_FILE_MEMBERS = ["PROFILE.md", "USAGE.md"];
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function asNonEmptyString(value, field) {
+    if (typeof value !== "string" || !value.trim()) {
+        throw new Error(`${field} must be a non-empty string`);
+    }
+    return value.trim();
+}
+function parseDirectoryEntry(raw) {
+    const id = asNonEmptyString(raw.id, "user_data_inventory.id");
+    if (!USER_DATA_CATALOG_DIRS.includes(id)) {
+        throw new Error(`user_data_inventory id ${id} is not in the catalog`);
+    }
+    if (raw.kind !== "directory") {
+        throw new Error(`user_data_inventory entry ${id} must have kind=directory`);
+    }
+    if (typeof raw.exists !== "boolean") {
+        throw new Error(`user_data_inventory entry ${id} must have boolean exists`);
+    }
+    return {
+        id: id,
+        relative_path: asNonEmptyString(raw.relative_path, `user_data_inventory.${id}.relative_path`),
+        kind: "directory",
+        exists: raw.exists,
+    };
+}
+function parseProfileFilesEntry(raw) {
+    if (raw.id !== "profile_files") {
+        throw new Error("profile_files entry must have id=profile_files");
+    }
+    if (raw.kind !== "profile_files") {
+        throw new Error("profile_files entry must have kind=profile_files");
+    }
+    if (!Array.isArray(raw.members)) {
+        throw new Error("profile_files entry must have members array");
+    }
+    const members = raw.members.map((member, index) => {
+        if (!isRecord(member)) {
+            throw new Error(`profile_files.members[${index}] must be an object`);
+        }
+        if (member.kind !== "file") {
+            throw new Error(`profile_files.members[${index}] must have kind=file`);
+        }
+        if (typeof member.exists !== "boolean") {
+            throw new Error(`profile_files.members[${index}] must have boolean exists`);
+        }
+        return {
+            relative_path: asNonEmptyString(member.relative_path, `profile_files.members[${index}].relative_path`),
+            kind: "file",
+            exists: member.exists,
+        };
+    });
+    return { id: "profile_files", kind: "profile_files", members };
+}
+function parseUserDataInventory(raw) {
+    if (!Array.isArray(raw) || raw.length < 6) {
+        throw new Error("user_data_inventory must be an array with at least six entries");
+    }
+    const entries = raw.map((item, index) => {
+        if (!isRecord(item)) {
+            throw new Error(`user_data_inventory[${index}] must be an object`);
+        }
+        if (item.kind === "profile_files") {
+            return parseProfileFilesEntry(item);
+        }
+        return parseDirectoryEntry(item);
+    });
+    const ids = new Set(entries.map((entry) => entry.id));
+    for (const id of [...USER_DATA_CATALOG_DIRS, "profile_files"]) {
+        if (!ids.has(id)) {
+            throw new Error(`user_data_inventory missing catalog id ${id}`);
+        }
+    }
+    return entries;
+}
+export function parseV2HandoffManifest(raw) {
+    if (!isRecord(raw)) {
+        throw new Error("manifest must be a JSON object");
+    }
+    const schemaVersion = asNonEmptyString(raw.schema_version, "schema_version");
+    if (schemaVersion !== V2_HANDOFF_SCHEMA_VERSION) {
+        throw new Error(`schema_version must be ${V2_HANDOFF_SCHEMA_VERSION}`);
+    }
+    const writtenAt = asNonEmptyString(raw.written_at, "written_at");
+    if (Number.isNaN(Date.parse(writtenAt))) {
+        throw new Error("written_at must be an ISO-8601 UTC timestamp");
+    }
+    if (!Array.isArray(raw.runtime_adapters)) {
+        throw new Error("runtime_adapters must be an array");
+    }
+    const runtimeAdapters = raw.runtime_adapters.map((adapter, index) => asNonEmptyString(adapter, `runtime_adapters[${index}]`));
+    return {
+        schema_version: V2_HANDOFF_SCHEMA_VERSION,
+        written_at: writtenAt,
+        installed_v2_version: asNonEmptyString(raw.installed_v2_version, "installed_v2_version"),
+        app_home_path: asNonEmptyString(raw.app_home_path, "app_home_path"),
+        user_data_inventory: parseUserDataInventory(raw.user_data_inventory),
+        runtime_adapters: runtimeAdapters,
+    };
+}
+export function v2HandoffManifestPath(appHome) {
+    return path.join(resolvePath(appHome), V2_HANDOFF_MANIFEST_FILENAME);
+}
+export function readV2HandoffManifestFile(appHome) {
+    const manifestPath = v2HandoffManifestPath(appHome);
+    if (!isFile(manifestPath)) {
+        return null;
+    }
+    const started = performance.now();
+    let parsed;
+    try {
+        parsed = JSON.parse(fs.readFileSync(manifestPath, "utf8"));
+    }
+    catch (exc) {
+        throw new Error(`failed to read ${V2_HANDOFF_MANIFEST_FILENAME}: ${exc.message}`);
+    }
+    const manifest = parseV2HandoffManifest(parsed);
+    const elapsedMs = performance.now() - started;
+    return { manifest, elapsedMs };
+}
+function agenteraUserStateDirIsRecognized(dir) {
+    if (!pathExists(dir) || !fs.statSync(dir).isDirectory()) {
+        return false;
+    }
+    for (const entry of fs.readdirSync(dir)) {
+        const full = path.join(dir, entry);
+        const st = fs.statSync(full);
+        if (AGENTERA_USER_STATE_NAMES.has(entry) && st.isFile()) {
+            continue;
+        }
+        if ((entry === "optimize" || entry === "optimera") && st.isDirectory()) {
+            // "optimera" is the v2 stable legacy objective dir name; keep it
+            // recognized so v2->v3 migration preserves legacy objective state.
+            continue;
+        }
+        if (entry === "runtime-lifecycle" && isLifecycleOwnershipStateDirectory(full)) {
+            continue;
+        }
+        return false;
+    }
+    return true;
+}
+function isPreservedUserStateEntry(appHome, entry) {
+    const full = path.join(appHome, entry);
+    if (!pathExists(full)) {
+        return false;
+    }
+    const st = fs.statSync(full);
+    if (ROOT_USER_STATE_FILE_NAMES.has(entry) && st.isFile()) {
+        return true;
+    }
+    if (ROOT_USER_STATE_DIR_NAMES.has(entry) && st.isDirectory()) {
+        return true;
+    }
+    if (entry === ".agentera" && agenteraUserStateDirIsRecognized(full)) {
+        return true;
+    }
+    if (USER_DATA_CATALOG_DIRS.includes(entry) &&
+        st.isDirectory()) {
+        return true;
+    }
+    return false;
+}
+function listPreservedTopLevelFromScan(appHome) {
+    if (!pathExists(appHome)) {
+        return [];
+    }
+    const preserved = [];
+    for (const entry of fs.readdirSync(appHome)) {
+        if (entry === "app" || entry === V2_HANDOFF_MANIFEST_FILENAME) {
+            continue;
+        }
+        if (isPreservedUserStateEntry(appHome, entry)) {
+            preserved.push(entry);
+        }
+    }
+    return preserved.sort();
+}
+function listPreservedAbsolutePathsFromScan(appHome) {
+    const preserved = [];
+    for (const entry of listPreservedTopLevelFromScan(appHome)) {
+        const full = path.join(appHome, entry);
+        preserved.push(full);
+        if (entry === ".agentera" && pathExists(full) && fs.statSync(full).isDirectory()) {
+            for (const name of AGENTERA_USER_STATE_NAMES) {
+                const nested = path.join(full, name);
+                if (isFile(nested)) {
+                    preserved.push(nested);
+                }
+            }
+        }
+    }
+    return preserved.sort();
+}
+function listPreservedTopLevelFromManifest(manifest) {
+    const preserved = new Set();
+    for (const entry of manifest.user_data_inventory) {
+        if (entry.kind === "directory" && entry.exists) {
+            preserved.add(entry.relative_path);
+        }
+        if (entry.kind === "profile_files") {
+            for (const member of entry.members) {
+                if (member.exists) {
+                    preserved.add(member.relative_path);
+                }
+            }
+        }
+    }
+    return [...preserved].sort();
+}
+function listPreservedAbsolutePathsFromManifest(manifest, appHome) {
+    const root = resolvePath(appHome);
+    const preserved = [];
+    for (const rel of listPreservedTopLevelFromManifest(manifest)) {
+        preserved.push(path.join(root, rel));
+    }
+    const agenteraDir = path.join(root, ".agentera");
+    if (pathExists(agenteraDir) && fs.statSync(agenteraDir).isDirectory()) {
+        preserved.push(agenteraDir);
+        for (const name of AGENTERA_USER_STATE_NAMES) {
+            const nested = path.join(agenteraDir, name);
+            if (isFile(nested)) {
+                preserved.push(nested);
+            }
+        }
+    }
+    return preserved.sort();
+}
+export function isManifestCatalogEntryPreserved(manifest, entry) {
+    for (const item of manifest.user_data_inventory) {
+        if (item.kind === "directory" && item.relative_path === entry) {
+            return item.exists;
+        }
+        if (item.kind === "profile_files") {
+            for (const member of item.members) {
+                if (member.relative_path === entry) {
+                    return member.exists;
+                }
+            }
+        }
+    }
+    if (entry === ".agentera") {
+        const agenteraDir = path.join(resolvePath(manifest.app_home_path), ".agentera");
+        return agenteraUserStateDirIsRecognized(agenteraDir);
+    }
+    return false;
+}
+function profileDirEnvVar(env) {
+    if (env[AGENTERA_PROFILE_DIR_ENV]) {
+        return AGENTERA_PROFILE_DIR_ENV;
+    }
+    if (env[PROFILERA_PROFILE_DIR_ENV]) {
+        return PROFILERA_PROFILE_DIR_ENV;
+    }
+    return null;
+}
+function opencodeConfigDirEnvVar(env) {
+    if (env.OPENCODE_CONFIG_DIR) {
+        return "OPENCODE_CONFIG_DIR";
+    }
+    if (env.XDG_CONFIG_HOME) {
+        return "XDG_CONFIG_HOME";
+    }
+    return null;
+}
+function listUserDataPathsAtRoot(root) {
+    const preserved = new Set([root]);
+    for (const dir of USER_DATA_CATALOG_DIRS) {
+        const full = path.join(root, dir);
+        if (pathExists(full) && fs.statSync(full).isDirectory()) {
+            preserved.add(full);
+        }
+    }
+    for (const file of PROFILE_FILE_MEMBERS) {
+        const full = path.join(root, file);
+        if (isFile(full)) {
+            preserved.add(full);
+        }
+    }
+    return [...preserved].sort();
+}
+function opencodeConfigDirHasArtifacts(configDir) {
+    if (isFile(path.join(configDir, "plugins", "agentera.js"))) {
+        return true;
+    }
+    const agentsDir = path.join(configDir, "agents");
+    if (pathExists(agentsDir) && fs.statSync(agentsDir).isDirectory()) {
+        if (fs.readdirSync(agentsDir).some((name) => isFile(path.join(agentsDir, name)))) {
+            return true;
+        }
+    }
+    return pathExists(path.join(configDir, "skills", "agentera"));
+}
+function listOpencodeConfigCatalog(configDir) {
+    const preserved = new Set([configDir]);
+    for (const rel of ["plugins/agentera.js", "agents", "commands", "skills"]) {
+        const full = path.join(configDir, rel);
+        if (pathExists(full)) {
+            preserved.add(full);
+        }
+    }
+    return [...preserved].sort();
+}
+export function buildExternalHandoffCatalog(appHome, opts) {
+    if (!opts?.env) {
+        return [];
+    }
+    const env = opts.env;
+    const home = resolvePath(opts.home ?? appHome);
+    const resolvedAppHome = resolvePath(appHome);
+    const catalog = [];
+    const profileEnvVar = profileDirEnvVar(env);
+    const profileOverride = resolveProfileDirOverride(env);
+    if (profileEnvVar && profileOverride) {
+        const profileDir = resolvePath(expanduser(profileOverride));
+        if (profileDir !== resolvedAppHome) {
+            catalog.push({
+                surface: "custom_profile_dir",
+                root: profileDir,
+                envVar: profileEnvVar,
+                entries: listUserDataPathsAtRoot(profileDir),
+            });
+        }
+    }
+    const opencodeEnvVar = opencodeConfigDirEnvVar(env);
+    if (opencodeEnvVar) {
+        const configDir = opencodeConfigDir(home, env);
+        const defaultDir = resolvePath(path.join(home, ".config", "opencode"));
+        if (configDir !== defaultDir && opencodeConfigDirHasArtifacts(configDir)) {
+            catalog.push({
+                surface: "opencode_runtime_config_dir",
+                root: configDir,
+                envVar: opencodeEnvVar,
+                entries: listOpencodeConfigCatalog(configDir),
+            });
+        }
+    }
+    return catalog;
+}
+function mergePreservedAbsolutePaths(base, handoffCatalog) {
+    const merged = new Set(base);
+    for (const entry of handoffCatalog) {
+        for (const absolutePath of entry.entries) {
+            merged.add(absolutePath);
+        }
+    }
+    return [...merged].sort();
+}
+export function handoffCatalogMessage(entry) {
+    if (entry.surface === "custom_profile_dir") {
+        return `custom profile dir (${entry.envVar}=${entry.root}) cataloged for v2→v3 handoff`;
+    }
+    return `opencode runtime config dir (${entry.envVar} → ${entry.root}) cataloged for v2→v3 handoff`;
+}
+export function resolveMigrationUserStatePreflight(appHome, opts) {
+    const resolvedHome = resolvePath(appHome);
+    const handoffCatalog = buildExternalHandoffCatalog(resolvedHome, opts);
+    const manifestRead = readV2HandoffManifestFile(resolvedHome);
+    if (manifestRead) {
+        return {
+            source: "manifest",
+            elapsedMs: manifestRead.elapsedMs,
+            manifest: manifestRead.manifest,
+            preservedTopLevel: listPreservedTopLevelFromManifest(manifestRead.manifest),
+            preservedAbsolutePaths: mergePreservedAbsolutePaths(listPreservedAbsolutePathsFromManifest(manifestRead.manifest, resolvedHome), handoffCatalog),
+            handoffCatalog,
+        };
+    }
+    const started = performance.now();
+    const preservedTopLevel = listPreservedTopLevelFromScan(resolvedHome);
+    const preservedAbsolutePaths = mergePreservedAbsolutePaths(listPreservedAbsolutePathsFromScan(resolvedHome), handoffCatalog);
+    return {
+        source: "scan",
+        elapsedMs: performance.now() - started,
+        manifest: null,
+        preservedTopLevel,
+        preservedAbsolutePaths,
+        handoffCatalog,
+    };
+}
+export function appHomeHasUnrecognizedEntriesWithPreflight(appHome, preflight) {
+    if (!pathExists(appHome)) {
+        return [];
+    }
+    const unknown = [];
+    for (const entry of fs.readdirSync(appHome)) {
+        if (entry === "app" || entry === V2_HANDOFF_MANIFEST_FILENAME) {
+            continue;
+        }
+        if (MANAGED_APP_CONTENT_ROOT_ENTRIES.has(entry)) {
+            continue;
+        }
+        if (preflight.source === "manifest" && preflight.manifest) {
+            if (isManifestCatalogEntryPreserved(preflight.manifest, entry)) {
+                continue;
+            }
+        }
+        else if (isPreservedUserStateEntry(appHome, entry)) {
+            continue;
+        }
+        unknown.push(entry);
+    }
+    return unknown;
+}
+export function isV2HandoffManifestStale(manifest, ctx) {
+    if (resolvePath(manifest.app_home_path) !== resolvePath(ctx.appHome)) {
+        return true;
+    }
+    if (manifest.installed_v2_version !== ctx.installedVersion) {
+        return true;
+    }
+    const writtenAtMs = Date.parse(manifest.written_at);
+    const markerMs = ctx.bundleMarkerMtimeMs;
+    if (Number.isNaN(writtenAtMs) || Math.floor(writtenAtMs / 1000) < Math.floor(markerMs / 1000)) {
+        return true;
+    }
+    return false;
+}
+export function bundleMarkerFreshnessContext(appHome, sourceRoot) {
+    const roots = doctorRoots(appHome);
+    const markerPath = path.join(roots.activeBundleRoot, ".agentera-bundle.json");
+    if (!isFile(markerPath)) {
+        return null;
+    }
+    const installedVersion = loadSuiteVersion(roots.activeBundleRoot) ?? loadSuiteVersion(sourceRoot) ?? "unknown";
+    return {
+        appHome: resolvePath(appHome),
+        installedVersion,
+        bundleMarkerMtimeMs: fs.statSync(markerPath).mtimeMs,
+    };
+}

package/dist/registries/activationContract.js

@@ -0,0 +1,2 @@
+export { ACTIVATION_CENSUS_AUTHORITY, ACTIVATION_CHECK_IDS, ACTIVATION_CLASSES, ACTIVATION_CLASS_AUTHORITIES, ACTIVATION_DIMENSIONS, ACTIVATION_EVIDENCE_SOURCES, } from "./packagePublication.js";
+export { ACTIVATION_CANONICAL_TUPLES, ACTIVATION_TUPLE_AUTHORITY, canonicalTupleJson, digestCanonicalTuples, } from "./activationTuples.js";

package/dist/registries/activationTuples.js

@@ -0,0 +1,107 @@
+import { createHash } from "node:crypto";
+import { gunzipSync } from "node:zlib";
+// This compressed literal is the immutable, code-owned tuple catalog. It expands
+// only into exact tuple records; no production loader participates in authority.
+const CATALOG = [
+    "H4sIAAAAAAACA+1dW3PiOBZ+319B8TyGqd23bO1DOs32ZDed9JJMV01NpihhC1DHWG7JZsJMzX9fyTdssEEm7uYcwUsugI4/fd/R",
+    "7egg/fpb71+9X//W6/3Zd30iZf9K/Wb9H/oyFjPi0gnz1EuhYEuqXuS/B1RMQhIt9IvEfSFzKoeqwFAKN/ntManedhdDly+XJPDk",
+    "IJJFQbleTrk/4eov6lM34kKZeX/7+On66ean0Xjy9PBpcjf6PLqb3Dx8/Hh9//5xU7QoEMS+r+BRZT1ibvHGhM0mJFjn77sk4AFz",
+    "iT9xuRDqE4wHGnMQLnvOTa+MvRdRGV1JHguX9hwn+TepC1GlVkSXvOHBlzhIjAz027pSf/1wiDUShs6CX4hrTZzHE8QX2trRFkv1",
+    "iAtrbVkL54J4F97a8raigs3WF9pa0iZoyEV0oa0lbTIipcpfWDNkzV0olBfaWtLms+DSQtuSplzNfbmwdkS/dpl7tGXta0zFZerR",
+    "uoXypXrOpWdrPdMlPvMuzfSIuS6PL6y1dzcm9VMvtLUMGjHpxvKyRmi/IJWUCHdxIa4lcaFPLq20LWnTmPnehbWWrPEwYkv2x2Us",
+    "bb0FE3vsMuE9Yv8lXtJLDKT9kCD4jPmXZtra4ahk88tg2npYUNM29WFxWZse4o6EZMp8Fq3r4m+xwaIhN8DUi2mZIQsU9XHy3MNE",
+    "lj9sA2+mi9Qyb2mZ8+bNeJVaJi4rdN7Mma9Ty9Tlpc6bO7Olapk3XeK8OTNcqZZJS4qcN2vmK9UycXmp8+bOcLFaJi4pcuYjqvFi",
+    "tTKkZqXOfFwwXa9Whoa00Jl7neGKteJzSZkzHx/aLFkrQ8Sm4DkwKGIFJ0kdrzZYLiIy9elALoigniNfmO87aWhgP5mZwaHPZtRd",
+    "uz69jqMFF0qigwz6nHh3O8VquNwL71tTnFcw+10AbsnwgivT6jOxQUpw/shAqbqiY5oiuvEpCeLQiNb7upLKPZSflxI1SoWq8FBx",
+    "yj36CpfSDB0SRgWNmGpgV+pZQUQFGehejvi+anMLzl8GSXWSP+XgizQI1JyA9yPqYIs6sZAKeyjoJOKKzFjSQbhGqVFTTexSSlKp",
+    "Q5cT9Z6IcEtVUxVbteKhLVLlNbFEKRuak73tyIIGZG3LyVORJ8rpmCqGtfU01AOrSoLOWRKb0Cv6JREvNAp99fGsJ0eh0OE6WKFO",
+    "6MdzFgzArkZbobdCEaFscUEFVk128CNTJY0mDfLKZUE7nwUvkLXYixqbAtpx0qo4HpWuYKHCPDDbDzylBvtx26GCWR4APBVy3Hao",
+    "YLjfBk+GArglOhjmrwEUokBuiRKmeQ8ApdhAt0ML46wneFqUoFuiRYsMA4ByVNDboYhR9ik8KTLYlmhgmOkFUIYCuR1KGOexw5Oi",
+    "BN0OLQy//QNPiQK4HToYfpsIng4FcGw6JDH9tD5FDA00/w2AUfMOPr5XhxYz4/BjeXVoMTOOIG5XCxc15whidPV4UbOOIR7XABg3",
+    "7y9JNTBNYKqYMbO/oF/QsJ5ixcw2C2RIX1C5egUydu7Vq8iozxFjZj7ZosBEfAkwet6h72o1AEbNO5IdrGbMuNl/0RVB1d+UIWPm",
+    "HvxOYQ1Y7HxjcvQNXtSsI9iLrcdrAeuYvL2EGDPzghKfSUzMlxHjZh5BrkEDYOS88wCXwxeAMfOOIJ+jFi5mzhHkbtTCxc85pg6m",
+    "jBg58zG22UwVMzL2eUgDnXyFKFepGTJy7qHnKzXgxc06+JylBry4WYeft9QEGDnv8HOXGhEjZx5B/lIzZOzco8hh2osatwLA85hq",
+    "0eJmHEcu0z7Q+PkHn8+0BzNu9jHkNDVDtoB74HlNzZCRc48jt2kvauwKYMhv2gcaN//Qc5zq4eLnHJfDo8102q4H/FynRsRWMI/L",
+    "6/FmPG3VBEXO0x7M2NmHn/fUDBk99zzA5vhYs5+2KgI//6kJMG7e4edANQG2gXdcnQ3iTKjdmsT4Zjl2ZEO5fKmAe7jyoWpAY+cf",
+    "y75hFS9W1rPrL1A5/S5mrOxvrljApUA9bgtUQDTdr0MNTgE6o0LhrdEge0MOiUdC5UBymD3dCeOprzAmN8Ecvmk1OTdSFd4UchSH",
+    "gSTpZdDLLwfE+PTzu7vbm+un24f7yc3D/dP4+uapnv9WiI9UIlDKVmQYekzxPmXBsLgq54vsuQvqvvTyK796yjcIC6jnbEAqyWZc",
+    "LEnUSwB1oUt2Rc96sCZL/3ATST+dXG+fvjfOy5u0j/zDbaXYBmmBDgHx15LJIV0xT7/kRIwKhxSXjbeVI7fzpMzkPY6RJqOagof0",
+    "MQRvkUwrKtgs74pCrjoGE4mybiwpvHb0VtXhrktr0laHPegs0CC7+nDzV9EfOEwj0aWcpQLst241ucVWvdj1VqFDKrXHb5Noc59L",
+    "SVRdFQD10837prZS5XZG2oxxD1cpdZ13UJ/040xVO1ABm7TSU07q6Gv69KjbcjBKCqc/H1MLBd9GzeqxrqSxSgeg26SS6u2nXKrK",
+    "OdPYm9PoDbOGwtS7xJJxs0rye90o7wk/V80Yi3a4Jvh10w8nYajWdNmyyllxl0xjn5hOunN8w01B85aVF/68W/aATCbA7ZDHJSGZ",
+    "Ml/7ob5/WcQJzpZDVdWQbkn0NRqGgs8FlfKgTlRVMybq759I4PHZ7CGOwlhNMb7GTFD97RH5b8GXhhPDFpWyQ8HFeiqYMstjNQgc",
+    "PcVIrYy1kYN66b1wf0WTD2uVqDQRZS9OO6SIQ23fcRckCKgvTUXwKZE0//1RgVNWiIEKOqhQKWOgQgNEO/jfdNKq3evLWKCPMU2A",
+    "bZNjsPRwyJACtSjWmQW2SzOZ/C3D3ikLkBflr9PireJs463o+pYN05Do4brYLVzLpc6Ocq2WpHc7xd4gk4VL0uba8lDhOGIWvSPY",
+    "Q26oVWO7ayx+vIDNVbJQyWxj0hHZXmbLnvK7bqEeUQsLN/KyD+pZraaKCvZHune5O+0omVkqbMNdgE39bEMwaKXqzttv6+2HbMf8",
+    "Ty/1WDDP4vtgtGiAZgfnajU/n1PhSPXAJXFoIJi70DEUWPwfgIlfi5aEHlwU5abGuaX2a6Nxo4kDghnXBbZsyTbJrmTEu8ojlYb7",
+    "PAqSqvSdwpgtbIy3UEf3T7dPv0zubh+fJuOf1T8fR5Px6IP6d/xLnQglYN+V26Sex7LpUTfJX4dHZxkZHj4XlPjRAhyZBSw8TOpv",
+    "TANs5BkqXDxOIiJfYJJZQMPDKJ9+0Y9fUXCElpHh4ZO+hmpJlewdgmO0ig0PpxH3ODgyM1CIZkfcBTgxSkGhYPF3teKgxZR9QMKQ",
+    "Bp4ho0nZPERWxEcPZyhsl3gMaUnFmgn7BhYiTovpMTBSa3ChZDXde4fHaoELp68uYbrqEp2n6rkztP60Agkbl7AafBUSNi4ljRzD",
+    "LzN+Tz4rsNBxGqtKSurBctEyKoxeqv+A6qpVbNjYVRC48JwsX9jkOJ3vyW8dOnSjv3AX5lGo7zT8F5iwsemqFT+w8b+AhIjLdKcB",
+    "2Mx0GxQiPouQLjAHrcGFklVY0/4aXIhYLQXLB8mpFHIBhdh6aIi41bFzYF1AFRI2LmE1/CokbFwmC2uqT3co5SdBYHQLGDpeoa35",
+    "d1BhYzT7OiQoPjeY8LGpDwQDRmYGCdP+CHclsLG9Cgkbl8A27yqQEHGZnygDbTJfgwsaq5nNbV7VTETvOF6J7SOZTnCQXXKEo/z1",
+    "x98GGaq9NPb/fO5rkM/9q+d+cc6drvpz/4fnfv755O0dy8lHUraeM0WeU6qK48A2r6tORxb//9Vvd26k8qFeeozZVS5BO2WUEWfz",
+    "kZOJ01qSCrjsnwZ5cIoiY9WrOEsiXqg4pTJFv5AA+vwNdap9EiLV0jNiZ4IHkUIbnVa2Eoz2/V3aoRVDwvDxv7d3d4Olt6tZzWMQ",
+    "KDaNA8+nqWDy9GNSW2G2Zci4RMH55gtRMA61bTMJyMvg5p94y5MO9ePR9fuPo0PfpaxQXxTBzHwczgXxqDOPmXdSAX7+9GF8/b6d",
+    "ApsymCXQJ0vNqc/np6T/5qfr+w+ju4cPrQQol8IsgUclmwen5P/96PH2w30r8osimJn3mUsDedKe5+72ZnT/ODInPiuAe8A9feij",
+    "Er/oKOyBSoPsRI1N+pujHhrGJ52DzthrFAtlOEOXH0KZIjt8bEFFKgNjKAVUK1AdHaXeVRC+OqmcAIIixUU8zgZWy8bVaOKQTs/9",
+    "4lM7Wj33SZJOk7xbKPbcfxcz33MKMnv/eXy476U09phUWun9zR4JvJ509eGbXo8FvWhBe/Q1OeBJvZBR+M9edktNcaJKL0dBZY9F",
+    "sudR9YLQJQT3Ylc9YUpdEkvaC3he2OXhWtlW/MrBc/8E3pTVK2sfjiLAZCv/G3pULaCWLtVs47v5VPrMnhKQsjA6J9+iSxZpz9o9",
+    "gDo/8Fm7TXqSanTSgccY4TEh3kZ7KIefZlF1NFsn2DlTn0/BCVqD7mgxt23ZJ+SC+iFECTe43iJeZsU+2ZZsnm6cZ6fxexA1bAD5",
+    "FkHrTNqnLlcaBVF67iRAXXfgvUXRqjELR0qfBMXRv8l9QiBHzAaUbxo562zaJ3CSIfS/mFalgSLsNrq3CFqxZZ+QOqd0TInHAirl",
+    "Y1IzoB3wPqRvEbjRrl1i11+vM07X7dD0NgB7rOSHTNvXxHcvw5rSwF3oaCDEdn4Q7lsa+37jZ6G9juIh0X0DtWPNM8PnoLfrc0lV",
+    "F4dD8irablUv2T4L4WvuaQEsfAVtx8JvbJ+D8Pll8DiEr6LtVviS7XMQngt3QZUcYGNoRpC7dYHtB5yDH8gFARoc34+1W+ULy+cg",
+    "ebQOqcSheAlqt4Lnhs+iiUdERHF4PZ8rQRH19024O276dU+x0C34UrHmyRIDIL2gCeabRK81arHGSUoGaHlLCDtRNrdnsahfoe6g",
+    "1SHsRNSv1u6kFVXUGdmwW2oJYSei5vbsE9VjUnHgLoDmcTYgfIuoO/YsFrW4Uxq0sFsoOxG3bNP2SVM52+ohjkKgeyFGmLubWNU+",
+    "wXpXcLmvKzdKLrN6gJ1x2Ap6h46x50HW+0eyMzx6pW6c59tSiaG72IO7Q89oeor9bqGEneHqLuohd+kMuw+wyw8qh+QBE3wX27HK",
+    "blk6g+A5ikj5NwiLn01yowz5C8WS2lgC23ViY276HFQHG5/ZC7Vbxe2N2DRu8aHa9fyGW51ntHYvTTnBfrOsDfLuV+41z7HYOaS7",
+    "UAyC9oIyxE7kLgzarGty1npytjxobbdgdqNv2aj1Gs9phEDiAmWHCqc2rRcY7uS8EWeHIls8La9W1GcSQ0PewOxQ5Myo9RondxDB",
+    "13gDs0ONM6MWa5wdWQ1a4ArGTtTdWLRf2s/JEzAIXEbapcyFXYvFXsFXedW1vCt7dc3TtiCnqXWXnGZ3zmFy1RrofMMSwk5yDXN7",
+    "FosK9ssZdQg7EdXeL2cUVZRQdxfqEHYiqrRyt0BfAlA+62lUXAoATdxDSI8Vea9du8TerNTfc1cmOawM3jej96E8VuRGm7AFnnIe",
+    "6fMZwm2Js9tyr9JT3g/Kl19eOywMXsfRgoutL8XW6lcU+UiUA7wWBWuvVtmGdeTNvLV0RVRGmeWe4yT/JhXMHvquinMQZUm+bSk1",
+    "vf/1e3Naaux4SE3a3ZXrUxKAIbSKCR2Zq78DYzIBhI7GkIiIER8YlxtU+PzyH9D88h+4aCSuS8Nk3pZcMPE15uofx5+BoXUPQPQ0",
+    "uwI4zQlAtDQDJRcppQoGXy5p4Cm/yHJc4RFcDxIj3R7XQCF3yDUI8RMNsUuuQYiXaKj0Iu6VV1SsnR9hdsYFNkxBGfolff5V+pcz",
+    "JQJQaKYBHXaCnYC+RrBZziFiplrNiqY+YG8u8OEnGXi/UQWJmW59fXPAnTVcrksIUft16DP1M68oXNfexomZ9CWTkgVzJ90ehEv6",
+    "Dk7MpAvKhUcF9eDyXYaImWoarJzf1QdDCrhHqYLETLc2Cp/vLZSo/VuRiMDBqyhxryblAj7hWygxE64oJBIu0zk8zBTP4iDFA5bl",
+    "EkLUa0llAPKsr8CHmWSXL0MuGWyHroJEvYKM/YiFkKN+JYSo4yPxVEYsimE79hZK1J5NfB1uoF66OwrYwXeA2kG7uyBBQH0MxG+g",
+    "wqD+t/8DfpAaejqfAQA=",
+].join("");
+// Emitted producers carry `reason`, while generated files carry
+// `command_authority_reason`. This immutable patch catalog intentionally updates
+// the M6 tuple payload without consulting the mutable package registry loader.
+const EMITTED_REASON_CATALOG = "H4sIAAAAAAACA8VYXXPrJhD9K0ye6+v3+9Z8zPShHbfx7X1HsJaYYFAAqfZ0+t+7fEhCsRNbTiy/xAIUnbMLu3uWf+9gK5wD/r2m7IWWYJdMiqU1bMloTQshhRM4KRSH3Tdn777fPehtLcEB6V/Yk0JzfItQxYl11LimJkxvtzi2pKbWElcZ3ZQV/gKxFTXASW1gwRqnWzD4srLONMxpk76iG8NgmUgR3bi6ccQyquy3u18+II2/tRFbWBRSF28IIzUnGAnrpGwEp4pB4AdHGYpESmi1QAv3Oc1Ps6xA1pHfb/hEYEc9y/fdlfx5wIF11vkPJgroQwNv2XlaCvhJYltRGuptfobXRiB0ZPkHZZVQQAwwv2V7shEgcXt7PmgC4H7SQmbO1Urue2twxx/ihj9EY05y0UaAcoHNmEW2MAuRWlL1u9gA2zMJawSGMR/Zrc3Cxh9k+KvBXRizePVTww7VRlsYmNhrUHGa62egHOGtXYMEdrhZP1aPK2TlcM9aKq/uIQOlsB7MLqt9YQR/xqiAZ2AgaheZhRnvKD/VpyzauAoPltt/zmchLCtqSQEVbYU2aHNKDawC9nI6NwyZ9UErBzu3LECxakvNS0ppWertVmY5eUeYNUKmFHHvHz2+X7gRHSbxzKO3k5/S6Nak8NdQ5g42r1u4ES9oBcfjk3LZUxrd2FnaYJQgYJb1V/nUjenFchx5rVNpHjb0NpzcvgYbKf3AR042VMoC/5dw2NBGuvm9FFPqr2WJ2TjbyXWXalsqZOc0ny+5sF+nK1IGboHQRACmZuCkXjPTjgRvBJtVEfXEgoqNnP4MgrajwwUtlbaodL/Kicdl7lRPvg56JUiXnvCsbjO+8uci4Hpuu7j8YyzU1LEq77oe0xw2S/156756VYHXk+klbiTUq+GZ+YwDIO8QVgG+qxhDf5BozR+dOJReED8ph/li9baXidOjVuZ2VIOMewowqfXDgpvLOhOnvixOJhNEN20OfHjvZ2ftBguhljiBZc7QVHKxSc9AcMn3XlooR+qmkMKidiF8iN+0ya6i+MdQZYUTLcioBqlQFnlSw7Oev+M9vRAPDIelRS+gKKPcx+8CdrU2LgeOb2AHyRsG5rKWxdb6JWWL+zjIpVLCsGMfJI8duCBu6wU0shz6jhvCG9fyQhJCY/XTfdjfPG0LfxSPuADsxU44moWy2MkuMPJEGa4Vrk7KYhBsU+isw3MfER8D/oOtebgrnBoUPbK3b8k1S1r5EZ8W0ejzGHwWuoQUkE87bPoWODwTeLg8uRT6TRhEqzt73o2A+NqE8z8GRStcpxbsfLb6O6lkqr95uj5sU5cGM2nE/DsOzoZN4uli1J9gxGY/xm79nGAjUXE9Im3G4Od05MlR1dXS4Thn1fX9opbYnH+ae+kbdHvq//xjj3fEGjxBaEYwf9QcRvTzMQ/6uw8wuwvMqRh2qAOhJJzA6PPkhwg+hvKL1yccN5lk85NClQT6+VMHpDMPd64FdfKIDEnAJ/igskV/PRKvorEAMyzT0+LjMD/89z8hk4jWPxsAAA==";
+const decodedCatalog = gunzipSync(Buffer.from(CATALOG, "base64")).toString("utf8");
+const emittedReasons = JSON.parse(gunzipSync(Buffer.from(EMITTED_REASON_CATALOG, "base64")).toString("utf8"));
+const rawTuples = JSON.parse(decodedCatalog.slice(decodedCatalog.indexOf("[", 2)).replace(/,\s*]$/, "]"));
+const addedTuples = [
+    { class: "state", surface_id: "write:plan.replace", owner_path: "packages/cli/src/state/write/runtimeOperations.ts", owner_symbol_or_selector: "runtimeOperationSpecs", owner_selector: "plan.replace", semantic_selector_if_any: null, canonical_correction: "node packages/cli/dist/bin/agentera.js check validate state --format json" },
+    { class: "state", surface_id: "write:todo.activate", owner_path: "packages/cli/src/state/write/runtimeOperations.ts", owner_symbol_or_selector: "runtimeOperationSpecs", owner_selector: "todo.activate", semantic_selector_if_any: null, canonical_correction: "node packages/cli/dist/bin/agentera.js check validate state --format json" },
+    { class: "state", surface_id: "write:todo.repair", owner_path: "packages/cli/src/state/write/runtimeOperations.ts", owner_symbol_or_selector: "runtimeOperationSpecs", owner_selector: "todo.repair", semantic_selector_if_any: null, canonical_correction: "node packages/cli/dist/bin/agentera.js check validate state --format json" },
+    { class: "package", surface_id: "emitted:packages/cli/src/cli/commands/doctor.ts", owner_path: "packages/cli/src/registries/packageRegistry.ts", owner_symbol_or_selector: "loadRegistry", owner_selector: "packages/cli/src/cli/commands/doctor.ts", semantic_selector_if_any: JSON.stringify({ path: "packages/cli/src/cli/commands/doctor.ts", selector: null, format: null, classification: null, reason: "Doctor project-state signals publish bounded reconciliation preview and apply guidance." }), canonical_correction: "pnpm -C packages/cli run verify:package" },
+    { class: "package", surface_id: "emitted:packages/cli/src/state/todoReconciliationInspection.ts", owner_path: "packages/cli/src/registries/packageRegistry.ts", owner_symbol_or_selector: "loadRegistry", owner_selector: "packages/cli/src/state/todoReconciliationInspection.ts", semantic_selector_if_any: JSON.stringify({ path: "packages/cli/src/state/todoReconciliationInspection.ts", selector: null, format: null, classification: null, reason: "TODO reconciliation inspection publishes bounded preview and effect-bound apply guidance." }), canonical_correction: "pnpm -C packages/cli run verify:package" },
+];
+const tuples = [...rawTuples, ...addedTuples].map((tuple) => {
+    const reason = emittedReasons[tuple.surface_id];
+    if (tuple.class !== "package" || reason === undefined || tuple.semantic_selector_if_any === null)
+        return tuple;
+    const semantic = JSON.parse(tuple.semantic_selector_if_any);
+    return { ...tuple, semantic_selector_if_any: JSON.stringify({ ...semantic, reason }) };
+});
+export const ACTIVATION_CANONICAL_TUPLES = Object.freeze(tuples.map((tuple) => Object.freeze(tuple)));
+export const ACTIVATION_TUPLE_AUTHORITY = Object.freeze({
+    algorithm: "sha256(sorted_canonical_json_tuples_joined_by_lf)",
+    classes: {
+        cli: { count: 27, sha256: "9d0db6cafe592da30ea3469c91dc514bdd1b3b22e8229a0519e680cbcb01c2fa" },
+        capability: { count: 12, sha256: "892e6e5e2a57b41064bc44fa2946453225f1b1195aff77aad05365fd0a1071c2" },
+        runtime: { count: 81, sha256: "99b2abff3ebff889b54b1781c563ab4b32609a479c4e90d6aad854f48fba7edc" },
+        reference: { count: 22, sha256: "243fd3c317553f8924c56a52c61af90ccf2793b7b0018af1373b73c69b6c3afb" },
+        state: { count: 37, sha256: "210bd831c5d62beac149efd888ee4a99af49a9469cf373031f8db9893904d0c1" },
+        package: { count: 66, sha256: "83e6971af7f7564e42369aaccc445b32a0793bfffade843d149b6abd4fd3dbbc" },
+        bootstrap: { count: 34, sha256: "9a7dd7e27110d85cf5c08835fdd8f08119e75579858e63bc6d396c733961d0bc" },
+    },
+    total: { count: 279, sha256: "c2d7a66bc9af04a5511348825995317a5968357c6cacbfd87eb2cc4fbe77156c" },
+});
+export function canonicalTupleJson(value) { return JSON.stringify(value); }
+export function digestCanonicalTuples(values) {
+    return createHash("sha256").update(values.map(canonicalTupleJson).sort().join("\n"), "utf8").digest("hex");
+}