@opengoat/core 2026.2.9 → 2026.2.13

package/dist/core/templates/assets/skills/og-board-individual/SKILL.md

@@ -0,0 +1,148 @@
+---
+name: og-board-individual
+description: "Use when you need to work with tasks: view tasks, list tasks, update task status, add blockers, artifacts, and worklogs."
+metadata:
+  version: "1.0.0"
+---
+
+# Board Individual
+
+Use this skill to read and update tasks assigned to you. Follow your manager’s instructions for what to do, and use the commands below to keep task state accurate.
+
+## Quick start
+
+Replace `<me>` with your agent id.
+
+```bash
+opengoat agent info <me>
+```
+
+You will typically have one or more `<task-id>` values to update.
+
+## Relevant commands
+
+```bash
+opengoat task list [--as <me>] [--json]
+opengoat task show <task-id> [--json]
+
+opengoat task status <task-id> <todo|doing|blocked|pending|done> [--reason <reason>] [--as <me>]
+
+opengoat task blocker add <task-id> <content> [--as <me>]
+opengoat task artifact add <task-id> <content> [--as <me>]
+opengoat task worklog add <task-id> <content> [--as <me>]
+```
+
+## View tasks
+
+### Show a single task
+
+```bash
+opengoat task show <task-id>
+```
+
+### List tasks
+
+List tasks owned by an agent (often: you):
+
+```bash
+opengoat task list --as <me>
+```
+
+### List tasks by status (practical approach)
+
+Use JSON output and filter locally. The JSON includes task status (`todo|doing|blocked|pending|done`).
+
+```bash
+opengoat task list --json
+```
+
+Filter examples (adjust the jq selector to match the JSON shape you see):
+
+```bash
+
+# If the JSON is an array of tasks
+
+opengoat task list --json | jq '.[] | select(.status=="doing")'
+
+# If the JSON is an object that contains a tasks array
+
+opengoat task list --json | jq '.tasks[] | select(.status=="doing")'
+```
+
+## Update task status
+
+Statuses: `todo`, `doing`, `blocked`, `pending`, `done`.
+
+```bash
+opengoat task status <task-id> <todo|doing|blocked|pending|done> [--reason "<reason>"]
+```
+
+### Reason rules
+
+- `--reason` is **mandatory** when moving to:
+  - `blocked`
+  - `pending`
+- `--reason` is optional for other statuses, but recommended when it improves clarity.
+
+Examples:
+
+```bash
+
+# Start work
+
+opengoat task status <task-id> doing
+
+# Blocked (reason required)
+
+opengoat task status <task-id> blocked --reason "Need API token from platform team"
+
+# Pending (reason required)
+
+opengoat task status <task-id> pending --reason "Waiting for review window on Friday"
+
+# Done (reason optional but useful)
+
+opengoat task status <task-id> done --reason "Merged PR #123 and deployed"
+```
+
+### Assignee override (only if you must)
+
+Some contexts require specifying an assignee context explicitly.
+
+```bash
+opengoat task status <task-id> doing --as <agent-id>
+```
+
+## Blockers, artifacts, worklogs
+
+### Add a blocker entry (recommended when blocked)
+
+Use this to capture what is blocking you and what unblocks you.
+
+```bash
+opengoat task blocker add <task-id> "Blocked by <thing>. Unblocks when <condition>." --as <me>
+```
+
+### Add an artifact (proof of work)
+
+Use this for PR links, docs, screenshots, commands run, or final outputs.
+
+```bash
+opengoat task artifact add <task-id> "PR: <link> | Docs: <link> | Output: <summary>" --as <me>
+```
+
+### Add a worklog update (progress notes)
+
+Use for concise progress updates and handoffs.
+
+```bash
+opengoat task worklog add <task-id> "Did X. Next: Y. Risk: Z." --as <me>
+```
+
+## Minimal hygiene
+
+- Keep status accurate (`todo` → `doing` → `blocked/pending/done`).
+- When moving to `blocked` or `pending`, always include a specific `--reason`.
+- When blocked, add a blocker entry that states what unblocks you.
+- When done, add at least one artifact that proves completion.
+- Use worklogs when progress is non-obvious or when handing off.

package/dist/core/templates/assets/skills/og-board-manager/SKILL.md

@@ -0,0 +1,140 @@
+---
+name: og-board-manager
+description: Use when you need to delegate, track, or review work.
+metadata:
+  version: "1.0.0"
+---
+
+# Board Manager
+
+Delegate and track work using tasks.
+
+## Allowed Actions
+
+- Create tasks for yourself.
+- Assign tasks to your direct or indirect reportees.
+- Read task state.
+- If your session has an associated project, specify the path when creating tasks.
+
+Important: replace `<me>` with your agent ID.
+
+```bash
+opengoat agent info <me>
+```
+
+## Task Commands
+
+```bash
+opengoat task list --as <me>
+opengoat task create --owner <me> --title "..." --description "..." --assign <agent-id> [--project <path>]
+opengoat task show <task-id>
+```
+
+## Standard workflow
+
+### 1. Confirm org context
+
+```bash
+opengoat agent info <me>
+```
+
+Use the output to ensure:
+
+- You assign only to **your** reportees (direct or indirect) or yourself
+- You choose task granularity appropriate to your layer in the org
+
+### 2. Review tasks
+
+```bash
+opengoat task list --as <me>
+opengoat task show <task-id>
+```
+
+### 3. Delegate by creating a task
+
+Create one task per owner and outcome.
+
+```bash
+opengoat task create \
+  --owner <me> \
+  --title "<verb>: <deliverable>" \
+  --description "<context + deliverable + acceptance criteria>" \
+  --assign <agent-id> \
+  [--project <path>]
+```
+
+## Self-assigning (do the work yourself)
+
+If the task is small enough and you have the tools and context to complete it efficiently, **do not delegate**. Create a task for yourself so the work is still tracked.
+
+Rules:
+
+- Use `--assign <me>`
+- Keep the task scoped to a single, verifiable outcome
+- Include acceptance criteria so “done” is unambiguous
+
+Example:
+
+```bash
+opengoat task create \
+  --owner <me> \
+  --title "Fix: <short description>" \
+  --description "Context:\n- ...\n\nDeliverable:\n- ...\n\nAcceptance criteria:\n- ..." \
+  --assign <me> \
+  [--project <path>]
+```
+
+## Task sizing and detail level (depends on your layer)
+
+Do not blindly "break tasks down small." Size tasks based on where you sit in the org and who you are assigning to. You already know your org shape (direct and indirect reportees, and which reportees are managers). Use that.
+
+### If you are a higher-level manager
+
+Write **outcome-focused** tasks:
+
+- What result is needed
+- Why it matters
+- Constraints and success criteria
+- Optional milestones (not step-by-step instructions)
+
+Expect your reportee to create smaller tasks for their own direct reportees if needed.
+
+### If you are the last manager before execution
+
+Write **execution-ready** tasks:
+
+- Concrete steps when helpful
+- File paths, commands, edge cases
+- Clear validation steps (how to verify)
+
+## Task writing template (not enforced, but recommended)
+
+### Title
+
+Use a verb + deliverable:
+
+- `Implement: <feature>`
+- `Fix: <bug>`
+- `Investigate: <question>`
+- `Decide: <tradeoff>`
+
+### Description (pasteable)
+
+```text
+Context:
+- Why this matters (1–3 bullets)
+
+Deliverable:
+- What to produce (code/doc/decision)
+
+Acceptance criteria:
+- Observable checks (tests pass, output, link, screenshot, etc.)
+
+Constraints:
+- Scope boundaries, dependencies, must-use tools, performance limits
+```
+
+## Troubleshooting
+
+- Task creation fails: you are likely assigning to someone who is not in your reportee tree. Reassign to a valid reportee (direct or indirect) or assign to yourself.
+- You can use `opengoat task --help` to see available commands and options.

package/dist/core/templates/default-templates.d.ts

@@ -1,19 +1,17 @@
 import type { AgentIdentity } from "../domain/agent.js";
 import type { AgentsIndex, OpenGoatConfig } from "../domain/opengoat-paths.js";
 export { DEFAULT_AGENT_ID } from "../domain/agent-id.js";
+export interface AgentTemplateOptions {
+    type?: "manager" | "individual";
+    reportsTo?: string | null;
+    skills?: string[];
+    role?: string;
+}
 export declare function renderGlobalConfig(nowIso: string): OpenGoatConfig;
 export declare function renderAgentsIndex(nowIso: string, agents: string[]): AgentsIndex;
-export declare function renderGlobalConfigMarkdown(): string;
-export declare function renderWorkspaceAgentsMarkdown(agent: AgentIdentity, providerId?: string): string;
-export declare function renderWorkspaceContextMarkdown(agent: AgentIdentity): string;
-export declare function renderWorkspaceSoulMarkdown(agent: AgentIdentity): string;
-export declare function renderWorkspaceToolsMarkdown(): string;
-export declare function renderWorkspaceIdentityMarkdown(agent: AgentIdentity): string;
-export declare function renderWorkspaceUserMarkdown(): string;
-export declare function renderWorkspaceHeartbeatMarkdown(): string;
-export declare function renderWorkspaceBootstrapMarkdown(agent: AgentIdentity): string;
-export declare function renderDefaultOrchestratorSkillMarkdown(): string;
-export declare function renderWorkspaceMetadata(agent: AgentIdentity): Record<string, unknown>;
-export declare function renderInternalAgentConfig(agent: AgentIdentity): Record<string, unknown>;
-export declare function renderInternalAgentMemoryMarkdown(agent: AgentIdentity): string;
-export declare function renderInternalAgentState(): Record<string, unknown>;
+export declare function renderCeoAgentsMarkdown(): string;
+export declare function renderCeoRoleMarkdown(): string;
+export declare function renderBoardManagerSkillMarkdown(): string;
+export declare function renderBoardIndividualSkillMarkdown(): string;
+export declare function renderInternalAgentConfig(agent: AgentIdentity, options?: AgentTemplateOptions): Record<string, unknown>;
+export declare function resolveAgentRole(agentId: string, type: "manager" | "individual", rawRole?: string): string;

package/dist/core/templates/default-templates.js

@@ -1,259 +1,127 @@
+import { readFileSync } from "node:fs";
 import { DEFAULT_AGENT_ID, isDefaultAgentId } from "../domain/agent-id.js";
-import { DEFAULT_PROVIDER_ID } from "../providers/index.js";
 export { DEFAULT_AGENT_ID } from "../domain/agent-id.js";
+const ROLE_SKILLS = {
+    manager: [],
+    individual: [],
+};
 export function renderGlobalConfig(nowIso) {
     return {
         schemaVersion: 1,
         defaultAgent: DEFAULT_AGENT_ID,
         createdAt: nowIso,
-        updatedAt: nowIso
+        updatedAt: nowIso,
     };
 }
 export function renderAgentsIndex(nowIso, agents) {
     return {
         schemaVersion: 1,
         agents,
-        updatedAt: nowIso
+        updatedAt: nowIso,
     };
 }
-export function renderGlobalConfigMarkdown() {
-    return [
-        "# OpenGoat Home",
-        "",
-        "This directory is OpenGoat runtime state.",
-        "",
-        "- `config.json`: global orchestrator settings",
-        "- `agents.json`: registered agent ids",
-        "- `workspaces/`: user-visible agent workspaces",
-        "- `agents/`: internal per-agent configuration",
-        "- `skills/`: managed shared skills (optional source for agent installs)",
-        "- `providers/`: provider credentials and endpoint settings",
-        "- `sessions/`: transient per-run orchestration working files",
-        "- `runs/`: run traces (routing + execution history)",
-        "",
-        "Only Markdown and JSON files are used for OpenGoat configuration and state."
-    ].join("\n");
+export function renderCeoAgentsMarkdown() {
+    return readMarkdownTemplate("ceo/AGENTS.md");
 }
-export function renderWorkspaceAgentsMarkdown(agent, providerId = DEFAULT_PROVIDER_ID) {
-    const description = isDefaultAgentId(agent.id)
-        ? "Primary orchestration agent that routes work to specialized agents."
-        : `Specialized agent for ${agent.displayName}.`;
-    const tags = isDefaultAgentId(agent.id) ? "orchestration, routing" : "specialized, delegated";
-    const canDelegate = isDefaultAgentId(agent.id) ? "true" : "false";
-    const priority = isDefaultAgentId(agent.id) ? "100" : "50";
-    return [
-        "---",
-        `id: ${agent.id}`,
-        `name: ${agent.displayName}`,
-        `description: ${description}`,
-        `provider: ${providerId}`,
-        "discoverable: true",
-        `tags: [${tags}]`,
-        "delegation:",
-        "  canReceive: true",
-        `  canDelegate: ${canDelegate}`,
-        `priority: ${priority}`,
-        "---",
-        "",
-        `# ${agent.displayName} (OpenGoat Agent)`,
-        "",
-        "## Role",
-        "You are an autonomous agent managed by OpenGoat.",
-        "",
-        "## Workspace Contract",
-        "- The workspace is your writable environment.",
-        "- Keep durable user-facing guidance in Markdown files.",
-        "- Keep structured settings in JSON files.",
-        "",
-        "## Operational Rules",
-        "- Prefer explicit planning before major actions.",
-        "- Keep logs concise and actionable.",
-        "- Record important decisions in `CONTEXT.md`.",
-        "",
-        "## Memory",
-        "Use `CONTEXT.md` for rolling context and handoff notes."
-    ].join("\n");
+export function renderCeoRoleMarkdown() {
+    return readMarkdownTemplate("ceo/ROLE.md");
 }
-export function renderWorkspaceContextMarkdown(agent) {
-    return [
-        `# Context (${agent.displayName})`,
-        "",
-        "- Created by OpenGoat during workspace bootstrap.",
-        "- Use this file to capture current goals, constraints, and pending work."
-    ].join("\n");
+export function renderBoardManagerSkillMarkdown() {
+    return readMarkdownTemplate("skills/og-board-manager/SKILL.md");
 }
-export function renderWorkspaceSoulMarkdown(agent) {
-    return [
-        `# Soul (${agent.displayName})`,
-        "",
-        "- Define tone, style, and non-negotiable guardrails here.",
-        "- Keep this file concise and stable across runs."
-    ].join("\n");
+export function renderBoardIndividualSkillMarkdown() {
+    return readMarkdownTemplate("skills/og-board-individual/SKILL.md");
 }
-export function renderWorkspaceToolsMarkdown() {
-    return [
-        "# Tools",
-        "",
-        "- Document local tool conventions and execution preferences.",
-        "- This file is guidance only; it does not grant tool permissions."
-    ].join("\n");
-}
-export function renderWorkspaceIdentityMarkdown(agent) {
-    return [
-        "# Identity",
-        "",
-        `- id: ${agent.id}`,
-        `- displayName: ${agent.displayName}`,
-        "- role: OpenGoat agent"
-    ].join("\n");
-}
-export function renderWorkspaceUserMarkdown() {
-    return [
-        "# User",
-        "",
-        "- Capture durable user preferences here.",
-        "- Avoid secrets; reference secure storage instead."
-    ].join("\n");
-}
-export function renderWorkspaceHeartbeatMarkdown() {
-    return [
-        "# Heartbeat",
-        "",
-        "Read this file when asked to perform heartbeat checks.",
-        "If nothing needs attention, return HEARTBEAT_OK."
-    ].join("\n");
-}
-export function renderWorkspaceBootstrapMarkdown(agent) {
-    return [
-        `# Bootstrap (${agent.displayName})`,
-        "",
-        "First-run checklist:",
-        "- Review AGENTS.md, SOUL.md, and IDENTITY.md.",
-        "- Confirm USER.md and CONTEXT.md reflect current goals.",
-        "- Delete this file after the bootstrap ritual is complete."
-    ].join("\n");
-}
-export function renderDefaultOrchestratorSkillMarkdown() {
-    return [
-        "---",
-        "name: OpenGoat Skill",
-        "description: Use the OpenGoat CLI to orchestrate agents, providers, sessions, skills, and plugins.",
-        "user-invocable: true",
-        "---",
-        "",
-        "# OpenGoat Skill",
-        "",
-        "## When to Use",
-        "- Use this skill when the task requires OpenGoat platform operations.",
-        "- Use it for agent lifecycle, provider setup, routing checks, and session inspection.",
-        "",
-        "## Command Playbook",
-        "- Send message to default orchestrator: `opengoat agent --message \"<text>\"`",
-        "- Send message to specific agent: `opengoat agent <agent-id> --message \"<text>\"`",
-        "- Create agent: `opengoat agent create --name \"<name>\"`",
-        "- List agents: `opengoat agent list`",
-        "- Inspect/set provider: `opengoat agent provider get --agent <agent-id>` / `opengoat agent provider set --agent <agent-id> --provider <provider-id>`",
-        "- List providers: `opengoat provider list`",
-        "- Configure providers and credentials: `opengoat onboard`",
-        "- Inspect routing: `opengoat route --message \"<text>\"`",
-        "- Manage sessions: `opengoat session list|history|reset|compact ...`",
-        "- Manage skills: `opengoat skill list|install ...`",
-        "- Manage plugins: `opengoat plugin list|install|enable|disable|doctor ...`",
-        "",
-        "## Rules",
-        "- Treat `orchestrator` as the default entry agent unless explicitly overridden.",
-        "- Prefer non-destructive inspection commands before changing provider or plugin state.",
-        "- After CLI actions, report what changed and where."
-    ].join("\n");
-}
-export function renderWorkspaceMetadata(agent) {
-    return {
-        schemaVersion: 1,
-        id: agent.id,
-        displayName: agent.displayName,
-        kind: "workspace",
-        createdBy: "opengoat"
-    };
-}
-export function renderInternalAgentConfig(agent) {
-    const workspaceAccess = isDefaultAgentId(agent.id) ? "internal" : "auto";
+export function renderInternalAgentConfig(agent, options = {}) {
+    const isCeo = isDefaultAgentId(agent.id);
+    const type = options.type ?? (isCeo ? "manager" : "individual");
+    const role = resolveAgentRole(agent.id, type, options.role ?? agent.role);
+    const reportsTo = options.reportsTo === undefined
+        ? isCeo
+            ? null
+            : DEFAULT_AGENT_ID
+        : options.reportsTo;
+    const assignedSkills = dedupe(options.skills ?? ROLE_SKILLS[type]);
     return {
-        schemaVersion: 1,
+        schemaVersion: 2,
         id: agent.id,
         displayName: agent.displayName,
-        provider: {
-            id: DEFAULT_PROVIDER_ID
+        role,
+        description: type === "manager"
+            ? `${role} coordinating direct reports.`
+            : `${role} OpenClaw agent for ${agent.displayName}.`,
+        organization: {
+            type,
+            reportsTo,
+            discoverable: true,
+            tags: type === "manager" ? ["manager", "leadership"] : ["specialized"],
+            priority: type === "manager" ? 100 : 50,
         },
         runtime: {
-            mode: "orchestrated",
-            workspaceAccess,
-            contextBudgetTokens: 128_000,
-            bootstrapMaxChars: 20_000,
+            adapter: "openclaw",
+            mode: "organization",
             sessions: {
                 mainKey: "main",
                 contextMaxChars: 12_000,
                 reset: {
                     mode: "daily",
-                    atHour: 4
+                    atHour: 4,
                 },
                 pruning: {
                     enabled: true,
                     maxMessages: 40,
                     maxChars: 16_000,
-                    keepRecentMessages: 12
+                    keepRecentMessages: 12,
                 },
                 compaction: {
                     enabled: true,
                     triggerMessageCount: 80,
                     triggerChars: 32_000,
                     keepRecentMessages: 20,
-                    summaryMaxChars: 4_000
+                    summaryMaxChars: 4_000,
                 },
-                skills: {
-                    enabled: true,
-                    includeWorkspace: true,
-                    includeManaged: true,
-                    load: {
-                        extraDirs: []
-                    },
-                    prompt: {
-                        maxSkills: 12,
-                        maxCharsPerSkill: 6_000,
-                        maxTotalChars: 36_000,
-                        includeContent: true
-                    }
-                }
-            }
+            },
+            skills: {
+                enabled: true,
+                includeWorkspace: false,
+                includeManaged: true,
+                assigned: assignedSkills,
+                load: {
+                    extraDirs: [],
+                },
+                prompt: {
+                    maxSkills: 12,
+                    maxCharsPerSkill: 6_000,
+                    maxTotalChars: 36_000,
+                    includeContent: true,
+                },
+            },
         },
-        prompt: {
-            bootstrapFiles: [
-                "AGENTS.md",
-                "SOUL.md",
-                "TOOLS.md",
-                "IDENTITY.md",
-                "USER.md",
-                "HEARTBEAT.md",
-                "CONTEXT.md",
-                "BOOTSTRAP.md",
-                "MEMORY.md",
-                "memory.md"
-            ]
-        }
     };
 }
-export function renderInternalAgentMemoryMarkdown(agent) {
-    return [
-        `# Internal Memory (${agent.displayName})`,
-        "",
-        "This file is for OpenGoat internal memory and diagnostic notes.",
-        "It should remain machine-writable and human-readable."
-    ].join("\n");
-}
-export function renderInternalAgentState() {
-    return {
-        schemaVersion: 1,
-        status: "idle",
-        lastRunAt: null
-    };
+export function resolveAgentRole(agentId, type, rawRole) {
+    const explicitRole = rawRole?.trim();
+    if (explicitRole) {
+        return explicitRole;
+    }
+    if (isDefaultAgentId(agentId)) {
+        return "CEO";
+    }
+    return type === "manager" ? "Manager" : "Individual Contributor";
+}
+function dedupe(values) {
+    return [...new Set(values.map((value) => value.trim()).filter(Boolean))];
+}
+const markdownTemplateCache = new Map();
+function readMarkdownTemplate(relativePath) {
+    const cached = markdownTemplateCache.get(relativePath);
+    if (cached) {
+        return cached;
+    }
+    const content = readFileSync(new URL(`./assets/${relativePath}`, import.meta.url), "utf-8")
+        .replace(/\r\n/g, "\n")
+        .trimEnd();
+    markdownTemplateCache.set(relativePath, content);
+    return content;
 }
 //# sourceMappingURL=default-templates.js.map