Mentor

---

name: ocas-mentor source: https://github.com/indigokarasu/mentor install: openclaw skill install https://github.com/indigokarasu/mentor description: Use when managing long-running multi-skill workflows, evaluating skill performance from journals, comparing champion vs challenger variants, or proposing skill improvements to Forge. Trigger phrases: 'manage this project', 'coordinate a multi-step analysis', 'evaluate skill performance', 'run a heartbeat', 'how are skills performing', 'update mentor'. Do not use for web research (use Sift), skill building (use Forge), or user communication (use Dispatch). metadata: {"openclaw":{"emoji":"🎓"}}

---

Mentor

Mentor is the system's control plane — in runtime mode it decomposes goals into task graphs, supervises execution across skills, and dynamically repairs failures through a layered escalation policy from local retry up to full strategy replan. In heartbeat mode it reads journals from every skill, scores OKR performance against baselines, and generates improvement proposals that flow to Forge and Fellow for empirical evaluation and promotion.

Mentor and Elephas are parallel journal consumers: Mentor reads journals to evaluate skill performance, Elephas reads them to extract entity knowledge into Chronicle, and neither blocks the other.

When to use

Manage a long-running multi-step project

Coordinate work across multiple skills

Evaluate skill performance from journal data

Compare champion vs challenger variant runs

Generate improvement proposals for Forge

When not to use

Web research — use Sift

Building new skills — use Forge

User communication — use Dispatch

Behavioral pattern analysis — use Corvus

Responsibility boundary

Mentor owns orchestration, evaluation, and the improvement loop.

Mentor does not own: skill building (Forge), behavioral pattern detection (Corvus), behavioral refinement (Praxis), knowledge graph (Elephas), web research (Sift), communications (Dispatch), experimentation execution (Fellow).

Mentor proposes improvements; Forge builds them. Mentor detects regressions; Praxis extracts behavioral lessons from Corvus signals.

Commands

mentor.project.create — create a project with goal, constraints, and requested output

mentor.project.status — current project state, task graph, execution progress

mentor.project.replan — trigger strategy-level replan

mentor.task.list — tasks with statuses, dependencies, blocking reasons

mentor.heartbeat.light — lightweight pass: ingest journals, update aggregates, queue work

mentor.heartbeat.deep — deep pass: full scoring, trend analysis, proposals

mentor.variants.list — active champion/challenger pairs with evaluation status

mentor.variants.decide — emit promotion decision for a variant (writes VariantDecision to Forge intake)

mentor.proposals.list — pending skill improvement proposals

mentor.proposals.create — generate a VariantProposal for a target skill (writes to Forge intake)

mentor.status — active projects, pending evaluations, self-improvement metrics

mentor.journal — write journal for the current run; called at end of every run

mentor.update — pull latest from GitHub source; preserves journals and data

mentor.plan.list — list available plans with plan_id, version, and description

mentor.plan.run {plan_id} [--arg name=value ...] — execute a named workflow plan

mentor.plan.status {plan_run_id} — current state of a running or recent plan run

mentor.plan.resume {plan_run_id} — continue a paused or failed plan run from the first incomplete step

mentor.plan.history [--plan plan_id] [--limit N] — recent plan run summaries

Mode A — Runtime orchestration

Triggered by explicit invocation. Creates a project record, builds a task graph, executes and supervises tasks, dynamically replans when blocked.

Task states: pending, ready, running, blocked, failed, complete, archived.

Scheduling: execute only tasks with complete dependencies. Prioritize critical path. Bounded parallelism. Bounded retries.

Mode B — Heartbeat evolution

Triggered periodically. Pipeline: ingest journals → validate schema → aggregate metrics → pair champion/challenger → score OKRs → detect anomalies → evaluate variants → generate proposals → emit decisions → write journal.

Mentor reads journals from all skills at: ~/openclaw/journals/ (recursive scan). It tracks which run_ids have been ingested via ~/openclaw/data/ocas-mentor/ingestion_log.jsonl.

Run completion

After every Mentor command (orchestration or heartbeat):

1. Check ~/openclaw/data/ocas-mentor/intake/ for CycleResult files from Fellow; process and move to intake/processed/ 2. Persist project state, evaluation results, or proposals to local files 3. For experiment requests: write ExperimentRequest file to ~/openclaw/data/ocas-fellow/intake/{experiment_id}.json, then invoke fellow.experiment.run 4. For variant proposals: write VariantProposal file to ~/openclaw/data/ocas-forge/intake/{proposal_id}.json 5. For variant decisions: write VariantDecision file to ~/openclaw/data/ocas-forge/intake/{decision_id}.json 6. Log material decisions to decisions.jsonl 7. Write journal via mentor.journal

Layered evaluation loops

Layer 1 — Micro Action (ms-sec): validate single outputs. Retry, local repair, fallback.

Layer 2 — Task Execution (sec-min): ensure task completion. Retry, switch skill, split task.

Layer 3 — Strategy (min-hr): improve active project plan. Reorder, insert, merge, parallelize.

Layer 4 — Evolution (hr-wk): improve skills and policies. Propose variants, promote/archive.

Failure repair policy

Order: retry with refined framing → alternate skill → split task → revise ordering → escalate to strategy loop. Never retry indefinitely. Every repair action journaled.

Safety invariants

Challenger variants never execute side effects

Comparisons only on identical normalized inputs

Malformed journals quarantined, not trusted

Promotion requires sufficient evidence over multiple runs

Mentor journals its own orchestration decisions

Inter-skill interfaces

Mentor writes ExperimentRequest files to: ~/openclaw/data/ocas-fellow/intake/{experiment_id}.json Written when empirical evaluation is needed. Mentor then invokes fellow.experiment.run. Fellow writes the result back.

Mentor receives CycleResult files from Fellow at: ~/openclaw/data/ocas-mentor/intake/{cycle_id}.json Read during mentor.heartbeat.light and mentor.heartbeat.deep. On decision: promote, Mentor emits a VariantDecision to Forge.

Mentor writes VariantProposal files to: ~/openclaw/data/ocas-forge/intake/{proposal_id}.json Mentor writes VariantDecision files to: ~/openclaw/data/ocas-forge/intake/{decision_id}.json

See spec-ocas-interfaces.md for schemas and handoff contracts.

Mentor reads journals from: ~/openclaw/journals/ (all skills, recursive). This is a read-only scan parallel to Elephas ingestion.

Storage layout

~/openclaw/data/ocas-mentor/
  config.json
  projects/
  evaluations/
  ingestion_log.jsonl
  decisions.jsonl
  intake/
    {cycle_id}.json
    processed/
  plans/
    {plan_id}.plan.md
  plan-runs/
    {plan_run_id}/
      state.json
      decisions.jsonl
~/openclaw/journals/ocas-mentor/
  YYYY-MM-DD/
    {run_id}.json

Default config.json:

{
  "skill_id": "ocas-mentor",
  "skill_version": "2.3.0",
  "config_version": "1",
  "created_at": "",
  "updated_at": "",
  "heartbeat": {
    "light_interval_minutes": 15,
    "deep_interval_hours": 24
  },
  "evaluation": {
    "minimum_runs_for_promotion": 20,
    "non_regression_required": true
  },
  "retention": {
    "days": 0,
    "max_records": 10000
  }
}

OKRs

Universal OKRs from spec-ocas-journal.md apply to all runs.

skill_okrs:
  - name: orchestration_success_rate
    metric: fraction of projects reaching completion without manual rescue
    direction: maximize
    target: 0.85
    evaluation_window: 30_runs
  - name: evaluation_coverage
    metric: fraction of skill journals ingested within one heartbeat cycle
    direction: maximize
    target: 0.99
    evaluation_window: 30_runs
  - name: variant_decision_quality
    metric: fraction of promotions not rolled back within 30 days
    direction: maximize
    target: 0.90
    evaluation_window: 30_runs
  - name: repair_escalation_rate
    metric: fraction of failures requiring strategy-level escalation
    direction: minimize
    target: 0.10
    evaluation_window: 30_runs

Optional skill cooperation

Forge — receives VariantProposal and VariantDecision files via intake directory

Fellow — invoked by Mentor to run controlled benchmark experiments; returns best variant result

Elephas — Mentor may read Chronicle (read-only) for evaluation context

Corvus — Mentor may read Corvus pattern data for anomaly context

All skills — Mentor reads journals from all skills for evaluation

Journal outputs

Action Journal — every orchestration run, heartbeat pass, variant evaluation, and proposal emission.

Initialization

On first invocation of any Mentor command, run mentor.init:

1. Create ~/openclaw/data/ocas-mentor/ and subdirectories (projects/, evaluations/, intake/, intake/processed/, plans/, plan-runs/) 2. Write default config.json with ConfigBase fields if absent 3. Create empty JSONL files: ingestion_log.jsonl, decisions.jsonl 4. Create ~/openclaw/journals/ocas-mentor/ 5. Ensure ~/openclaw/data/ocas-forge/intake/ exists (create if missing) 6. Ensure ~/openclaw/data/ocas-fellow/intake/ exists (create if missing) 7. Copy bundled plans from skill package references/plans/*.plan.md to ~/openclaw/data/ocas-mentor/plans/ -- skip any plan file already present (do not overwrite user-modified plans) 8. Register cron jobs mentor:deep and mentor:update if not already present (check openclaw cron list first) 9. Register heartbeat entry mentor:light in HEARTBEAT.md if not already present 10. Log initialization as a DecisionRecord in decisions.jsonl

Background tasks

| Job name | Mechanism | Schedule | Command | |---|---|---|---| | mentor:deep | cron | 0 5 * * * (daily 5am) | mentor.heartbeat.deep — full OKR scoring, trend analysis, variant proposals | | mentor:light | heartbeat | every heartbeat pass | mentor.heartbeat.light — ingest journals, update aggregates, queue work | | mentor:update | cron | 0 0 * * * (midnight daily) | mentor.update |

Cron options for mentor:deep: sessionTarget: isolated, lightContext: true, wakeMode: next-heartbeat.

Registration during mentor.init:

openclaw cron list
If mentor:deep absent:
openclaw cron add --name mentor:deep --schedule "0 5 * * *" --command "mentor.heartbeat.deep" --sessionTarget isolated --lightContext true --wakeMode next-heartbeat --timezone America/Los_Angeles
If mentor:update absent:
openclaw cron add --name mentor:update --schedule "0 0 * * *" --command "mentor.update" --sessionTarget isolated --lightContext true --timezone America/Los_Angeles

Heartbeat registration: append mentor:light entry to ~/.openclaw/workspace/HEARTBEAT.md if not already present.

Self-update

mentor.update pulls the latest package from the source: URL in this file's frontmatter. Runs silently — no output unless the version changed or an error occurred.

1. Read source: from frontmatter → extract {owner}/{repo} from URL 2. Read local version from skill.json 3. Fetch remote version: gh api "repos/{owner}/{repo}/contents/skill.json" --jq '.content' | base64 -d | python3 -c "import sys,json;print(json.load(sys.stdin)['version'])" 4. If remote version equals local version → stop silently 5. Download and install:

   TMPDIR=$(mktemp -d)
   gh api "repos/{owner}/{repo}/tarball/main" > "$TMPDIR/archive.tar.gz"
   mkdir "$TMPDIR/extracted"
   tar xzf "$TMPDIR/archive.tar.gz" -C "$TMPDIR/extracted" --strip-components=1
   cp -R "$TMPDIR/extracted/"* ./
   rm -rf "$TMPDIR"
   

6. On failure → retry once. If second attempt fails, report the error and stop. 7. Output exactly: I updated Mentor from version {old} to {new}

Visibility

public

Support file map

| File | When to read | |---|---| | references/schemas.md | Before creating projects, tasks, proposals, or decisions | | references/orchestration_engine.md | Before goal decomposition, scheduling, or failure repair | | references/evaluation_engine.md | Before journal ingestion, OKR scoring, or champion/challenger pairing | | references/evolution_engine.md | Before improvement detection, proposal generation, or promotion decisions | | references/journal.md | Before mentor.journal; at end of every run | | references/workflow_plans.md | Before any mentor.plan.* command | | references/plans/template.plan.md | When writing a new plan file | | references/plans/contact-enrichment.plan.md | When running the contact enrichment workflow |