@opengoat/core 2026.2.9 → 2026.2.14

package/dist/core/agents/application/agent.service.js

@@ -1,5 +1,5 @@
-import { isDefaultAgentId, normalizeAgentId } from "../../domain/agent-id.js";
-import { renderAgentsIndex, renderInternalAgentConfig, renderInternalAgentMemoryMarkdown, renderInternalAgentState, renderWorkspaceAgentsMarkdown, renderWorkspaceBootstrapMarkdown, renderWorkspaceContextMarkdown, renderWorkspaceHeartbeatMarkdown, renderWorkspaceIdentityMarkdown, renderDefaultOrchestratorSkillMarkdown, renderWorkspaceSoulMarkdown, renderWorkspaceToolsMarkdown, renderWorkspaceUserMarkdown, renderWorkspaceMetadata } from "../../templates/default-templates.js";
+import { DEFAULT_AGENT_ID, isDefaultAgentId, normalizeAgentId, } from "../../domain/agent-id.js";
+import { renderAgentsIndex, renderBoardIndividualSkillMarkdown, renderBoardManagerSkillMarkdown, renderCeoBootstrapMarkdown, renderCeoRoleMarkdown, renderInternalAgentConfig, resolveAgentRole, } from "../../templates/default-templates.js";
 export class AgentService {
     fileSystem;
     pathPort;
@@ -20,41 +20,17 @@ export class AgentService {
         }
         return { id, displayName };
     }
-    async ensureAgent(paths, identity) {
+    async ensureAgent(paths, identity, options = {}) {
         const workspaceDir = this.pathPort.join(paths.workspacesDir, identity.id);
-        const workspaceSkillsDir = this.pathPort.join(workspaceDir, "skills");
         const internalConfigDir = this.pathPort.join(paths.agentsDir, identity.id);
-        const sessionsDir = this.pathPort.join(internalConfigDir, "sessions");
+        const configPath = this.pathPort.join(internalConfigDir, "config.json");
+        const templateOptions = toAgentTemplateOptions(identity.id, options);
         const createdPaths = [];
         const skippedPaths = [];
-        await this.ensureDirectory(workspaceDir, createdPaths, skippedPaths);
-        await this.ensureDirectory(workspaceSkillsDir, createdPaths, skippedPaths);
+        const configExisted = await this.fileSystem.exists(configPath);
         await this.ensureDirectory(internalConfigDir, createdPaths, skippedPaths);
-        await this.ensureDirectory(sessionsDir, createdPaths, skippedPaths);
-        const shouldCreateBootstrapFile = await this.isBrandNewWorkspace(workspaceDir);
-        await this.writeJsonIfMissing(this.pathPort.join(workspaceDir, "workspace.json"), renderWorkspaceMetadata(identity), createdPaths, skippedPaths);
-        await this.writeMarkdownIfMissing(this.pathPort.join(workspaceDir, "AGENTS.md"), renderWorkspaceAgentsMarkdown(identity), createdPaths, skippedPaths);
-        await this.writeMarkdownIfMissing(this.pathPort.join(workspaceDir, "CONTEXT.md"), renderWorkspaceContextMarkdown(identity), createdPaths, skippedPaths);
-        await this.writeMarkdownIfMissing(this.pathPort.join(workspaceDir, "SOUL.md"), renderWorkspaceSoulMarkdown(identity), createdPaths, skippedPaths);
-        await this.writeMarkdownIfMissing(this.pathPort.join(workspaceDir, "TOOLS.md"), renderWorkspaceToolsMarkdown(), createdPaths, skippedPaths);
-        await this.writeMarkdownIfMissing(this.pathPort.join(workspaceDir, "IDENTITY.md"), renderWorkspaceIdentityMarkdown(identity), createdPaths, skippedPaths);
-        await this.writeMarkdownIfMissing(this.pathPort.join(workspaceDir, "USER.md"), renderWorkspaceUserMarkdown(), createdPaths, skippedPaths);
-        await this.writeMarkdownIfMissing(this.pathPort.join(workspaceDir, "HEARTBEAT.md"), renderWorkspaceHeartbeatMarkdown(), createdPaths, skippedPaths);
-        if (shouldCreateBootstrapFile) {
-            await this.writeMarkdownIfMissing(this.pathPort.join(workspaceDir, "BOOTSTRAP.md"), renderWorkspaceBootstrapMarkdown(identity), createdPaths, skippedPaths);
-        }
-        if (isDefaultAgentId(identity.id)) {
-            const orchestratorSkillDir = this.pathPort.join(workspaceSkillsDir, "opengoat-skill");
-            await this.ensureDirectory(orchestratorSkillDir, createdPaths, skippedPaths);
-            await this.writeMarkdownIfMissing(this.pathPort.join(orchestratorSkillDir, "SKILL.md"), renderDefaultOrchestratorSkillMarkdown(), createdPaths, skippedPaths);
-        }
-        await this.writeJsonIfMissing(this.pathPort.join(internalConfigDir, "config.json"), renderInternalAgentConfig(identity), createdPaths, skippedPaths);
-        await this.writeJsonIfMissing(this.pathPort.join(internalConfigDir, "state.json"), renderInternalAgentState(), createdPaths, skippedPaths);
-        await this.writeMarkdownIfMissing(this.pathPort.join(internalConfigDir, "memory.md"), renderInternalAgentMemoryMarkdown(identity), createdPaths, skippedPaths);
-        await this.writeJsonIfMissing(this.pathPort.join(sessionsDir, "sessions.json"), {
-            schemaVersion: 1,
-            sessions: {}
-        }, createdPaths, skippedPaths);
+        await this.writeJsonIfMissing(configPath, renderInternalAgentConfig(identity, templateOptions), createdPaths, skippedPaths);
+        const role = await this.readAgentRole(paths, identity.id);
         const existingIndex = await this.readJsonIfPresent(paths.agentsIndexJsonPath);
         const agents = dedupe([...(existingIndex?.agents ?? []), identity.id]);
         const nextIndex = renderAgentsIndex(this.nowIso(), agents);
@@ -62,37 +38,183 @@ export class AgentService {
         return {
             agent: {
                 ...identity,
+                role,
                 workspaceDir,
-                internalConfigDir
+                internalConfigDir,
             },
+            alreadyExisted: configExisted,
             createdPaths,
-            skippedPaths
+            skippedPaths,
         };
     }
     async listAgents(paths) {
-        const ids = await this.fileSystem.listDirectories(paths.workspacesDir);
+        const ids = await this.fileSystem.listDirectories(paths.agentsDir);
         const descriptors = [];
         for (const id of ids) {
             const workspaceDir = this.pathPort.join(paths.workspacesDir, id);
             const internalConfigDir = this.pathPort.join(paths.agentsDir, id);
-            const metadataPath = this.pathPort.join(workspaceDir, "workspace.json");
-            const metadata = await this.readJsonIfPresent(metadataPath);
+            const displayName = await this.readAgentDisplayName(paths, id);
+            const role = await this.readAgentRole(paths, id);
             descriptors.push({
                 id,
-                displayName: metadata?.displayName ?? id,
+                displayName,
+                role,
                 workspaceDir,
-                internalConfigDir
+                internalConfigDir,
             });
         }
         return descriptors.sort((left, right) => left.id.localeCompare(right.id));
     }
+    async ensureCeoWorkspaceBootstrap(paths) {
+        const displayName = await this.readAgentDisplayName(paths, DEFAULT_AGENT_ID);
+        const role = await this.readAgentRole(paths, DEFAULT_AGENT_ID);
+        return this.ensureAgentWorkspaceBootstrap(paths, {
+            agentId: DEFAULT_AGENT_ID,
+            displayName,
+            role,
+        });
+    }
+    async ensureAgentWorkspaceBootstrap(paths, input) {
+        const normalizedAgentId = normalizeAgentId(input.agentId);
+        if (!normalizedAgentId) {
+            throw new Error("Agent id cannot be empty.");
+        }
+        const workspaceDir = this.pathPort.join(paths.workspacesDir, normalizedAgentId);
+        const agentsPath = this.pathPort.join(workspaceDir, "AGENTS.md");
+        const rolePath = this.pathPort.join(workspaceDir, "ROLE.md");
+        const bootstrapPath = this.pathPort.join(workspaceDir, "BOOTSTRAP.md");
+        const createdPaths = [];
+        const skippedPaths = [];
+        const removedPaths = [];
+        await this.ensureDirectory(workspaceDir, createdPaths, skippedPaths);
+        await this.rewriteAgentsMarkdown(agentsPath, normalizedAgentId, createdPaths, skippedPaths);
+        await this.writeRoleMarkdown(rolePath, {
+            agentId: normalizedAgentId,
+            displayName: input.displayName.trim() || normalizedAgentId,
+            role: input.role.trim(),
+        }, createdPaths, skippedPaths);
+        const workspaceSkillSync = await this.ensureAgentWorkspaceRoleSkills(paths, normalizedAgentId);
+        createdPaths.push(...workspaceSkillSync.createdPaths);
+        skippedPaths.push(...workspaceSkillSync.skippedPaths);
+        removedPaths.push(...workspaceSkillSync.removedPaths);
+        if (isDefaultAgentId(normalizedAgentId)) {
+            await this.writeBootstrapMarkdown(bootstrapPath, createdPaths, skippedPaths);
+        }
+        else if (await this.fileSystem.exists(bootstrapPath)) {
+            await this.fileSystem.removeDir(bootstrapPath);
+            removedPaths.push(bootstrapPath);
+        }
+        else {
+            skippedPaths.push(bootstrapPath);
+        }
+        return {
+            createdPaths,
+            skippedPaths,
+            removedPaths,
+        };
+    }
+    async ensureAgentWorkspaceRoleSkills(paths, agentId) {
+        const normalizedAgentId = normalizeAgentId(agentId);
+        if (!normalizedAgentId) {
+            throw new Error("Agent id cannot be empty.");
+        }
+        const type = await this.readAgentType(paths, normalizedAgentId);
+        const requiredSkillIds = type === "manager" ? MANAGER_ROLE_SKILLS : INDIVIDUAL_ROLE_SKILLS;
+        const managedRoleSkillIds = [
+            ...new Set([
+                ...MANAGER_ROLE_SKILLS,
+                ...INDIVIDUAL_ROLE_SKILLS,
+                ...LEGACY_MANAGER_ROLE_SKILLS,
+                ...LEGACY_INDIVIDUAL_ROLE_SKILLS,
+            ]),
+        ];
+        const workspaceDir = this.pathPort.join(paths.workspacesDir, normalizedAgentId);
+        const skillsDir = this.pathPort.join(workspaceDir, "skills");
+        const createdPaths = [];
+        const skippedPaths = [];
+        const removedPaths = [];
+        await this.ensureDirectory(workspaceDir, createdPaths, skippedPaths);
+        await this.ensureDirectory(skillsDir, createdPaths, skippedPaths);
+        for (const skillId of requiredSkillIds) {
+            const skillDir = this.pathPort.join(skillsDir, skillId);
+            const skillFile = this.pathPort.join(skillDir, "SKILL.md");
+            await this.ensureDirectory(skillDir, createdPaths, skippedPaths);
+            await this.writeMarkdown(skillFile, this.renderWorkspaceSkill(skillId), createdPaths, skippedPaths, { overwrite: true });
+        }
+        for (const skillId of managedRoleSkillIds) {
+            if (requiredSkillIds.includes(skillId)) {
+                continue;
+            }
+            const staleSkillDir = this.pathPort.join(skillsDir, skillId);
+            if (await this.fileSystem.exists(staleSkillDir)) {
+                await this.fileSystem.removeDir(staleSkillDir);
+                removedPaths.push(staleSkillDir);
+            }
+            else {
+                skippedPaths.push(staleSkillDir);
+            }
+        }
+        return {
+            createdPaths,
+            skippedPaths,
+            removedPaths,
+        };
+    }
+    async syncAgentRoleAssignments(paths, agentId) {
+        const normalizedAgentId = normalizeAgentId(agentId);
+        if (!normalizedAgentId) {
+            throw new Error("Agent id cannot be empty.");
+        }
+        const configPath = this.pathPort.join(paths.agentsDir, normalizedAgentId, "config.json");
+        const config = await this.readJsonIfPresent(configPath);
+        if (!config) {
+            return {
+                updatedPaths: [],
+                skippedPaths: [configPath],
+            };
+        }
+        const type = await this.readAgentType(paths, normalizedAgentId);
+        const requiredSkillIds = type === "manager" ? MANAGER_ROLE_SKILLS : INDIVIDUAL_ROLE_SKILLS;
+        const roleSkillIds = new Set([
+            ...MANAGER_ROLE_SKILLS,
+            ...INDIVIDUAL_ROLE_SKILLS,
+            ...LEGACY_MANAGER_ROLE_SKILLS,
+            ...LEGACY_INDIVIDUAL_ROLE_SKILLS,
+        ]);
+        const runtimeRecord = toObject(config.runtime);
+        const skillsRecord = toObject(runtimeRecord.skills);
+        const assignedRaw = Array.isArray(skillsRecord.assigned)
+            ? skillsRecord.assigned
+            : [];
+        const assigned = [
+            ...new Set(assignedRaw
+                .map((value) => String(value).trim().toLowerCase())
+                .filter(Boolean)),
+        ];
+        const preserved = assigned.filter((skillId) => !roleSkillIds.has(skillId));
+        const nextAssigned = [...new Set([...preserved, ...requiredSkillIds])];
+        if (sameStringArray(assigned, nextAssigned)) {
+            return {
+                updatedPaths: [],
+                skippedPaths: [configPath],
+            };
+        }
+        skillsRecord.assigned = nextAssigned;
+        runtimeRecord.skills = skillsRecord;
+        config.runtime = runtimeRecord;
+        await this.fileSystem.writeFile(configPath, toJson(config));
+        return {
+            updatedPaths: [configPath],
+            skippedPaths: [],
+        };
+    }
     async removeAgent(paths, rawAgentId) {
         const agentId = normalizeAgentId(rawAgentId);
         if (!agentId) {
             throw new Error("Agent id cannot be empty.");
         }
         if (isDefaultAgentId(agentId)) {
-            throw new Error("Cannot delete orchestrator. It is the immutable default entry agent.");
+            throw new Error("Cannot delete ceo. It is the immutable default entry agent.");
         }
         const workspaceDir = this.pathPort.join(paths.workspacesDir, agentId);
         const internalConfigDir = this.pathPort.join(paths.agentsDir, agentId);
@@ -124,21 +246,59 @@ export class AgentService {
             agentId,
             existed: workspaceExists || internalConfigExists,
             removedPaths,
-            skippedPaths
+            skippedPaths,
         };
     }
-    async isBrandNewWorkspace(workspaceDir) {
-        const firstRunFiles = [
-            "AGENTS.md",
-            "CONTEXT.md",
-            "SOUL.md",
-            "TOOLS.md",
-            "IDENTITY.md",
-            "USER.md",
-            "HEARTBEAT.md"
-        ];
-        const existence = await Promise.all(firstRunFiles.map((fileName) => this.fileSystem.exists(this.pathPort.join(workspaceDir, fileName))));
-        return existence.every((value) => !value);
+    async setAgentManager(paths, rawAgentId, rawReportsTo) {
+        const agentId = normalizeAgentId(rawAgentId);
+        if (!agentId) {
+            throw new Error("Agent id cannot be empty.");
+        }
+        const explicitReportsTo = rawReportsTo === null || rawReportsTo === undefined
+            ? null
+            : normalizeAgentId(rawReportsTo);
+        if (explicitReportsTo === agentId) {
+            throw new Error(`Agent "${agentId}" cannot report to itself.`);
+        }
+        if (isDefaultAgentId(agentId) && explicitReportsTo) {
+            throw new Error("ceo is the head of the organization and cannot report to another agent.");
+        }
+        const reportsTo = resolveReportsTo(agentId, rawReportsTo);
+        const knownAgents = await this.fileSystem.listDirectories(paths.agentsDir);
+        if (!knownAgents.includes(agentId)) {
+            throw new Error(`Agent "${agentId}" does not exist.`);
+        }
+        if (reportsTo && !knownAgents.includes(reportsTo)) {
+            throw new Error(`Manager "${reportsTo}" does not exist.`);
+        }
+        await this.assertNoReportingCycle(paths, agentId, reportsTo, knownAgents);
+        const configPath = this.pathPort.join(paths.agentsDir, agentId, "config.json");
+        const displayName = await this.readAgentDisplayName(paths, agentId);
+        const role = await this.readAgentRole(paths, agentId);
+        const existingConfig = (await this.readJsonIfPresent(configPath)) ??
+            renderInternalAgentConfig({ id: agentId, displayName, role });
+        const existingOrganization = toObject(existingConfig.organization);
+        const previousReportsTo = normalizeReportsToValue(existingOrganization.reportsTo);
+        const nextOrganization = {
+            ...existingOrganization,
+            reportsTo,
+        };
+        if (typeof existingOrganization.type !== "string") {
+            nextOrganization.type = isDefaultAgentId(agentId)
+                ? "manager"
+                : "individual";
+        }
+        const nextConfig = {
+            ...existingConfig,
+            organization: nextOrganization,
+        };
+        await this.fileSystem.writeFile(configPath, toJson(nextConfig));
+        return {
+            agentId,
+            previousReportsTo: previousReportsTo ?? null,
+            reportsTo,
+            updatedPaths: [configPath],
+        };
     }
     async ensureDirectory(directoryPath, createdPaths, skippedPaths) {
         const existed = await this.fileSystem.exists(directoryPath);
@@ -158,16 +318,43 @@ export class AgentService {
         await this.fileSystem.writeFile(filePath, toJson(payload));
         createdPaths.push(filePath);
     }
-    async writeMarkdownIfMissing(filePath, content, createdPaths, skippedPaths) {
+    async writeMarkdown(filePath, content, createdPaths, skippedPaths, options = {}) {
         const exists = await this.fileSystem.exists(filePath);
-        if (exists) {
+        if (exists && !options.overwrite) {
             skippedPaths.push(filePath);
             return;
         }
         const markdown = content.endsWith("\n") ? content : `${content}\n`;
         await this.fileSystem.writeFile(filePath, markdown);
+        if (exists) {
+            skippedPaths.push(filePath);
+            return;
+        }
         createdPaths.push(filePath);
     }
+    async rewriteAgentsMarkdown(filePath, agentId, createdPaths, skippedPaths) {
+        const exists = await this.fileSystem.exists(filePath);
+        if (!exists) {
+            skippedPaths.push(filePath);
+            return;
+        }
+        const source = await this.fileSystem.readFile(filePath);
+        const next = normalizeAgentsMarkdown(source, {
+            keepFirstRunSection: isDefaultAgentId(agentId),
+        });
+        if (source === next) {
+            skippedPaths.push(filePath);
+            return;
+        }
+        await this.fileSystem.writeFile(filePath, next);
+        skippedPaths.push(filePath);
+    }
+    async writeRoleMarkdown(filePath, profile, createdPaths, skippedPaths) {
+        await this.writeMarkdown(filePath, renderRoleMarkdown(profile), createdPaths, skippedPaths, { overwrite: true });
+    }
+    async writeBootstrapMarkdown(filePath, createdPaths, skippedPaths) {
+        await this.writeMarkdown(filePath, renderCeoBootstrapMarkdown(), createdPaths, skippedPaths, { overwrite: true });
+    }
     async readJsonIfPresent(filePath) {
         const exists = await this.fileSystem.exists(filePath);
         if (!exists) {
@@ -181,6 +368,140 @@ export class AgentService {
             return null;
         }
     }
+    async readAgentDisplayName(paths, agentId) {
+        const configPath = this.pathPort.join(paths.agentsDir, agentId, "config.json");
+        const config = await this.readJsonIfPresent(configPath);
+        return config?.displayName?.trim() || agentId;
+    }
+    async readAgentRole(paths, agentId) {
+        const configPath = this.pathPort.join(paths.agentsDir, agentId, "config.json");
+        const config = await this.readJsonIfPresent(configPath);
+        const type = config?.organization?.type ??
+            (isDefaultAgentId(agentId) ? "manager" : "individual");
+        return resolveAgentRole(agentId, type, config?.role);
+    }
+    async readAgentType(paths, agentId) {
+        const configPath = this.pathPort.join(paths.agentsDir, agentId, "config.json");
+        const config = await this.readJsonIfPresent(configPath);
+        const type = config?.organization?.type;
+        const hasDirectReportees = await this.hasDirectReportees(paths, agentId);
+        if (type === "manager") {
+            return type;
+        }
+        if (type === "individual") {
+            return hasDirectReportees ? "manager" : "individual";
+        }
+        if (isDefaultAgentId(agentId)) {
+            return "manager";
+        }
+        return hasDirectReportees ? "manager" : "individual";
+    }
+    renderWorkspaceSkill(skillId) {
+        if (skillId === "og-board-manager") {
+            return renderBoardManagerSkillMarkdown();
+        }
+        if (skillId === "og-board-individual") {
+            return renderBoardIndividualSkillMarkdown();
+        }
+        throw new Error(`Unsupported workspace skill id: ${skillId}`);
+    }
+    async assertNoReportingCycle(paths, agentId, reportsTo, knownAgentIds) {
+        if (!reportsTo) {
+            return;
+        }
+        const reportsToByAgent = new Map();
+        await Promise.all(knownAgentIds.map(async (candidateAgentId) => {
+            reportsToByAgent.set(candidateAgentId, await this.readAgentReportsTo(paths, candidateAgentId));
+        }));
+        reportsToByAgent.set(agentId, reportsTo);
+        const visited = new Set([agentId]);
+        let cursor = reportsTo;
+        while (cursor) {
+            if (visited.has(cursor)) {
+                throw new Error(`Cannot set "${agentId}" to report to "${reportsTo}" because it would create a cycle.`);
+            }
+            visited.add(cursor);
+            cursor = reportsToByAgent.get(cursor) ?? null;
+        }
+    }
+    async readAgentReportsTo(paths, agentId) {
+        const configPath = this.pathPort.join(paths.agentsDir, agentId, "config.json");
+        const config = await this.readJsonIfPresent(configPath);
+        const reportsTo = normalizeReportsToValue(config?.organization?.reportsTo);
+        if (isDefaultAgentId(agentId)) {
+            return null;
+        }
+        if (reportsTo === undefined) {
+            return DEFAULT_AGENT_ID;
+        }
+        return reportsTo;
+    }
+    async hasDirectReportees(paths, managerAgentId) {
+        const normalizedManagerId = normalizeAgentId(managerAgentId);
+        if (!normalizedManagerId) {
+            return false;
+        }
+        const knownAgents = await this.fileSystem.listDirectories(paths.agentsDir);
+        for (const agentId of knownAgents) {
+            if (agentId === normalizedManagerId) {
+                continue;
+            }
+            const reportsTo = await this.readAgentReportsTo(paths, agentId);
+            if (reportsTo === normalizedManagerId) {
+                return true;
+            }
+        }
+        return false;
+    }
+}
+const MANAGER_ROLE_SKILLS = ["og-board-manager"];
+const INDIVIDUAL_ROLE_SKILLS = ["og-board-individual"];
+const LEGACY_MANAGER_ROLE_SKILLS = ["board-manager"];
+const LEGACY_INDIVIDUAL_ROLE_SKILLS = ["board-individual"];
+function toAgentTemplateOptions(agentId, options) {
+    const type = options.type ?? (isDefaultAgentId(agentId) ? "manager" : "individual");
+    const reportsTo = resolveReportsTo(agentId, options.reportsTo);
+    const providedSkills = options.skills ?? [];
+    const roleSkillIds = new Set([
+        ...MANAGER_ROLE_SKILLS,
+        ...INDIVIDUAL_ROLE_SKILLS,
+        ...LEGACY_MANAGER_ROLE_SKILLS,
+        ...LEGACY_INDIVIDUAL_ROLE_SKILLS,
+    ]);
+    const skills = dedupe(providedSkills.filter((skillId) => !roleSkillIds.has(skillId)));
+    const role = resolveAgentRole(agentId, type, options.role);
+    return {
+        type,
+        reportsTo,
+        skills,
+        role,
+    };
+}
+function resolveReportsTo(agentId, reportsTo) {
+    if (isDefaultAgentId(agentId)) {
+        return null;
+    }
+    if (reportsTo === null || reportsTo === undefined) {
+        return DEFAULT_AGENT_ID;
+    }
+    const normalized = normalizeAgentId(reportsTo);
+    if (!normalized || normalized === agentId) {
+        return DEFAULT_AGENT_ID;
+    }
+    return normalized;
+}
+function normalizeReportsToValue(value) {
+    if (value === null) {
+        return null;
+    }
+    if (typeof value !== "string") {
+        return undefined;
+    }
+    const normalized = normalizeAgentId(value);
+    if (!normalized) {
+        return null;
+    }
+    return normalized;
 }
 function dedupe(values) {
     return [...new Set(values)].sort((left, right) => left.localeCompare(right));
@@ -188,4 +509,104 @@ function dedupe(values) {
 function toJson(payload) {
     return `${JSON.stringify(payload, null, 2)}\n`;
 }
+function toObject(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return {};
+    }
+    return value;
+}
+function sameStringArray(left, right) {
+    if (left.length !== right.length) {
+        return false;
+    }
+    return left.every((value, index) => value === right[index]);
+}
+function normalizeAgentsMarkdown(markdown, options) {
+    const withFirstRunApplied = options.keepFirstRunSection
+        ? markdown
+        : rewriteSecondLevelSection(markdown, /^##\s+first run\s*$/i, null);
+    return rewriteSecondLevelSection(withFirstRunApplied, /^##\s+every session\s*$/i, EVERY_SESSION_SECTION_LINES);
+}
+function rewriteSecondLevelSection(markdown, headingPattern, replacementLines) {
+    const lineBreak = markdown.includes("\r\n") ? "\r\n" : "\n";
+    const lines = markdown.split(/\r?\n/);
+    const hasTrailingLineBreak = /\r?\n$/.test(markdown);
+    const kept = [];
+    let index = 0;
+    let replaced = false;
+    while (index < lines.length) {
+        const line = lines[index];
+        if (line === undefined) {
+            index += 1;
+            continue;
+        }
+        const trimmed = line.trim();
+        if (headingPattern.test(trimmed)) {
+            replaced = true;
+            if (replacementLines) {
+                kept.push(...replacementLines);
+            }
+            index += 1;
+            while (index < lines.length) {
+                const nextLine = lines[index];
+                if (nextLine !== undefined && /^##\s+/.test(nextLine.trim())) {
+                    break;
+                }
+                index += 1;
+            }
+            continue;
+        }
+        kept.push(line);
+        index += 1;
+    }
+    if (!replaced) {
+        return markdown;
+    }
+    let next = kept.join(lineBreak);
+    if (hasTrailingLineBreak && !next.endsWith(lineBreak)) {
+        next = `${next}${lineBreak}`;
+    }
+    return next;
+}
+const EVERY_SESSION_SECTION_LINES = [
+    "## Every Session",
+    "",
+    "You are part of an organization run by AI agents.",
+    "",
+    "Before doing anything else:",
+    "",
+    "1. Read `SOUL.md` — this is who you are",
+    "2. Read `ROLE.md` — this is your role in the organization",
+    "3. Read `memory/YYYY-MM-DD.md` (today + yesterday) for recent context",
+    "4. **If in MAIN SESSION**: Also read `MEMORY.md`",
+    "",
+    "Don't ask permission. Just do it.",
+    "",
+    "## The Organization",
+    "",
+    "You are part of an organization run by AI agents. You have access to the organization's context and wiki on `../../organization`",
+    "",
+];
+function renderRoleMarkdown(profile) {
+    if (isDefaultAgentId(profile.agentId)) {
+        return renderCeoRoleMarkdown();
+    }
+    return [
+        "# ROLE.md - Your position in the organization",
+        "",
+        "You are part of an organization fully run by AI agents.",
+        "",
+        `- Your id: ${profile.agentId} (agent id)`,
+        `- Your name: ${profile.displayName}`,
+        `- Role: ${profile.role}`,
+        `- For info about your level on the organiztion, run \`opengoat agent info ${profile.agentId}\`.`,
+        "- To delegate and coordinate work, use `og-*` skills.",
+        "- Organization context is available in `../../organization` - read them",
+        "- You can view and edit the wiki in `../../organization/wiki`",
+        "",
+        "---",
+        "",
+        "_This file is yours to evolve. Update it as you learn your role and responsibilities in the organization._",
+    ].join("\n");
+}
 //# sourceMappingURL=agent.service.js.map