@runcore-sh/runcore 0.1.9 → 0.2.0

package/brain-template/agents/cooldowns.json

@@ -0,0 +1 @@
+[]

package/brain-template/agents/locks.json

@@ -0,0 +1 @@
+{}

package/brain-template/agents/module.json

@@ -0,0 +1,15 @@
+{
+  "name": "agents",
+  "description": "Agent runtime: spawned Claude Code agent tasks, execution logs, runtime state.",
+  "keywords": ["agent", "agents", "agent task", "agent status", "spawned"],
+  "files": [
+    { "path": "tasks/", "role": "data" },
+    { "path": "runtime/", "role": "data" },
+    { "path": "logs/", "role": "log" }
+  ],
+  "endpoints": [
+    { "path": "/api/agents/tasks", "method": "GET" },
+    { "path": "/api/runtime/status", "method": "GET" }
+  ],
+  "promptOrder": 55
+}

package/brain-template/agents/workflows/examples/conditional-deploy.json

@@ -0,0 +1,124 @@
+{
+  "name": "conditional-deploy",
+  "version": "1.0.0",
+  "description": "Run tests, then branch based on results: deploy on success, diagnose on failure. Demonstrates conditional branching with stepStatus conditions, allOf/not combinators, and fallback recovery.",
+  "tags": ["deploy", "testing", "conditional"],
+  "inputs": {
+    "target": {
+      "type": "string",
+      "description": "Deployment target: 'staging' or 'production'.",
+      "required": true
+    },
+    "skipLint": {
+      "type": "boolean",
+      "description": "Skip the lint step.",
+      "default": false
+    }
+  },
+  "outputs": {
+    "result": {
+      "fromStep": "deploy",
+      "value": "output"
+    },
+    "diagnosis": {
+      "fromStep": "diagnose",
+      "value": "output"
+    }
+  },
+  "mode": "sequential",
+  "onFailure": {
+    "action": "continue"
+  },
+  "steps": [
+    {
+      "key": "lint",
+      "label": "Lint codebase",
+      "prompt": "Run linting checks on the codebase. Report any issues found with file paths and line numbers. Output PASS if clean, or FAIL with details.",
+      "condition": {
+        "not": {
+          "inputEquals": {
+            "input": "skipLint",
+            "value": true
+          }
+        }
+      },
+      "tags": ["quality"],
+      "timeoutMs": 120000
+    },
+    {
+      "key": "test",
+      "label": "Run test suite",
+      "prompt": "Run the full test suite. Report pass/fail counts and any failing test details. Summarize overall result as PASS or FAIL.",
+      "tags": ["testing"],
+      "retries": 1,
+      "timeoutMs": 300000
+    },
+    {
+      "key": "deploy",
+      "label": "Deploy to target",
+      "prompt": "Deploy the application to {{input.target}}. Verify the deployment was successful and report the deployed version and URL.",
+      "dependsOn": ["test"],
+      "condition": {
+        "allOf": [
+          {
+            "stepStatus": {
+              "step": "test",
+              "equals": "completed"
+            }
+          },
+          {
+            "anyOf": [
+              {
+                "stepStatus": {
+                  "step": "lint",
+                  "equals": "completed"
+                }
+              },
+              {
+                "stepStatus": {
+                  "step": "lint",
+                  "equals": "skipped"
+                }
+              }
+            ]
+          }
+        ]
+      },
+      "tags": ["deploy"],
+      "timeoutMs": 600000,
+      "onFailure": {
+        "action": "fallback",
+        "fallbackStep": "rollback"
+      }
+    },
+    {
+      "key": "diagnose",
+      "label": "Diagnose test failures",
+      "prompt": "The test suite failed. Analyze the test output and identify root causes:\n\nTest output:\n{{steps.test.error}}\n\nProvide a prioritized list of issues and suggested fixes.",
+      "dependsOn": ["test"],
+      "condition": {
+        "stepStatus": {
+          "step": "test",
+          "equals": "failed"
+        }
+      },
+      "tags": ["debugging"],
+      "timeoutMs": 180000
+    },
+    {
+      "key": "rollback",
+      "label": "Rollback deployment",
+      "prompt": "The deployment to {{input.target}} failed. Initiate a rollback to the previous stable version. Report the rollback status and any manual steps needed.",
+      "tags": ["deploy", "recovery"],
+      "timeoutMs": 300000
+    },
+    {
+      "key": "notify",
+      "label": "Send status notification",
+      "prompt": "Summarize the pipeline results:\n- Lint: {{steps.lint.status}}\n- Tests: {{steps.test.status}}\n- Deploy: {{steps.deploy.status}}\n- Diagnosis: {{steps.diagnose.status}}\n- Rollback: {{steps.rollback.status}}\n\nTarget: {{input.target}}\n\nCompose a concise status notification suitable for a team channel.",
+      "dependsOn": ["test"],
+      "tags": ["notification"],
+      "timeoutMs": 60000
+    }
+  ]
+}

package/brain-template/agents/workflows/examples/parallel-analysis.json

@@ -0,0 +1,81 @@
+{
+  "name": "parallel-analysis",
+  "version": "1.0.0",
+  "description": "Analyze a codebase change from multiple angles in parallel (security, performance, architecture), then synthesize findings. Demonstrates parallel fan-out with dependency fan-in, conditional steps, and input-based gating.",
+  "tags": ["code-review", "analysis", "parallel"],
+  "inputs": {
+    "changeset": {
+      "type": "string",
+      "description": "Description of the code change or PR to analyze.",
+      "required": true
+    },
+    "includeSecurity": {
+      "type": "boolean",
+      "description": "Whether to run the security analysis pass.",
+      "default": true
+    },
+    "includePerformance": {
+      "type": "boolean",
+      "description": "Whether to run the performance analysis pass.",
+      "default": true
+    }
+  },
+  "outputs": {
+    "synthesis": {
+      "fromStep": "synthesize",
+      "value": "output"
+    }
+  },
+  "mode": "dependency",
+  "maxConcurrent": 3,
+  "onFailure": {
+    "action": "continue"
+  },
+  "steps": [
+    {
+      "key": "security",
+      "label": "Security analysis",
+      "prompt": "Perform a security review of the following code change:\n\n{{input.changeset}}\n\nCheck for: injection vulnerabilities, authentication/authorization gaps, data exposure risks, dependency vulnerabilities, and OWASP Top 10 issues. Output a structured report with severity ratings.",
+      "condition": {
+        "inputEquals": {
+          "input": "includeSecurity",
+          "value": true
+        }
+      },
+      "tags": ["security"],
+      "priority": 10,
+      "timeoutMs": 240000
+    },
+    {
+      "key": "performance",
+      "label": "Performance analysis",
+      "prompt": "Analyze the performance implications of the following code change:\n\n{{input.changeset}}\n\nEvaluate: time complexity changes, memory usage, I/O patterns, potential bottlenecks, and scalability concerns. Suggest optimizations where applicable.",
+      "condition": {
+        "inputEquals": {
+          "input": "includePerformance",
+          "value": true
+        }
+      },
+      "tags": ["performance"],
+      "priority": 20,
+      "timeoutMs": 240000
+    },
+    {
+      "key": "architecture",
+      "label": "Architecture review",
+      "prompt": "Review the architectural impact of the following code change:\n\n{{input.changeset}}\n\nAssess: adherence to existing patterns, coupling/cohesion changes, abstraction appropriateness, testability impact, and alignment with project conventions.",
+      "tags": ["architecture"],
+      "priority": 30,
+      "timeoutMs": 240000
+    },
+    {
+      "key": "synthesize",
+      "label": "Synthesize findings",
+      "prompt": "Synthesize the following analysis reports into a unified code review summary:\n\nSecurity Analysis:\n{{steps.security.output}}\n\nPerformance Analysis:\n{{steps.performance.output}}\n\nArchitecture Review:\n{{steps.architecture.output}}\n\nProduce a prioritized list of findings, an overall risk assessment, and actionable recommendations. Note which analyses were skipped (empty sections above).",
+      "dependsOn": ["security", "performance", "architecture"],
+      "tags": ["synthesis"],
+      "priority": 0,
+      "timeoutMs": 180000
+    }
+  ]
+}

package/brain-template/agents/workflows/examples/research-and-write.json

@@ -0,0 +1,71 @@
+{
+  "name": "research-and-write",
+  "version": "1.0.0",
+  "description": "Research a topic, draft content based on findings, then review for quality. Demonstrates sequential dependency chains, template interpolation, and error recovery with fallback.",
+  "tags": ["content", "research", "writing"],
+  "inputs": {
+    "topic": {
+      "type": "string",
+      "description": "The topic to research and write about.",
+      "required": true
+    },
+    "format": {
+      "type": "string",
+      "description": "Output format: 'blog', 'memo', or 'summary'.",
+      "default": "blog"
+    }
+  },
+  "outputs": {
+    "draft": {
+      "fromStep": "write",
+      "value": "output"
+    },
+    "review": {
+      "fromStep": "review",
+      "value": "output"
+    }
+  },
+  "mode": "dependency",
+  "maxConcurrent": 2,
+  "onFailure": {
+    "action": "continue"
+  },
+  "steps": [
+    {
+      "key": "research",
+      "label": "Research topic",
+      "prompt": "Research the following topic thoroughly: {{input.topic}}\n\nGather key facts, recent developments, and relevant context. Output a structured research brief with sections: Overview, Key Points, Sources, and Open Questions.",
+      "tags": ["research"],
+      "retries": 1,
+      "timeoutMs": 300000,
+      "onFailure": {
+        "action": "fallback",
+        "fallbackStep": "research-lite"
+      }
+    },
+    {
+      "key": "research-lite",
+      "label": "Lightweight research fallback",
+      "prompt": "Provide a brief overview of: {{input.topic}}\n\nFocus on the most essential facts and context. Keep it concise — this is a fallback for when deep research fails.",
+      "tags": ["research", "fallback"],
+      "timeoutMs": 120000
+    },
+    {
+      "key": "write",
+      "label": "Draft content",
+      "prompt": "Using the following research:\n\n{{steps.research.output}}\n\nWrite a {{input.format}} about \"{{input.topic}}\". Follow the appropriate style and structure for the format. Make it engaging and well-organized.",
+      "dependsOn": ["research"],
+      "tags": ["writing"],
+      "retries": 1,
+      "timeoutMs": 300000
+    },
+    {
+      "key": "review",
+      "label": "Review and polish",
+      "prompt": "Review the following draft for accuracy, clarity, tone, and structure:\n\n{{steps.write.output}}\n\nProvide specific feedback and a revised version. Check facts against the research brief:\n\n{{steps.research.output}}",
+      "dependsOn": ["write"],
+      "tags": ["review", "editing"],
+      "timeoutMs": 180000
+    }
+  ]
+}

package/brain-template/agents/workflows/schema.json

@@ -0,0 +1,236 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://dash-brain.local/schemas/workflow.json",
+  "title": "Core Workflow Definition",
+  "description": "Defines a multi-step agent workflow with dependencies, conditional logic, and error recovery.",
+  "type": "object",
+  "required": ["name", "version", "steps"],
+  "additionalProperties": false,
+  "properties": {
+    "name": {
+      "type": "string",
+      "description": "Human-readable workflow name.",
+      "minLength": 1,
+      "maxLength": 120
+    },
+    "version": {
+      "type": "string",
+      "description": "Semantic version of this workflow definition.",
+      "pattern": "^\\d+\\.\\d+\\.\\d+$"
+    },
+    "description": {
+      "type": "string",
+      "description": "What this workflow does and when to use it."
+    },
+    "tags": {
+      "type": "array",
+      "items": { "type": "string" },
+      "description": "Tags for discovery and skill matching."
+    },
+    "inputs": {
+      "type": "object",
+      "description": "Workflow-level input parameters. Keys are parameter names.",
+      "additionalProperties": {
+        "$ref": "#/$defs/parameterDef"
+      }
+    },
+    "outputs": {
+      "type": "object",
+      "description": "Workflow-level outputs mapped from step results.",
+      "additionalProperties": {
+        "type": "object",
+        "required": ["fromStep", "value"],
+        "additionalProperties": false,
+        "properties": {
+          "fromStep": {
+            "type": "string",
+            "description": "Step key to source the value from."
+          },
+          "value": {
+            "type": "string",
+            "description": "Expression referencing the step output (e.g. 'output', 'status')."
+          }
+        }
+      }
+    },
+    "mode": {
+      "type": "string",
+      "enum": ["sequential", "parallel", "dependency"],
+      "default": "dependency",
+      "description": "Default execution mode. 'dependency' respects dependsOn edges; 'sequential' runs steps in definition order; 'parallel' runs all at once."
+    },
+    "maxConcurrent": {
+      "type": "integer",
+      "minimum": 1,
+      "default": 5,
+      "description": "Max concurrent agents when mode is 'parallel' or 'dependency'."
+    },
+    "timeoutMs": {
+      "type": "integer",
+      "minimum": 1000,
+      "description": "Wall-clock timeout for the entire workflow."
+    },
+    "onFailure": {
+      "$ref": "#/$defs/failurePolicy",
+      "description": "Default failure policy applied to steps that don't define their own."
+    },
+    "steps": {
+      "type": "array",
+      "minItems": 1,
+      "items": { "$ref": "#/$defs/step" },
+      "description": "Ordered list of workflow steps."
+    }
+  },
+  "$defs": {
+    "parameterDef": {
+      "type": "object",
+      "required": ["type"],
+      "additionalProperties": false,
+      "properties": {
+        "type": {
+          "type": "string",
+          "enum": ["string", "number", "boolean"],
+          "description": "Parameter data type."
+        },
+        "description": {
+          "type": "string"
+        },
+        "required": {
+          "type": "boolean",
+          "default": false
+        },
+        "default": {
+          "description": "Default value if not provided at runtime."
+        }
+      }
+    },
+    "step": {
+      "type": "object",
+      "required": ["key", "label", "prompt"],
+      "additionalProperties": false,
+      "properties": {
+        "key": {
+          "type": "string",
+          "pattern": "^[a-z][a-z0-9_-]*$",
+          "description": "Unique identifier within the workflow. Lowercase, alphanumeric with hyphens/underscores."
+        },
+        "label": {
+          "type": "string",
+          "description": "Human-readable step name."
+        },
+        "prompt": {
+          "type": "string",
+          "description": "Agent prompt. Supports {{input.paramName}} and {{steps.prevKey.output}} template interpolation."
+        },
+        "dependsOn": {
+          "type": "array",
+          "items": { "type": "string" },
+          "description": "Step keys that must complete before this step runs."
+        },
+        "condition": {
+          "$ref": "#/$defs/condition",
+          "description": "Conditional gate — step only runs if this evaluates to true."
+        },
+        "inputs": {
+          "type": "object",
+          "description": "Input mappings from workflow inputs or prior step outputs.",
+          "additionalProperties": {
+            "type": "string"
+          }
+        },
+        "priority": {
+          "type": "integer",
+          "minimum": 0,
+          "maximum": 100,
+          "default": 50,
+          "description": "Priority (0 = highest). Used for scheduling order."
+        },
+        "timeoutMs": {
+          "type": "integer",
+          "minimum": 1000,
+          "description": "Per-step timeout override."
+        },
+        "retries": {
+          "type": "integer",
+          "minimum": 0,
+          "maximum": 5,
+          "default": 0,
+          "description": "Number of retry attempts on failure."
+        },
+        "onFailure": {
+          "$ref": "#/$defs/failurePolicy",
+          "description": "Step-level failure policy, overrides workflow default."
+        },
+        "tags": {
+          "type": "array",
+          "items": { "type": "string" }
+        },
+        "cwd": {
+          "type": "string",
+          "description": "Working directory override for this step's agent."
+        }
+      }
+    },
+    "condition": {
+      "type": "object",
+      "description": "Conditional expression. Exactly one of the operator fields must be set.",
+      "additionalProperties": false,
+      "properties": {
+        "stepStatus": {
+          "type": "object",
+          "required": ["step", "equals"],
+          "additionalProperties": false,
+          "properties": {
+            "step": { "type": "string", "description": "Step key to check." },
+            "equals": {
+              "type": "string",
+              "enum": ["completed", "failed", "skipped"],
+              "description": "Required status."
+            }
+          },
+          "description": "True if the referenced step finished with the given status."
+        },
+        "inputEquals": {
+          "type": "object",
+          "required": ["input", "value"],
+          "additionalProperties": false,
+          "properties": {
+            "input": { "type": "string", "description": "Workflow input parameter name." },
+            "value": { "description": "Expected value." }
+          },
+          "description": "True if a workflow input matches the given value."
+        },
+        "allOf": {
+          "type": "array",
+          "items": { "$ref": "#/$defs/condition" },
+          "description": "All sub-conditions must be true (logical AND)."
+        },
+        "anyOf": {
+          "type": "array",
+          "items": { "$ref": "#/$defs/condition" },
+          "description": "At least one sub-condition must be true (logical OR)."
+        },
+        "not": {
+          "$ref": "#/$defs/condition",
+          "description": "Negation of a sub-condition."
+        }
+      }
+    },
+    "failurePolicy": {
+      "type": "object",
+      "required": ["action"],
+      "additionalProperties": false,
+      "properties": {
+        "action": {
+          "type": "string",
+          "enum": ["stop", "continue", "fallback"],
+          "description": "'stop' aborts the workflow. 'continue' skips the failed step and proceeds. 'fallback' runs the fallbackStep."
+        },
+        "fallbackStep": {
+          "type": "string",
+          "description": "Step key to run as a fallback (required when action is 'fallback')."
+        }
+      }
+    }
+  }
+}

package/brain-template/contacts/README.md

@@ -0,0 +1,22 @@
+# Contacts module
+
+Relationship graph of everyone and everything Core interacts with. Nodes are entities (humans, AI systems, organizations, services). Edges are relationships between them. Encrypted at rest because this is sensitive data.
+
+## Files (append-only, encrypted)
+
+- **entities.jsonl** — Entity records. Fields: `id` (ent_ + 8 hex), `type` (human | ai | organization | service), `name`, `aliases`, `channels` (array of {type, value}), `meta` (freeform type-specific data), `notes`, `tags`, `status` (active | archived).
+- **edges.jsonl** — Relationship edges. Fields: `id` (edg_ + 8 hex), `from`/`to` (entity IDs), `type` (works_at | owns | introduced_by | collaborates_with | uses | built_by | reports_to), `label` (optional qualifier), `since` (ISO date or YYYY-MM), `notes`, `status` (active | archived).
+
+## Privacy rules
+
+- **Encrypt at rest.** All contact data is encrypted. Never store plaintext contact information.
+- **Only record explicit knowledge.** Contact entries come from things Core was told about or directly interacted with — never scraped or inferred without basis.
+- **This is Core's relational memory, not surveillance.** The graph represents Core's understanding of its world, not a dossier.
+- **Archive, don't delete.** To remove an entity or edge, set `"status": "archived"` — never rewrite the file.
+
+## Rules
+
+- **Append only.** Add one new line per entry. Never overwrite or rewrite the file.
+- To update an entity or edge, append a new line with the same `id` and updated fields. Last occurrence wins.
+- Use `getRelationships(entityId)` to find all edges where an entity is `from` or `to`.
+- Use `getGraph(entityId, depth)` for BFS traversal to explore relationship neighborhoods.

package/brain-template/contacts/module.json

@@ -0,0 +1,19 @@
+{
+  "name": "contacts",
+  "description": "Entity relationship graph. People, AI systems, organizations, and services Core interacts with — plus the edges between them.",
+  "keywords": ["contact", "contacts", "who", "person", "company", "organization", "relationship", "knows", "introduced", "entity", "people"],
+  "files": [
+    { "path": "entities.jsonl", "role": "data", "description": "Append-only entity records (encrypted at rest)" },
+    { "path": "edges.jsonl", "role": "data", "description": "Append-only relationship edges (encrypted at rest)" }
+  ],
+  "endpoints": [
+    { "path": "/api/contacts/entities", "method": "GET", "description": "List entities with ?type= filter" },
+    { "path": "/api/contacts/entities", "method": "POST", "description": "Create entity" },
+    { "path": "/api/contacts/entities/:id", "method": "PATCH", "description": "Update entity" },
+    { "path": "/api/contacts/entities/:id/relationships", "method": "GET", "description": "Entity's edges" },
+    { "path": "/api/contacts/edges", "method": "POST", "description": "Create edge" },
+    { "path": "/api/contacts/graph/:id", "method": "GET", "description": "Subgraph from entity (depth param)" }
+  ],
+  "prompt": "## Contacts (entity graph)\nYou maintain a relationship graph of everyone and everything you interact with. Entities are people, AI systems, organizations, or services. Edges describe how they relate (works_at, owns, collaborates_with, uses, etc.). All contact data is encrypted at rest. When {name} asks about contacts, relationships, or \"who\" questions, query entities.jsonl and edges.jsonl. This is your relational memory — not surveillance. Only record things you were explicitly told about or directly interacted with.",
+  "promptOrder": 40
+}

package/brain-template/content/CONTENT.md

@@ -0,0 +1,36 @@
+# CONTENT.md — Content module instructions
+
+Load this when the task is content: blog, post, thread, draft, edit, or research.
+
+## File inventory
+
+- `brain/identity/tone-of-voice.md` — Voice profile and checkpoints. Load for any writing.
+- `brain/identity/brand.md` — Positioning and guardrails. Load for any writing.
+- `brain/content/templates/` — Blog, thread, research templates. Load the one that matches the content type.
+- `brain/knowledge/research/` — Existing topic research. Check before drafting.
+
+## Content pipeline (stages)
+
+1. **Idea** — Capture to ideas log; score alignment, insight, audience need, timeliness, effort.
+2. **Research** — Output to `brain/knowledge/research/[topic].md` (structured: summary, landscape, evidence, sources).
+3. **Outline** — Per template (sections, word counts).
+4. **Draft** — Follow template + voice. Run anti-patterns check.
+5. **Edit** — Structure → voice → evidence → read-aloud.
+6. **Publish / Promote** — Log to posts; create thread or adaptation per template.
+
+## Quality gates
+
+- Every draft: banned-words scan, sentence rhythm, one em-dash per paragraph rule.
+- Evidence: claims sourced?
+- Final: would the user actually post this?
+
+## Instructions for the agent
+
+<instructions>
+
+- When writing, always load tone-of-voice and brand. Do not skip voice checkpoints.
+- Use the template for the requested content type (blog, thread, research). Do not make up structure.
+- Research output goes to `brain/knowledge/research/[topic].md` in the structured format (Executive Summary, Landscape, Evidence Bank, Sources).
+- Single source of truth: reference files by path; do not duplicate long content into the prompt.
+
+</instructions>

package/brain-template/content/templates/blog.md

@@ -0,0 +1,26 @@
+# Blog template (long-form)
+
+Structure for a long-form blog post. Use with voice and anti-patterns from identity.
+
+## Sections (word count targets)
+
+1. **Hook** — Grab attention; lead with insight or question. (~100–150)
+2. **Core concept** — What we’re talking about and why it matters. (~200–300)
+3. **Framework** — How to think about it (model, steps, or lens). (~300–400)
+4. **Practical application** — How to do it / use it. (~400–600)
+5. **Failure modes** — What to avoid. (~200–300)
+6. **Getting started** — Concrete first steps. (~150–200)
+7. **Closing** — Takeaway or CTA. (~100–150)
+
+**Total:** 2,000–3,500 words.
+
+## Attribution
+
+Every published piece must include a byline footer. Load `brain/identity/brand.md` for the canonical entity name and URL. Do not hard-code — always pull from brand.md so updates propagate.
+
+## Editing passes
+
+1. Structure — Does the hook grab? Does each section earn its place?
+2. Voice — Banned words scan, sentence rhythm, em-dash limit.
+3. Evidence — Claims sourced? Numbers and examples where needed?
+4. Read-aloud — Would the user actually post this?

package/brain-template/knowledge/README.md

@@ -0,0 +1,11 @@
+# Knowledge module
+
+Research outputs, bookmarks, and notes. Input for content and decisions.
+
+## Layout
+
+- **research/** — Topic research in structured markdown (one file per topic). Created by the content research workflow.
+- **bookmarks/** — Optional. Links and notes for later use.
+- **notes/** — Free-form notes the agent can read when relevant.
+
+Load only the file(s) needed for the current task. Do not load the entire directory.