metaharness 0.1.0

package/templates/vertical_devops/CLAUDE.md.tmpl

@@ -0,0 +1,34 @@
+# {{name}}
+
+{{description}}
+
+## What this harness does
+
+Coordinates on-call incident response: alert ingestion, runbook lookup, escalation logic, and postmortem authoring. 4 agents work in a hierarchical pipeline; the kernel routes between them.
+
+## Agents
+
+| Agent | Role | Typical model tier |
+|---|---|---|
+| `responder` | Triages incoming alerts, identifies playbook | Haiku |
+| `runbook-runner` | Executes known runbooks step by step | Haiku |
+| `escalator` | Decides when to page humans + who | Sonnet |
+| `postmortem` | Drafts incident postmortems from session transcript | Sonnet |
+
+## Behavioral rules
+
+- ALWAYS run `runbook-runner` before `escalator` — escalation requires runbook context
+- NEVER auto-execute destructive commands; runbook-runner deliberates, doesn't `rm`
+- `escalator` may invoke a human via the `notify` MCP tool — that's the only side-effect agent
+
+## Slash commands
+
+| Command | What it does |
+|---|---|
+| `/triage <alert>` | Run responder + runbook-runner |
+| `/escalate <reason>` | Force escalation path |
+| `/postmortem` | Generate postmortem from current session |
+
+## Architecture
+
+Built on `@ruflo/kernel` (Rust + WASM). Multi-host: ships with the **{{host}}** adapter; other hosts available via `harness add-host <name>`.

package/templates/vertical_devops/README.md.tmpl

@@ -0,0 +1,27 @@
+# {{name}}
+
+{{description}}
+
+> Generated with [`create-agent-harness`](https://github.com/ruvnet/agent-harness-generator) using the `vertical:devops` template. WASM kernel, multi-host, witness-signed.
+
+## Install
+
+```bash
+npm install -g {{name}}
+{{name}} init
+```
+
+## What's in the box
+
+- 4 specialized agents (responder, runbook-runner, escalator, postmortem)
+- `runbooks/` directory for your team's runbooks (markdown)
+- Pre-configured routing: Haiku for triage/runbook execution, Sonnet for escalation + postmortem
+- `.claude/settings.json` with sensible permissions and the kernel MCP server registered
+
+## Adding your own runbooks
+
+Drop markdown files into `runbooks/`. The runbook-runner agent finds them by semantic search via the kernel's memory bridge — no schema required.
+
+## License
+
+MIT

package/templates/vertical_devops/manifest.json

@@ -0,0 +1,22 @@
+{
+  "id": "vertical:devops",
+  "description": "DevOps incident response harness — 4 agents (responder, runbook, escalator, postmortem), 3 MCP servers (kernel + alerts + runbook-store), opinionated routing rules for on-call workflows",
+  "domain": "devops/incident-response",
+  "files": [
+    { "src": "package.json.tmpl", "dst": "package.json", "render": true },
+    { "src": "CLAUDE.md.tmpl", "dst": "CLAUDE.md", "render": true },
+    { "src": "README.md.tmpl", "dst": "README.md", "render": true },
+    { "src": ".claude/settings.json.tmpl", "dst": ".claude/settings.json", "render": true },
+    { "src": "src/init.ts.tmpl", "dst": "src/init.ts", "render": true },
+    { "src": "src/agents/responder.ts.tmpl", "dst": "src/agents/responder.ts", "render": true },
+    { "src": "src/agents/runbook-runner.ts.tmpl", "dst": "src/agents/runbook-runner.ts", "render": true },
+    { "src": "src/agents/escalator.ts.tmpl", "dst": "src/agents/escalator.ts", "render": true },
+    { "src": "src/agents/postmortem.ts.tmpl", "dst": "src/agents/postmortem.ts", "render": true },
+    { "src": "runbooks/README.md.tmpl", "dst": "runbooks/README.md", "render": true }
+  ],
+  "vars": [
+    { "name": "name", "prompt": "Harness name (kebab-case)", "validate": "^[a-z0-9-]+$" },
+    { "name": "description", "prompt": "One-line description", "default": "Incident response with on-call workflows" },
+    { "name": "host", "prompt": "Host adapter", "default": "claude-code", "choices": ["claude-code", "codex", "pi-dev", "hermes"] }
+  ]
+}

package/templates/vertical_devops/package.json.tmpl

@@ -0,0 +1,26 @@
+{
+  "name": "{{name}}",
+  "version": "0.1.0",
+  "description": "{{description}}",
+  "type": "module",
+  "bin": {
+    "{{name}}": "./bin/{{name}}.js"
+  },
+  "files": ["bin/**", "dist/**", "runbooks/**", ".claude/**", "CLAUDE.md", "README.md", "LICENSE"],
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest run --passWithNoTests",
+    "init": "node ./dist/init.js"
+  },
+  "dependencies": {
+    "@ruflo/kernel": "^0.1.0",
+    "@ruflo/host-{{host}}": "^0.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "^5.4.0",
+    "vitest": "^2.0.0"
+  },
+  "keywords": ["devops", "incident-response", "on-call", "runbooks", "agent-harness"],
+  "engines": { "node": ">=20.0.0" }
+}

package/templates/vertical_devops/runbooks/README.md.tmpl

@@ -0,0 +1,32 @@
+# Runbooks for {{name}}
+
+Drop your team's runbooks in this directory as markdown files. The
+`runbook-runner` agent finds them by semantic search via the kernel's
+memory bridge — no schema required, no registration step.
+
+## Convention
+
+```markdown
+# <Incident name>
+
+## Symptoms
+- What you see
+- What metric triggers this
+
+## Runbook
+1. First step
+2. Second step
+3. ...
+
+## When to escalate
+- Conditions under which the runbook gives up and pages a human
+```
+
+The semantic-search retriever looks at the `# title`, the `## Symptoms`,
+and the first paragraph of `## Runbook`. Keep those expressive; the
+narrative below can be as detailed as you like.
+
+## Versioning
+
+Runbooks are versioned with the harness — when you `npm publish`, the
+runbook bundle ships too. Users get your latest runbooks on `npm update`.

package/templates/vertical_devops/src/agents/escalator.ts.tmpl

@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: MIT
+// Escalator agent — decides when to page humans and who.
+
+export const SYSTEM_PROMPT = `You are the escalator for {{name}}.
+
+You're invoked when the runbook runner can't resolve the incident, or when
+the responder's triage indicates an unknown failure mode. Your job:
+
+1. Summarise what's been tried (from session context)
+2. State the blast radius (just one service? multiple? customer-facing?)
+3. Recommend a specific human or team to page, with reasoning
+4. Draft the notification text
+
+Don't actually page yet — emit a NOTIFY_INTENT block the kernel routes
+to the notify MCP tool. Wait for human confirmation before the page goes
+out.`;
+
+export const NAME = 'escalator';
+export const TIER = 'sonnet' as const;

package/templates/vertical_devops/src/agents/postmortem.ts.tmpl

@@ -0,0 +1,23 @@
+// SPDX-License-Identifier: MIT
+// Postmortem agent — drafts blameless incident postmortems from the
+// session transcript.
+
+export const SYSTEM_PROMPT = `You are the postmortem author for {{name}}.
+
+After an incident resolves, you draft a blameless postmortem from the
+session transcript. Required sections:
+
+1. Summary (1-2 sentences)
+2. Timeline (UTC, terse)
+3. Impact (users / services / duration)
+4. Root cause (technical)
+5. Contributing factors (process, tooling, communication)
+6. What went well
+7. Action items (each with an owner and a due date)
+
+Stay blameless. Name systems, not people. Pull facts from the session
+transcript via the kernel memory bridge — do not invent dates or impact
+numbers.`;
+
+export const NAME = 'postmortem';
+export const TIER = 'sonnet' as const;

package/templates/vertical_devops/src/agents/responder.ts.tmpl

@@ -0,0 +1,14 @@
+// SPDX-License-Identifier: MIT
+// Responder agent — first to receive alerts. Triages and identifies the
+// appropriate runbook for the next agent.
+
+export const SYSTEM_PROMPT = `You are the on-call responder for {{name}}.
+
+Your job: when an alert comes in, identify what's broken, find the matching
+runbook, and hand off to runbook-runner. Do NOT execute remediation
+yourself; you triage and delegate.
+
+Stay terse. State: what's broken, what runbook, what to escalate later.`;
+
+export const NAME = 'responder';
+export const TIER = 'haiku' as const;

package/templates/vertical_devops/src/agents/runbook-runner.ts.tmpl

@@ -0,0 +1,17 @@
+// SPDX-License-Identifier: MIT
+// Runbook runner agent — executes runbook steps in order, deliberates
+// (does not auto-execute destructive operations).
+
+export const SYSTEM_PROMPT = `You are the runbook runner for {{name}}.
+
+The responder handed you a runbook. Execute it step by step. For each step:
+1. State what you'll do
+2. Show the exact command (do not run it yet)
+3. Ask for confirmation if the step is destructive
+4. After execution, report the outcome before moving on
+
+NEVER auto-execute: rm, kubectl delete, systemctl stop, drop table.
+Defer to escalator if the runbook doesn't cover what you're seeing.`;
+
+export const NAME = 'runbook-runner';
+export const TIER = 'haiku' as const;

package/templates/vertical_devops/src/init.ts.tmpl

@@ -0,0 +1,23 @@
+// SPDX-License-Identifier: MIT
+// {{name}} init — DevOps incident response harness entry point.
+
+import { loadKernel } from '@ruflo/kernel';
+import adapter from '@ruflo/host-{{host}}';
+
+const HARNESS_NAME = '{{name}}';
+const ROLE_AGENTS = ['responder', 'runbook-runner', 'escalator', 'postmortem'];
+
+async function main(): Promise<number> {
+  const kernel = await loadKernel();
+  const info = kernel.kernelInfo();
+  console.log(`${HARNESS_NAME} — DevOps incident response harness`);
+  console.log(`Kernel ${info.version} (${kernel.backend}), host: ${adapter.name}`);
+  console.log(`Agents available: ${ROLE_AGENTS.join(', ')}`);
+  console.log('Run `' + HARNESS_NAME + ' doctor` to verify the install.');
+  return 0;
+}
+
+main().then(c => process.exit(c)).catch(err => {
+  console.error(err);
+  process.exit(1);
+});

package/templates/vertical_education/.claude/commands/doctor.md.tmpl

@@ -0,0 +1,12 @@
+---
+description: "Health-check the harness: kernel load, MCP wiring, memory backend, host adapter."
+---
+
+Run a full health check and print a PASS/FAIL table.
+
+1. Kernel loads and `kernelInfo().version` matches package.json.
+2. The MCP server starts and lists its tools.
+3. The memory backend is reachable.
+4. The configured host adapter is present.
+
+Exit non-zero if any check fails.

package/templates/vertical_education/.claude/commands/mastery-report.md.tmpl

@@ -0,0 +1,12 @@
+---
+description: "Summarise the learner's current mastery map and recommend the next session's focus."
+---
+
+Generate the mastery report.
+
+1. Read the full mastery map from memory.
+2. Group concepts as: mastered (>0.85), in-progress (0.5-0.85), shaky (<0.5), and locked (prereq not mastered).
+3. Recommend 1-3 concepts for the next session, with the rationale ("X is in-progress and unlocks 4 downstream concepts").
+4. Flag any concepts where the miss-pattern suggests a deeper conceptual gap rather than rehearsal noise.
+
+Write the report; do not start teaching in this command.

package/templates/vertical_education/.claude/settings.json.tmpl

@@ -0,0 +1,45 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(npx {{name}}*)",
+      "mcp__{{name}}__*",
+      "mcp__mastery_log__*",
+      "mcp__curriculum__*"
+    ],
+    "deny": [
+      "Read(./.env)",
+      "Read(./.env.*)",
+      "Bash(rm -rf*)",
+      "Bash(git push*)"
+    ]
+  },
+  "mcpServers": {
+    "{{name}}": {
+      "command": "npx",
+      "args": [
+        "-y",
+        "{{name}}@latest",
+        "mcp",
+        "start"
+      ]
+    },
+    "mastery_log": {
+      "command": "npx",
+      "args": [
+        "-y",
+        "{{name}}@latest",
+        "mcp",
+        "mastery"
+      ]
+    },
+    "curriculum": {
+      "command": "npx",
+      "args": [
+        "-y",
+        "{{name}}@latest",
+        "mcp",
+        "curriculum"
+      ]
+    }
+  }
+}

package/templates/vertical_education/.claude/skills/memory-inspect/SKILL.md.tmpl

@@ -0,0 +1,14 @@
+---
+name: memory-inspect
+description: Search and inspect the harness memory namespace (HNSW + emergent-time decay).
+---
+
+# memory-inspect
+
+Inspect what the harness has learned.
+
+- `search <query>` — semantic nearest-neighbour over the namespace
+- `list` — recent patterns with decay weight
+- `forget <id>` — evict a pattern
+
+Use this before planning so the harness reuses prior trajectories instead of starting cold.

package/templates/vertical_education/.claude/skills/teach-next/SKILL.md.tmpl

@@ -0,0 +1,16 @@
+---
+name: teach-next
+description: "Run one teaching cycle: pick next concept → explain → quiz → grade → update mastery."
+---
+
+# teach-next
+
+Run one complete teaching cycle.
+
+1. Tutor reads the mastery map and picks the next concept whose prereqs are mastered.
+2. Explainer teaches it in 3 layers, pausing for "ready to go deeper?" between layers.
+3. Quiz-master generates 3-5 calibrated items mixing recall/apply/transfer.
+4. Grader scores the responses against the hidden rubric and writes mastery memory.
+5. Surface the smallest re-explanation needed for any item the learner missed.
+
+Always respect the abstain floor — never invent supporting facts to fill in for a concept the harness doesn't actually know.

package/templates/vertical_education/CLAUDE.md.tmpl

@@ -0,0 +1,33 @@
+# {{name}}
+
+{{description}}
+
+> Education / Tutoring harness · domain: `learning`. Generated with [create-agent-harness](https://github.com/ruvnet/agent-harness-generator).
+
+## Behavioral rules
+
+- Use the harness's MCP tools (`mcp__{{name}}__*`) for orchestration
+- Memory and routing are handled by the kernel — you don't need to learn them
+- Defer destructive operations to the user
+
+## Agents
+
+| Agent | Tier | Role |
+|---|---|---|
+| `tutor` | sonnet | Picks the next concept to teach from the learner's mastery map. |
+| `explainer` | sonnet | Explains the picked concept at the right depth. |
+| `quiz-master` | haiku | Generates calibrated quiz items. |
+| `grader` | sonnet | Grades open-ended responses against the hidden rubric. |
+## Skills
+
+- `/memory-inspect` — Search and inspect the harness memory namespace (HNSW + emergent-time decay).
+- `/teach-next` — Run one teaching cycle: pick next concept → explain → quiz → grade → update mastery.
+
+## Commands
+
+- `doctor` — Health-check the harness: kernel load, MCP wiring, memory backend, host adapter.
+- `mastery-report` — Summarise the learner's current mastery map and recommend the next session's focus.
+
+## Architecture
+
+This harness uses [@ruflo/kernel](https://www.npmjs.com/package/@ruflo/kernel) — a Rust-compiled WASM module with a NAPI-RS native fallback — so the same code runs identically on every platform.

package/templates/vertical_education/README.md.tmpl

@@ -0,0 +1,30 @@
+# {{name}}
+
+{{description}}
+
+> **Education / Tutoring** — Tutor → explain → quiz → grade, over per-learner mastery memory with an abstain-not-hallucinate policy.
+>
+> Generated with [`create-agent-harness`](https://github.com/ruvnet/agent-harness-generator). WASM kernel, multi-host support, witness-signed releases.
+
+## Install
+
+```bash
+npm install -g {{name}}
+{{name}} init
+{{name}} doctor
+```
+
+## Agents
+
+| Agent | Role |
+|---|---|
+| `tutor` | Picks the next concept to teach from the learner's mastery map. |
+| `explainer` | Explains the picked concept at the right depth. |
+| `quiz-master` | Generates calibrated quiz items. |
+| `grader` | Grades open-ended responses against the hidden rubric. |
+
+This harness ships with the **{{host}}** adapter.
+
+## License
+
+MIT

package/templates/vertical_education/manifest.json

@@ -0,0 +1,96 @@
+{
+  "id": "vertical:education",
+  "description": "A tutoring pod — tutor, explainer, quiz-master, grader over a per-learner mastery memory.",
+  "domain": "learning",
+  "category": "Knowledge",
+  "files": [
+    {
+      "src": "package.json.tmpl",
+      "dst": "package.json",
+      "render": true
+    },
+    {
+      "src": "CLAUDE.md.tmpl",
+      "dst": "CLAUDE.md",
+      "render": true
+    },
+    {
+      "src": "README.md.tmpl",
+      "dst": "README.md",
+      "render": true
+    },
+    {
+      "src": ".claude/settings.json.tmpl",
+      "dst": ".claude/settings.json",
+      "render": true
+    },
+    {
+      "src": "src/init.ts.tmpl",
+      "dst": "src/init.ts",
+      "render": true
+    },
+    {
+      "src": "src/agents/tutor.ts.tmpl",
+      "dst": "src/agents/tutor.ts",
+      "render": true
+    },
+    {
+      "src": "src/agents/explainer.ts.tmpl",
+      "dst": "src/agents/explainer.ts",
+      "render": true
+    },
+    {
+      "src": "src/agents/quiz-master.ts.tmpl",
+      "dst": "src/agents/quiz-master.ts",
+      "render": true
+    },
+    {
+      "src": "src/agents/grader.ts.tmpl",
+      "dst": "src/agents/grader.ts",
+      "render": true
+    },
+    {
+      "src": ".claude/skills/memory-inspect/SKILL.md.tmpl",
+      "dst": ".claude/skills/memory-inspect/SKILL.md",
+      "render": true
+    },
+    {
+      "src": ".claude/skills/teach-next/SKILL.md.tmpl",
+      "dst": ".claude/skills/teach-next/SKILL.md",
+      "render": true
+    },
+    {
+      "src": ".claude/commands/doctor.md.tmpl",
+      "dst": ".claude/commands/doctor.md",
+      "render": true
+    },
+    {
+      "src": ".claude/commands/mastery-report.md.tmpl",
+      "dst": ".claude/commands/mastery-report.md",
+      "render": true
+    }
+  ],
+  "vars": [
+    {
+      "name": "name",
+      "prompt": "Harness name (kebab-case)",
+      "validate": "^[a-z0-9-]+$"
+    },
+    {
+      "name": "description",
+      "prompt": "One-line description",
+      "default": "Tutor → explain → quiz → grade with adaptive depth and a \"say I do not know\" floor"
+    },
+    {
+      "name": "host",
+      "prompt": "Host adapter",
+      "default": "claude-code",
+      "choices": [
+        "claude-code",
+        "codex",
+        "pi-dev",
+        "hermes"
+      ]
+    }
+  ]
+}

package/templates/vertical_education/package.json.tmpl

@@ -0,0 +1,30 @@
+{
+  "name": "{{name}}",
+  "version": "0.1.0",
+  "description": "{{description}}",
+  "type": "module",
+  "bin": {
+    "{{name}}": "./bin/{{name}}.js"
+  },
+  "files": ["bin/**", "dist/**", ".claude/**", "CLAUDE.md", "README.md", "LICENSE"],
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest run --passWithNoTests",
+    "init": "node ./dist/init.js"
+  },
+  "dependencies": {
+    "@ruflo/kernel": "^0.1.0",
+    "@ruflo/host-{{host}}": "^0.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "^5.4.0",
+    "vitest": "^2.0.0"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/templates/vertical_education/src/agents/explainer.ts.tmpl

@@ -0,0 +1,7 @@
+// SPDX-License-Identifier: MIT
+// Explainer agent — Explains the picked concept at the right depth.
+
+export const SYSTEM_PROMPT = `You explain the concept the tutor picked. Start from the analogy or example most likely to land given the learner's prior masteries. Build the new concept in three layers: the one-line intuition, the worked example, then the formal statement. Stop after each layer and ask if the learner is ready to go deeper — never dump all three at once. If you do not know, say so; do not invent supporting "facts". You operate inside the {{name}} harness; defer destructive actions to the user.`;
+
+export const NAME = 'explainer';
+export const TIER = 'sonnet' as const;

package/templates/vertical_education/src/agents/grader.ts.tmpl

@@ -0,0 +1,7 @@
+// SPDX-License-Identifier: MIT
+// Grader agent — Grades open-ended responses against the hidden rubric.
+
+export const SYSTEM_PROMPT = `You grade the learner's response against the rubric the quiz-master attached. Award partial credit for correct reasoning that misses the bottom line; deduct for the answer-by-pattern-match without the reasoning. Write to mastery memory: concept, item id, score, miss pattern, and the smallest re-explanation the explainer would give to close the gap. Be the encouraging-but-honest voice. You operate inside the {{name}} harness; defer destructive actions to the user.`;
+
+export const NAME = 'grader';
+export const TIER = 'sonnet' as const;

package/templates/vertical_education/src/agents/quiz-master.ts.tmpl

@@ -0,0 +1,7 @@
+// SPDX-License-Identifier: MIT
+// Quiz Master agent — Generates calibrated quiz items.
+
+export const SYSTEM_PROMPT = `You generate quiz items targeted at the concept just taught. One concept per item; mix recall, application, and transfer in 1:2:1 ratio. Calibrate difficulty using the learner's previous miss rate in memory — too easy is noise, too hard is demoralising. Every item carries a hidden rubric the grader will use; never reveal the rubric to the learner. You operate inside the {{name}} harness; defer destructive actions to the user.`;
+
+export const NAME = 'quiz-master';
+export const TIER = 'haiku' as const;

package/templates/vertical_education/src/agents/tutor.ts.tmpl

@@ -0,0 +1,7 @@
+// SPDX-License-Identifier: MIT
+// Tutor agent — Picks the next concept to teach from the learner's mastery map.
+
+export const SYSTEM_PROMPT = `You are the tutor. Read the learner's mastery map from memory and pick the next concept whose prerequisites are mastered but the concept itself is not. State the goal in one sentence the learner can hold in their head. Never teach something whose prerequisite is unmastered — fix the prerequisite first. Adapt depth to the learner's grade level and stated style preferences in memory. You operate inside the {{name}} harness; defer destructive actions to the user.`;
+
+export const NAME = 'tutor';
+export const TIER = 'sonnet' as const;

package/templates/vertical_education/src/init.ts.tmpl

@@ -0,0 +1,21 @@
+// SPDX-License-Identifier: MIT
+// Generated by create-agent-harness — your harness's `{{name}} init` entry.
+
+import { loadKernel } from '@ruflo/kernel';
+import adapter from '@ruflo/host-{{host}}';
+
+const HARNESS_NAME = '{{name}}';
+
+async function main(): Promise<number> {
+  const kernel = await loadKernel();
+  const info = kernel.kernelInfo();
+  console.log(`${HARNESS_NAME} — kernel ${info.version} (${kernel.backend})`);
+  console.log(`Host adapter: ${adapter.name}`);
+  console.log(`Run \`${HARNESS_NAME} doctor\` to verify the install.`);
+  return 0;
+}
+
+main().then(c => process.exit(c)).catch(err => {
+  console.error(err);
+  process.exit(1);
+});

package/templates/vertical_exotic/.claude/commands/doctor.md.tmpl

@@ -0,0 +1,12 @@
+---
+description: "Health-check the harness: kernel load, MCP wiring, memory backend, host adapter."
+---
+
+Run a full health check and print a PASS/FAIL table.
+
+1. Kernel loads and `kernelInfo().version` matches package.json.
+2. The MCP server starts and lists its tools.
+3. The memory backend is reachable.
+4. The configured host adapter is present.
+
+Exit non-zero if any check fails.