agent-enderun 1.10.2 → 1.10.4

package/src/cli/commands/orchestrate.ts

@@ -1,6 +1,5 @@
 import fs from "fs";
 import path from "path";
-import chalk from "chalk";
 import { getFrameworkDir, updateDocumentStore, readStatus } from "../utils/memory.js";
 import { UI } from "../utils/ui.js";
 import { writeTextFile, appendFile } from "../utils/fs.js";
@@ -19,7 +18,8 @@ export const HermesMessageSchema = z.object({
     parentId: z.string().optional(),
     status: z.enum(["PENDING", "PROCESSED", "WAITING", "APPROVED"]),
     priority: z.enum(["HIGH", "NORMAL", "LOW"]).optional(),
-    action: z.string().optional()
+    action: z.string().optional(),
+    requiresApproval: z.boolean().optional(),
 });
 
 export type HermesMessage = z.infer<typeof HermesMessageSchema>;
@@ -49,162 +49,182 @@ export async function orchestrateCommand() {
     isLooping = true;
 
     while (isLooping) {
-        // Initial load from disk to sync the cache
-        if (Object.keys(agentStatusCache).length === 0) {
-            const diskStatus = readStatus();
-            agentStatusCache = diskStatus || {};
-        }
+        try {
+            // Initial load from disk to sync the cache
+            if (Object.keys(agentStatusCache).length === 0) {
+                const diskStatus = readStatus();
+                agentStatusCache = diskStatus || {};
+            }
 
-        // Check for agent timeouts (e.g. 30 minutes in EXECUTING state)
-        const agentStatuses = readStatus();
-        let updatedStatus = false;
-        for (const [agentName, info] of Object.entries(agentStatuses)) {
-            const { state, lastUpdated } = info as { state: string; task: string; lastUpdated?: string };
-            if (state === "EXECUTING" && lastUpdated) {
-                const lastUpdatedTime = Date.parse(lastUpdated);
-                if (!isNaN(lastUpdatedTime) && Date.now() - lastUpdatedTime > 30 * 60 * 1000) {
-                    UI.error(`⚠️  Agent ${agentName} has TIMED OUT (in EXECUTING state for >30m). Transitioning to BLOCKED.`);
-                    agentStatuses[agentName] = { state: "BLOCKED", task: "Timeout occurred", lastUpdated: new Date().toISOString() };
-                    updatedStatus = true;
+            // Check for agent timeouts (e.g. 30 minutes in EXECUTING state)
+            const agentStatuses = readStatus();
+            let updatedStatus = false;
+            for (const [agentName, info] of Object.entries(agentStatuses)) {
+                const { state, lastUpdated } = info as { state: string; task: string; lastUpdated?: string };
+                if (state === "EXECUTING" && lastUpdated) {
+                    const lastUpdatedTime = Date.parse(lastUpdated);
+                    if (!isNaN(lastUpdatedTime) && Date.now() - lastUpdatedTime > 30 * 60 * 1000) {
+                        UI.error(`⚠️  Agent ${agentName} has TIMED OUT (in EXECUTING state for >30m). Transitioning to BLOCKED.`);
+                        agentStatuses[agentName] = { state: "BLOCKED", task: "Timeout occurred", lastUpdated: new Date().toISOString() };
+                        updatedStatus = true;
+                    }
                 }
             }
-        }
-        if (updatedStatus) {
-            updateDocumentStore("status", agentStatuses);
-            agentStatusCache = { ...agentStatuses }; // Sync cache
-        }
+            if (updatedStatus) {
+                updateDocumentStore("status", agentStatuses);
+                agentStatusCache = { ...agentStatuses }; // Sync cache
+            }
 
-        if (fs.existsSync(messagesDir)) {
-            const messageFiles = fs.readdirSync(messagesDir).filter((f) => f.endsWith(".json"));
-            const pendingMessages: HermesMessage[] = [];
-            const fileMessagesMap: Record<string, HermesMessage[]> = {};
+            if (fs.existsSync(messagesDir)) {
+                const messageFiles = fs.readdirSync(messagesDir).filter((f) => f.endsWith(".json"));
+                const pendingMessages: HermesMessage[] = [];
+                const fileMessagesMap: Record<string, HermesMessage[]> = {};
 
-            for (const file of messageFiles) {
-                const filePath = path.join(messagesDir, file);
-                try {
-                    const content = fs.readFileSync(filePath, "utf8").trim();
-                    if (!content) continue;
-                    const lines = content.split("\n");
-                    const allMsgs: HermesMessage[] = [];
-                    lines.forEach((line) => {
-                        if (!line.trim()) return;
-                        try {
-                            const parsed = JSON.parse(line);
-                            const msg = HermesMessageSchema.parse(parsed);
-
-                            // Contract Validation
-                            if (msg.category === "ACTION" || msg.category === "DELEGATION") {
-                                try {
-                                    const payload = JSON.parse(msg.content);
-                                    TaskRequestSchema.parse(payload);
-                                } catch (e) {
-                                    UI.error(`Invalid task contract payload: ${(e as Error).message}`);
-                                    return; // Skip invalid message
+                for (const file of messageFiles) {
+                    const filePath = path.join(messagesDir, file);
+                    try {
+                        const content = fs.readFileSync(filePath, "utf8").trim();
+                        if (!content) continue;
+                        const lines = content.split("\n");
+                        const allMsgs: HermesMessage[] = [];
+                        lines.forEach((line) => {
+                            if (!line.trim()) return;
+                            try {
+                                const parsed = JSON.parse(line);
+                                const msg = HermesMessageSchema.parse(parsed);
+
+                                // Contract Validation
+                                if (msg.category === "ACTION" || msg.category === "DELEGATION") {
+                                    try {
+                                        const payload = JSON.parse(msg.content);
+                                        TaskRequestSchema.parse(payload);
+                                    } catch (e) {
+                                        UI.error(`Invalid task contract payload: ${(e as Error).message}`);
+                                        return; // Skip invalid message
+                                    }
                                 }
-                            }
 
-                            if (msg.status === "PENDING") {
-                                pendingMessages.push(msg);
+                                // A message is actionable if it's pending, or if it's been approved.
+                                if (msg.status === "PENDING" || msg.status === "APPROVED") {
+                                    pendingMessages.push(msg);
+                                }
+                                allMsgs.push(msg);
+                            } catch (e) {
+                                UI.error(`Skipping invalid Hermes message format: ${(e as Error).message}`);
                             }
-                            allMsgs.push(msg);
-                        } catch (e) {
-                            UI.error(`Skipping invalid Hermes message format: ${(e as Error).message}`);
-                        }
-                    });
-                    fileMessagesMap[file] = allMsgs;
-                } catch (err) {
-                    UI.error(`Error occurred while reading ${file}.`);
-                    logger.debug(`Failed to read message file ${file}`, err);
+                        });
+                        fileMessagesMap[file] = allMsgs;
+                    } catch (err) {
+                        UI.error(`Error occurred while reading ${file}.`);
+                        logger.debug(`Failed to read message file ${file}`, err);
+                    }
                 }
-            }
 
-            if (pendingMessages.length > 0) {
-                // Sort by priority: HIGH -> NORMAL -> LOW
-                const priorityOrder = { HIGH: 1, NORMAL: 2, LOW: 3 };
-                pendingMessages.sort((a, b) => {
-                    const pA = priorityOrder[a.priority || "NORMAL"] || 2;
-                    const pB = priorityOrder[b.priority || "NORMAL"] || 2;
-                    if (pA !== pB) return pA - pB;
-                    return Date.parse(a.timestamp) - Date.parse(b.timestamp);
-                });
+                if (pendingMessages.length > 0) {
+                    // Sort by priority: HIGH -> NORMAL -> LOW
+                    const priorityOrder = { HIGH: 1, NORMAL: 2, LOW: 3 };
+                    pendingMessages.sort((a, b) => {
+                        const pA = priorityOrder[a.priority || "NORMAL"] || 2;
+                        const pB = priorityOrder[b.priority || "NORMAL"] || 2;
+                        if (pA !== pB) return pA - pB;
+                        return Date.parse(a.timestamp) - Date.parse(b.timestamp);
+                    });
+
+                    UI.intent("Multi-Agent Orchestration", `${pendingMessages.length} pending tasks and collaboration messages found.`);
 
-                UI.intent("Multi-Agent Orchestration", `${pendingMessages.length} pending tasks and collaboration messages found.`);
+                    const statusChanges: Record<string, { state: string; task: string }> = {};
 
-                const statusChanges: Record<string, { state: string; task: string }> = {};
+                    for (const msg of pendingMessages) {
+                        const { from, to, content, traceId, category, status, requiresApproval } = msg;
 
-                for (const msg of pendingMessages) {
-                    const { from, to, content, traceId, category, parentId } = msg;
+                        // Approval Gate for high-risk actions.
+                        // If it requires approval but isn't approved yet, skip it for now.
+                        if ((category === "ACTION" || category === "ALERT") && requiresApproval && status !== "APPROVED") {
+                            logger.debug(`Action for @${to} (Trace: ${traceId}) is pending manager approval.`);
+                            continue;
+                        }
+                        
+                        // Gate for regular messages.
+                        // If it's a non-approval-required message, it should only be processed when PENDING.
+                        // This prevents re-processing of SUBTASK/REPLY messages that might get set to APPROVED.
+                        if (!(category === "ACTION" || category === "ALERT") && status !== "PENDING") {
+                            continue;
+                        }
 
-                    const isSubtask = category === "SUBTASK" || !!parentId;
-                    const agentLabel = isSubtask ? `${to} (Sub-Agent)` : to;
 
-                    UI.agentBox(agentLabel, content, `Trace: ${traceId} | From: ${from} | Category: ${category}`);
+                        const isSubtask = category === "SUBTASK" || !!msg.parentId;
+                        const agentLabel = isSubtask ? `${to} (Sub-Agent)` : to;
 
-                    let targetState = "EXECUTING";
-                    if (category === "DELEGATION" || category === "SUBTASK") targetState = "BRIEFED";
+                        UI.agentBox(agentLabel, content, `Trace: ${traceId} | From: ${from} | Category: ${category}`);
 
-                    let taskDescription = content;
-                    if (category === "DELEGATION" || category === "ACTION") {
-                        try {
-                            const payload = JSON.parse(content);
-                            taskDescription = payload.task || content;
-                        } catch {
-                            // Ignore
+                        let targetState = "EXECUTING";
+                        if (category === "DELEGATION" || category === "SUBTASK") targetState = "BRIEFED";
+
+                        let taskDescription = content;
+                        if (category === "DELEGATION" || category === "ACTION") {
+                            try {
+                                const payload = JSON.parse(content);
+                                taskDescription = payload.task || content;
+                            } catch {
+                                // Ignore
+                            }
                         }
-                    }
 
-                    statusChanges[to] = { state: targetState, task: taskDescription };
+                        statusChanges[to] = { state: targetState, task: taskDescription };
 
-                    if (targetState === "BRIEFED") {
-                        UI.success(`${to} informed and took over the task.`);
-                        statusChanges[to] = { state: "EXECUTING", task: taskDescription };
-                    }
+                        if (targetState === "BRIEFED") {
+                            UI.success(`${to} informed and took over the task.`);
+                            statusChanges[to] = { state: "EXECUTING", task: taskDescription };
+                        }
 
-                    if (isSubtask) {
-                        UI.success(`Sub-task connection established (Parent: ${parentId || "Unknown"}).`);
-                    }
+                        if (isSubtask) {
+                            UI.success(`Sub-task connection established (Parent: ${msg.parentId || "Unknown"}).`);
+                        }
 
-                    UI.success(`Collaboration initiated: ${from} -> ${to}`);
-                    console.warn(chalk.gray(`  👉 Instructions: ${frameworkDir}/agents/${to.replace("@", "")}.md`));
+                        UI.success(`Collaboration initiated: ${from} -> ${to}`);
 
-                    msg.status = "PROCESSED";
-                }
+                        msg.status = "PROCESSED";
+                    }
 
-                applyBatchStatusUpdates(statusChanges);
+                    applyBatchStatusUpdates(statusChanges);
 
-                const archiveDir = path.join(messagesDir, "archive");
-                
-                for (const file of Object.keys(fileMessagesMap)) {
-                    const filePath = path.join(messagesDir, file);
-                    const msgs = fileMessagesMap[file];
-                    
-                    const activeMsgs = msgs.filter(m => m.status !== "PROCESSED");
-                    const processedMsgs = msgs.filter(m => m.status === "PROCESSED");
+                    const archiveDir = path.join(messagesDir, "archive");
                     
-                    try {
-                        if (activeMsgs.length > 0) {
-                            const updatedContent = activeMsgs.map(m => JSON.stringify(m)).join("\n") + "\n";
-                            writeTextFile(filePath, updatedContent);
-                        } else if (fs.existsSync(filePath)) {
-                            writeTextFile(filePath, "");
-                        }
+                    for (const file of Object.keys(fileMessagesMap)) {
+                        const filePath = path.join(messagesDir, file);
+                        const msgs = fileMessagesMap[file];
+                        
+                        const activeMsgs = msgs.filter(m => m.status !== "PROCESSED");
+                        const processedMsgs = msgs.filter(m => m.status === "PROCESSED");
+                        
+                        try {
+                            if (activeMsgs.length > 0) {
+                                const updatedContent = activeMsgs.map(m => JSON.stringify(m)).join("\n") + "\n";
+                                writeTextFile(filePath, updatedContent);
+                            } else if (fs.existsSync(filePath)) {
+                                writeTextFile(filePath, "");
+                            }
 
-                        if (processedMsgs.length > 0) {
-                            if (!fs.existsSync(archiveDir)) {
-                                fs.mkdirSync(archiveDir, { recursive: true });
+                            if (processedMsgs.length > 0) {
+                                if (!fs.existsSync(archiveDir)) {
+                                    fs.mkdirSync(archiveDir, { recursive: true });
+                                }
+                                const agentName = file.replace(".json", "");
+                                const archivePath = path.join(archiveDir, `${agentName}_archive.json`);
+                                const archiveContent = processedMsgs.map(m => JSON.stringify(m)).join("\n") + "\n";
+                                appendFile(archivePath, archiveContent);
+                                UI.success(`Archived ${processedMsgs.length} messages for @${agentName}`);
                             }
-                            const agentName = file.replace(".json", "");
-                            const archivePath = path.join(archiveDir, `${agentName}_archive.json`);
-                            const archiveContent = processedMsgs.map(m => JSON.stringify(m)).join("\n") + "\n";
-                            appendFile(archivePath, archiveContent);
-                            UI.success(`Archived ${processedMsgs.length} messages for @${agentName}`);
+                        } catch (err) {
+                            UI.error(`Error occurred while updating and archiving the message file ${file}.`);
+                            logger.debug(`Failed to update and archive message file ${file}`, err);
                         }
-                    } catch (err) {
-                        UI.error(`Error occurred while updating and archiving the message file ${file}.`);
-                        logger.debug(`Failed to update and archive message file ${file}`, err);
                     }
                 }
             }
+        } catch (globalLoopErr) {
+            UI.error(`⚠️  Critical error in Hermes orchestration loop: ${(globalLoopErr as Error).message}`);
+            logger.debug("Hermes global loop failure", globalLoopErr);
         }
 
         // Prevent 100% CPU and provide breathing room for I/O
@@ -223,6 +243,7 @@ export async function sendMessage(args: {
     traceId: string;
     parentId?: string;
     priority?: "HIGH" | "NORMAL" | "LOW";
+    requiresApproval?: boolean;
 }) {
     const frameworkDir = getFrameworkDir();
     const messagesDir = path.join(frameworkDir, "messages");
@@ -274,11 +295,14 @@ export async function sendMessage(args: {
 
     try {
         const defaultPriority = (args.category === "ALERT" || args.category === "ACTION") ? "HIGH" : "NORMAL";
+        const requiresApproval = args.requiresApproval !== undefined ? args.requiresApproval : (args.category === "ALERT" || args.category === "ACTION");
+
         const message: HermesMessage = {
             timestamp: new Date().toISOString(),
             priority: args.priority || defaultPriority,
             ...args,
-            status: "PENDING"
+            status: "PENDING",
+            requiresApproval: requiresApproval,
         };
         
         appendFile(messagePath, JSON.stringify(message) + "\n");

package/src/cli/utils/fs.ts

@@ -8,7 +8,7 @@ import { ensureDir, writeTextFile, writeJsonFile, appendFile } from "../../share
 
 export { ensureDir, writeTextFile, writeJsonFile, appendFile };
 
-export function updateGitIgnore(targetPath: string, frameworkDir = ".gemini", dryRun = false): void {
+export function updateGitIgnore(targetPath: string, frameworkDir = ".enderun", dryRun = false): void {
     const IGNORE_LINES = [
         "# Agent Enderun",
         `${frameworkDir}/logs/*.json`,

package/src/cli/utils/memory.ts

@@ -5,9 +5,13 @@ import { logger } from "../../shared/logger.js";
 import { ensureDir, writeTextFile, writeJsonFile } from "../../shared/fs.js";
 import { StateSchema, AgentStatusSchema, TaskSchema } from "./schemas.js";
 import type { TraceID } from "../../shared/types.js";
+import {
+    FRAMEWORK,
+    FRAMEWORK_DIR_CANDIDATES,
+    MCP,
+} from "../../shared/constants.js";
 
 export { generateULID } from "./time.js";
-export { FRAMEWORK_DIR_CANDIDATES } from "../adapters/index.js";
 
 const CWD = process.cwd();
 const HOME = os.homedir();
@@ -28,9 +32,24 @@ function findFrameworkDir(basePath: string): string | null {
     return null;
 }
 
+export function isFrameworkDevelopmentRepo(): boolean {
+    try {
+        const pkgPath = path.join(CWD, "package.json");
+        if (fs.existsSync(pkgPath)) {
+            const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+            if (pkg.name === "agent-enderun") {
+                return true;
+            }
+        }
+    } catch (err) {
+        logger.debug("Failed to read package.json in isFrameworkDevelopmentRepo", err);
+    }
+    return false;
+}
+
 export function getLocalFrameworkDir(): string {
     const localDir = findFrameworkDir(CWD);
-    return localDir || path.join(CWD, ".gemini");
+    return localDir || path.join(CWD, FRAMEWORK.CORE_DIR);
 }
 
 export function getConfigDir(): string {
@@ -38,17 +57,23 @@ export function getConfigDir(): string {
     if (localDir) return localDir;
 
     // Check for standard local directories if package.json doesn't specify
-    const localCandidates = [".enderun", ".gemini", ".claude", ".cursor", ".antigravity", ".agent"];
+    const localCandidates = [...FRAMEWORK_DIR_CANDIDATES, ".agent"] as string[];
     for (const cand of localCandidates) {
         const p = path.join(CWD, cand);
         if (fs.existsSync(p)) return p;
     }
 
-    return path.join(HOME, ".gemini");
+    // In dev repo, don't fall back to global dir. Point to local default.
+    if (isFrameworkDevelopmentRepo()) {
+        return path.join(CWD, FRAMEWORK.CORE_DIR);
+    }
+
+    return path.join(HOME, FRAMEWORK.CORE_DIR);
 }
 
 export function getFrameworkDir(): string {
-    if (process.env.ENDERUN_TEST_DIR) return process.env.ENDERUN_TEST_DIR;
+    const testDir = process.env[MCP.TEST_DIR_ENV];
+    if (testDir) return testDir;
     return getConfigDir();
 }
 
@@ -105,7 +130,7 @@ export function readActiveTraceId(memoryContent: string): string | null {
     try {
         const state = JSON.parse(memoryContent);
         return state.traceId || null;
-    } catch {
+    } catch (_e) { /* ignore */
         return null;
     }
 }
@@ -254,7 +279,7 @@ export function acquireMemoryLock(lockPath: string): boolean {
                     fs.writeFileSync(lockPath, String(Date.now()), { flag: "wx" });
                     return true;
                 }
-            } catch {
+            } catch (_e) { /* ignore */
                 // Ignore
             }
         }

package/src/modules/adapters/definitions.ts

@@ -3,6 +3,7 @@ import type { AdapterConfig, AdapterId } from "./types.js";
 import { addMcpServerToClaude, findClaudeConfigPath } from "../../cli/utils/claude.js";
 import { writeJsonFile } from "../../shared/fs.js";
 import { registerGlobalAntigravityPlugins } from "./shared.js";
+import { unifiedAdapterPath, UNIFIED_ADAPTER_SLUG } from "../../shared/constants.js";
 
 /**
  * Mapped Adapter Configurations
@@ -16,7 +17,7 @@ export const ADAPTER_CONFIGS: Record<AdapterId, AdapterConfig> = {
         role: "commander",
         templateDir: ".enderun",
         nestedDirs: ["agents", "rules"],
-        agentsDir: ".gemini/agents",
+        agentsDir: ".gemini/agents", // Use unified path
         agentsExt: ".md"
     },
     claude: {
@@ -38,7 +39,7 @@ export const ADAPTER_CONFIGS: Record<AdapterId, AdapterConfig> = {
         role: "researcher",
         templateDir: ".enderun",
         nestedDirs: ["rules"],
-        agentsDir: ".grok",
+        agentsDir: ".grok/agents",
         agentsExt: ".md"
     },
     cursor: {
@@ -60,7 +61,7 @@ export const ADAPTER_CONFIGS: Record<AdapterId, AdapterConfig> = {
         role: "implementer",
         templateDir: ".enderun",
         nestedDirs: ["skills", "rules", "instructions"],
-        agentsDir: ".agents/skills",
+        agentsDir: ".agents/instructions",
         agentsExt: ".md"
     },
     "antigravity-cli": {

package/src/modules/agents/definitions.ts

@@ -6,6 +6,7 @@
 import fs from "fs";
 import path from "path";
 import { AgentDefinition } from "./types.js";
+import { getPackageRoot } from "../../cli/utils/pkg.js";
 
 // Import individual agent definitions
 import { manager } from "./registry/manager.js";
@@ -124,7 +125,7 @@ function resolveModel(
 }
 
 /** Build a flat system prompt string from structured instructions */
-function buildSystemPrompt(ag: AgentDefinition, baseKnowledgeDir: string = path.join(process.cwd(), "templates/standards")): string {
+function buildSystemPrompt(ag: AgentDefinition, baseKnowledgeDir: string = path.join(getPackageRoot(), "templates/standards")): string {
     const lines: string[] = [
         "# Identity",
         ag.instructions.identity,

package/src/modules/agents/registry/architect.ts

@@ -42,5 +42,6 @@ export const architect: AgentDefinition = {
             "CONTRACT STABILITY: Validate 'contract.version.json' consistency before and after every schema change.",
             "GOVERNANCE READ: Always read architecture governance docs before making design decisions.",
         ],
+        knowledgeFiles: ["architecture-standards.md"],
     },
 };

package/src/modules/agents/registry/backend.ts

@@ -7,8 +7,8 @@ export const backend: AgentDefinition = {
     displayName: "Backend Specialist",
     role: "Backend Development",
     description:
-  "Server logic, Databases, and API implementation specialist. " +
-  "Owns the Database Management & Migrations discipline.",
+  "Server logic and API implementation specialist. " +
+  "Owns the API contracts and business logic implementation.",
     capability: 9,
     tier: "core",
     tags: ["core", "logic"],
@@ -42,6 +42,6 @@ export const backend: AgentDefinition = {
             "HIGH-RISK OPS: Refuse User/Role management, bulk deletes, schema alterations, and billing changes autonomously. " +
       "Return a standard refusal, send a managerApproval request to @manager, and shift to WAITING status.",
         ],
-        knowledgeFiles: ["skills/database_management.md"],
+        knowledgeFiles: ["crud-governance.md"],
     },
 };

package/src/modules/agents/registry/database.ts

@@ -7,8 +7,8 @@ export const database: AgentDefinition = {
     displayName: "Database Specialist",
     role: "Data Management",
     description:
-  "SQL Schema design and Query Optimization specialist. " +
-  "Manages data as the empire's treasury — secure and optimized.",
+  "SQL Schema design, migration, and query optimization specialist. " +
+  "Owns the database schema, migrations, and data integrity.",
     capability: 9,
     tier: "core",
     tags: ["core", "data"],
@@ -37,6 +37,6 @@ export const database: AgentDefinition = {
             "DETERMINISTIC MIGRATIONS: Every migration must be reversible and produce identical results across environments.",
             "PERFORMANCE FIRST: Design indexes proactively — never retroactively after a performance incident.",
         ],
-        knowledgeFiles: ["skills/database_management.md"],
+        knowledgeFiles: ["performance-standards.md", "quality-standards.md"],
     },
 };

package/src/modules/agents/registry/devops.ts

@@ -37,6 +37,6 @@ export const devops: AgentDefinition = {
             "ENVIRONMENT ISOLATION: All variables managed via '.env' — hardcoded secrets trigger immediate escalation.",
             "NO UNTRACKED DEPLOYMENTS: Every deployment must be declared, versioned, and traceable.",
         ],
-        knowledgeFiles: ["skills/devops_infrastructure.md"],
+        knowledgeFiles: ["deployment-standards.md"],
     },
 };

package/src/modules/agents/registry/quality.ts

@@ -21,6 +21,7 @@ export const quality: AgentDefinition = {
         "read_project_memory",
         "get_memory_insights",
         "run_tests",
+        "check_lint",
         "log_agent_action",
         "send_agent_message",
     ],