@caoscompanybr/merlin 3.5.0

package/.merlin-core/core/alkimia/layers/l0-constitution.js

@@ -0,0 +1,47 @@
+/**
+ * L0 Constitution Layer Processor
+ *
+ * Injects the 7 Merlin Constitutional principles as NON-NEGOTIABLE rules.
+ * ALWAYS_ON -- processes regardless of session state.
+ *
+ * @module core/alkimia/layers/l0-constitution
+ * @version 3.0.0
+ */
+
+const path = require("path");
+const { loadDomainFile } = require("../domain/domain-loader");
+const LayerProcessor = require("./layer-processor");
+
+class L0ConstitutionProcessor extends LayerProcessor {
+  constructor() {
+    super({ name: "constitution", layer: 0, timeout: 5 });
+  }
+
+  process(context) {
+    const { config } = context;
+    const { alkimiaPath, manifest } = config;
+
+    const domainKey = Object.keys(manifest.domains || {}).find(
+      (k) => k.toUpperCase() === "CONSTITUTION",
+    );
+
+    const domain = domainKey ? manifest.domains[domainKey] : null;
+
+    const domainFile =
+      domain && domain.file
+        ? path.join(alkimiaPath, domain.file)
+        : path.join(alkimiaPath, "constitution");
+
+    const rules = loadDomainFile(domainFile);
+    if (!rules || rules.length === 0) return null;
+
+    const nonNegotiable = domain ? domain.nonNegotiable === true : false;
+
+    return {
+      rules,
+      metadata: { layer: 0, source: "constitution", nonNegotiable },
+    };
+  }
+}
+
+module.exports = L0ConstitutionProcessor;

package/.merlin-core/core/alkimia/layers/l1-global.js

@@ -0,0 +1,58 @@
+/**
+ * L1 Global Layer Processor
+ *
+ * Injects universal rules from global and context domain files.
+ * ALWAYS_ON -- processes regardless of session state.
+ *
+ * @module core/alkimia/layers/l1-global
+ * @version 3.0.0
+ */
+
+const path = require("path");
+const { loadDomainFile } = require("../domain/domain-loader");
+const LayerProcessor = require("./layer-processor");
+
+class L1GlobalProcessor extends LayerProcessor {
+  constructor() {
+    super({ name: "global", layer: 1, timeout: 10 });
+  }
+
+  process(context) {
+    const { config } = context;
+    const { alkimiaPath, manifest } = config;
+
+    const globalDomain = this._findDomain(manifest, "GLOBAL");
+    const contextDomain = this._findDomain(manifest, "CONTEXT");
+
+    const globalFile =
+      globalDomain && globalDomain.file
+        ? path.join(alkimiaPath, globalDomain.file)
+        : path.join(alkimiaPath, "global");
+
+    const contextFile =
+      contextDomain && contextDomain.file
+        ? path.join(alkimiaPath, contextDomain.file)
+        : path.join(alkimiaPath, "context");
+
+    const globalRules = loadDomainFile(globalFile);
+    const contextRules = loadDomainFile(contextFile);
+    const rules = [...globalRules, ...contextRules];
+
+    if (rules.length === 0) return null;
+
+    const sources = [];
+    if (globalRules.length > 0) sources.push("global");
+    if (contextRules.length > 0) sources.push("context");
+
+    return { rules, metadata: { layer: 1, sources } };
+  }
+
+  _findDomain(manifest, name) {
+    const key = Object.keys(manifest.domains || {}).find(
+      (k) => k.toUpperCase() === name.toUpperCase(),
+    );
+    return key ? manifest.domains[key] : null;
+  }
+}
+
+module.exports = L1GlobalProcessor;

package/.merlin-core/core/alkimia/layers/l2-agent.js

@@ -0,0 +1,58 @@
+/**
+ * L2 Agent-Scoped Layer Processor
+ *
+ * Injects agent-specific rules based on the currently active agent.
+ * Detects the active agent from session.active_agent.id and finds
+ * the matching domain via agentTrigger in the manifest.
+ *
+ * @module core/alkimia/layers/l2-agent
+ * @version 3.0.0
+ */
+
+const path = require("path");
+const { loadDomainFile } = require("../domain/domain-loader");
+const { getProactiveMandate } = require("../mandate");
+const LayerProcessor = require("./layer-processor");
+
+class L2AgentProcessor extends LayerProcessor {
+  constructor() {
+    super({ name: "agent", layer: 2, timeout: 15 });
+  }
+
+  process(context) {
+    const { session, config } = context;
+    const { manifest, alkimiaPath } = config;
+
+    const agentId = session.active_agent?.id;
+    if (!agentId) return null;
+
+    const domainKey = Object.keys(manifest.domains || {}).find(
+      (k) => manifest.domains[k].agentTrigger === agentId,
+    );
+    if (!domainKey) return null;
+
+    const domain = manifest.domains[domainKey];
+    const domainFile = domain.file
+      ? path.join(alkimiaPath, domain.file)
+      : path.join(alkimiaPath, `agent-${agentId}`);
+
+    const rules = loadDomainFile(domainFile);
+    if (!rules || rules.length === 0) return null;
+
+    const hasAuthority = rules.some((r) => r.toUpperCase().includes("AUTH"));
+
+    return {
+      rules,
+      metadata: {
+        layer: 2,
+        source: `agent-${agentId}`,
+        agentId,
+        hasAuthority,
+        // v3.4: per-agent Proactive Mandate (rendered in the protected AGENT section)
+        mandate: getProactiveMandate(agentId),
+      },
+    };
+  }
+}
+
+module.exports = L2AgentProcessor;

package/.merlin-core/core/alkimia/layers/l3-workflow.js

@@ -0,0 +1,54 @@
+/**
+ * L3 Workflow Layer Processor
+ *
+ * Injects workflow-specific rules based on the currently active workflow.
+ * Includes Folloni funnel phase awareness.
+ *
+ * @module core/alkimia/layers/l3-workflow
+ * @version 3.0.0
+ */
+
+const path = require("path");
+const { loadDomainFile } = require("../domain/domain-loader");
+const LayerProcessor = require("./layer-processor");
+
+class L3WorkflowProcessor extends LayerProcessor {
+  constructor() {
+    super({ name: "workflow", layer: 3, timeout: 15 });
+  }
+
+  process(context) {
+    const { session, config } = context;
+    const { manifest, alkimiaPath } = config;
+
+    const workflowId = session.active_workflow?.id;
+    if (!workflowId) return null;
+
+    const domainKey = Object.keys(manifest.domains || {}).find(
+      (k) => manifest.domains[k].workflowTrigger === workflowId,
+    );
+    if (!domainKey) return null;
+
+    const domain = manifest.domains[domainKey];
+    const domainFile = domain.file
+      ? path.join(alkimiaPath, domain.file)
+      : path.join(alkimiaPath, `workflow-${workflowId}`);
+
+    const rules = loadDomainFile(domainFile);
+    if (!rules || rules.length === 0) return null;
+
+    const phase = session.active_workflow?.current_phase || null;
+
+    return {
+      rules,
+      metadata: {
+        layer: 3,
+        source: `workflow-${workflowId}`,
+        workflow: workflowId,
+        phase,
+      },
+    };
+  }
+}
+
+module.exports = L3WorkflowProcessor;

package/.merlin-core/core/alkimia/layers/l4-task.js

@@ -0,0 +1,45 @@
+/**
+ * L4 Task Layer Processor
+ *
+ * Injects task-specific context based on the currently active task.
+ *
+ * @module core/alkimia/layers/l4-task
+ * @version 3.0.0
+ */
+
+const LayerProcessor = require("./layer-processor");
+const {
+  sanitizeId,
+  sanitizeContent,
+} = require("../security/content-sanitizer");
+
+class L4TaskProcessor extends LayerProcessor {
+  constructor() {
+    super({ name: "task", layer: 4, timeout: 20 });
+  }
+
+  process(context) {
+    const { session } = context;
+    const task = session.active_task;
+    if (!task || !task.id) return null;
+
+    const rules = [];
+    rules.push(`Active Task: ${sanitizeId(task.id)}`);
+    if (task.story)
+      rules.push(`Story: ${sanitizeContent(task.story, { maxLength: 500 })}`);
+    if (task.executor_type)
+      rules.push(`Executor: ${sanitizeId(task.executor_type)}`);
+
+    return {
+      rules,
+      metadata: {
+        layer: 4,
+        taskId: task.id,
+        story: task.story || null,
+        executorType: task.executor_type || null,
+      },
+    };
+  }
+}
+
+module.exports = L4TaskProcessor;

package/.merlin-core/core/alkimia/layers/l5-squad.js

@@ -0,0 +1,161 @@
+/**
+ * L5 Squad Layer Processor
+ *
+ * Discovers and merges domain rules from installed squads.
+ * Scans squads/ directory for .alkimia/manifest files.
+ *
+ * @module core/alkimia/layers/l5-squad
+ * @version 3.0.0
+ */
+
+const fs = require("fs");
+const path = require("path");
+const { parseManifest, loadDomainFile } = require("../domain/domain-loader");
+const LayerProcessor = require("./layer-processor");
+
+const CACHE_TTL_MS = 60000;
+
+class L5SquadProcessor extends LayerProcessor {
+  constructor() {
+    super({ name: "squad", layer: 5, timeout: 20 });
+  }
+
+  process(context) {
+    const { session, config } = context;
+    const { alkimiaPath } = config;
+
+    const projectRoot = path.dirname(alkimiaPath);
+    const squadsDir = path.join(projectRoot, "squads");
+
+    if (!fs.existsSync(squadsDir)) return null;
+
+    const cacheDir = path.join(alkimiaPath, "cache");
+    const cachePath = path.join(cacheDir, "squad-manifests.json");
+    const cachedData = this._readCache(cachePath);
+
+    let squadManifests;
+    if (cachedData) {
+      squadManifests = cachedData.manifests;
+    } else {
+      squadManifests = this._scanSquads(squadsDir);
+      this._writeCache(cachePath, cacheDir, squadManifests);
+    }
+
+    if (Object.keys(squadManifests).length === 0) return null;
+
+    const activeSquadName = session.active_squad?.name || null;
+    const allRules = [];
+    const domainsLoaded = [];
+
+    if (activeSquadName && squadManifests[activeSquadName]) {
+      this._loadSquadDomains(
+        activeSquadName,
+        squadManifests[activeSquadName],
+        squadsDir,
+        allRules,
+        domainsLoaded,
+      );
+    }
+
+    for (const squadName of Object.keys(squadManifests)) {
+      if (squadName === activeSquadName) continue;
+      this._loadSquadDomains(
+        squadName,
+        squadManifests[squadName],
+        squadsDir,
+        allRules,
+        domainsLoaded,
+      );
+    }
+
+    if (allRules.length === 0) return null;
+
+    return {
+      rules: allRules,
+      metadata: {
+        layer: 5,
+        squadsFound: Object.keys(squadManifests).length,
+        domainsLoaded,
+      },
+    };
+  }
+
+  _loadSquadDomains(squadName, manifest, squadsDir, allRules, domainsLoaded) {
+    const squadUpper = squadName.toUpperCase();
+    const squadAlkimiaPath = path.join(squadsDir, squadName, ".alkimia");
+    const extendsKey = `${squadUpper}_EXTENDS`;
+    const mergeMode = manifest.domains?.[extendsKey]?.file || "extend";
+    const resolvedMerge = ["extend", "override", "none"].includes(mergeMode)
+      ? mergeMode
+      : "extend";
+    if (resolvedMerge === "none") return;
+
+    for (const [domainKey, domain] of Object.entries(manifest.domains || {})) {
+      if (domainKey === extendsKey) continue;
+      const namespacedKey = `${squadUpper}_${domainKey}`;
+      const domainFile = domain.file
+        ? path.join(squadAlkimiaPath, domain.file)
+        : path.join(
+            squadAlkimiaPath,
+            domainKey.toLowerCase().replace(/_/g, "-"),
+          );
+
+      const rules = loadDomainFile(domainFile);
+      if (rules && rules.length > 0) {
+        allRules.push(...rules);
+        domainsLoaded.push(namespacedKey);
+      }
+    }
+  }
+
+  _readCache(cachePath) {
+    try {
+      const raw = fs.readFileSync(cachePath, "utf8");
+      const cached = JSON.parse(raw);
+      if (cached.timestamp && Date.now() - cached.timestamp < CACHE_TTL_MS)
+        return cached;
+      return null;
+    } catch {
+      return null;
+    }
+  }
+
+  _writeCache(cachePath, cacheDir, manifests) {
+    try {
+      if (!fs.existsSync(cacheDir)) fs.mkdirSync(cacheDir, { recursive: true });
+      fs.writeFileSync(
+        cachePath,
+        JSON.stringify({ timestamp: Date.now(), manifests }),
+      );
+    } catch {
+      /* non-fatal */
+    }
+  }
+
+  _scanSquads(squadsDir) {
+    const manifests = {};
+    let entries;
+    try {
+      entries = fs.readdirSync(squadsDir, { withFileTypes: true });
+    } catch {
+      return manifests;
+    }
+
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const manifestPath = path.join(
+        squadsDir,
+        entry.name,
+        ".alkimia",
+        "manifest",
+      );
+      if (!fs.existsSync(manifestPath)) continue;
+      const parsed = parseManifest(manifestPath);
+      if (parsed && Object.keys(parsed.domains).length > 0)
+        manifests[entry.name] = parsed;
+    }
+    return manifests;
+  }
+}
+
+module.exports = L5SquadProcessor;