theorems-harness

Plugin theorems-harness from marketplace codex-marketplace in Travis-Gilbert/claude-marketplace. Commands read from the repo's manifest — 1 month ago.

Skills (37)

• agent-contracts

  Use when interpreting or designing Harness MCP, GraphQL, HTTP, pagination, truncation, error, idempotency, budget, or receipt behavior and a universal contract must not be assumed.

• agent-interop

  Use when invoking the composed agent, sending durable Head Calls, or reasoning about A2A and ACP boundaries, with strict identity, tenant, budget, receipt, approval, and live-provider evidence discipline.

• ambition

  Use when scoping, planning, building, or reviewing whether an implementation matches the full capability implied by the user's request.

• browser-web

  Browser-use web tools over RustyWeb. Use when the user wants to navigate to a live page and extract from it, co-browse with a human in the loop, or ingest a page into the graph. Triggers on "browse to", "go to this page and get", "navigate and extract", "co-browse with me", "browse with me", "consum

• claudeai-session-writer

  Use on every substantive turn of a claude.ai conversation with Travis (or any operator who shares the harness substrate). Writes the turn's decisions, commitments, and architectural shifts into Commonplace through the harness MCP tools so Claude Code, Codex, and the next claude.ai session can read t

• commitments-policy

  Use when a task needs scoped standing decisions, structured coordination claims, canonical typed commitments, policy receipts, or the still-Rust-only typed claim and constitution-refusal boundaries.

• compute_code

  Use this skill for native code ingest, status, search, context, explanation, specification, drift, feature, or implementation-obligation work. Prefer the typed Harness GraphQL code fields; use the consolidated CodeCrawler flat tools as compatibility fallbacks. Use RustyRed inline graph algorithms on

• context-management

  Use when a task needs Harness Context Brief status, explanation, lease reuse, explicit compilation, invalidation, generation history, span disposition, or an honest account of the current UserPromptSubmit, PostToolUse, and PreCompact hook boundary.

• coordination-operations

  Use for Harness coordination rooms, durable streams, dispatch jobs, multi-head work graphs, session spawning, service readiness, or active-catalog questions, with exact state, cursor, tenant, and execution-proof boundaries.

• curiosity

  Use this skill when the user is investigating, explaining, or trying to understand a target entity and related graph context may be useful.

• data-reconstruction

  Use when an agent must query Data records or instant-KG views, run flat-only DATAWAVE or entity resolution, or compose source reconstruction while preserving source pins, receipts, unknowns, and unresolved obligations.

• design-engineering

  Use when the user says design engineering, design mode, token audit, CSS audit, APG check, UI accessibility check, or invokes /design-engineering; and when designing, implementing, reviewing, debugging, or encoding design systems, CSS, design tokens, accessible components, APG fixtures, typography,

• dispatch

  Use for the current Harness dispatch job board or the distinct GitHub Actions session-spawn handoff. Triggers on queue, job board, submit, note, archive, receiver, or spawn session.

• encode

  The Harness memory-write capability. Use when the user runs /encode, when a session produces a durable lesson, or when an agent should preserve a feedback signal, solution, postmortem, decision, preference, or continuity pack into the shared harness memory substrate.

• execute

  Use when the user asks to implement, fix, ship, simplify, run tests, reconcile a checklist, or carry a bounded task through code changes and validation. This is an internal execution capability of Theorem's Harness, not a tunnel that prevents planning, diagnosis, coordination, or context refresh whe

• graph-lisp

  Use when an agent needs bounded pure Graph Lisp read, eval, diff, or explain through the dynamic gateway or GraphQL, including fuel, permission, graph-version, receipt, and effect-isolation semantics.

• graph-storage

  Use for Harness graph reads, algorithms, designated indexes, admin bulk mutations, graph-version values, resources, or storage readiness, while distinguishing callable projections from Rust-only storage internals.

• graph-version

  Use for the current flat graph-pack compile, diff, caller-carried refs/log/checkout, and three-way merge value operations without claiming a durable remote graph-git repository or live rollback.

• graph_theorem

  Query and traverse the current Theorem graph through typed GraphQL or exact flat MCP graph surfaces. Use for neighbors, schema, algorithms, vector/full-text/spatial retrieval, relational queries, or index diagnostics.

• harness-coordinate

  Teach and run Theorem's current cross-head coordination protocol. Use for shared intent, presence, messages, durable records, task-reference rooms, streams, mentions, semantic overlap, or handoff without inventing retired aliases.

• identity-bindings

  Use when a task needs to inspect or explain the authenticated Harness principal, project, session, actor, binding, head set, scopes, budget, or their admission provenance without accepting caller-supplied identity claims.

• learning-evolution

  Use when a task concerns Harness outcomes, calibration, ReasoningBank, GEPA candidates, programmable-graph evolution, or theorem-evolve scoring and promotion, especially to distinguish callable remote seams from Rust-only learning APIs.

• peer-review

  Coordinate cross-frontier-model review between Claude Code and Codex. Use at the end of multi-agent work, before commit or PR, or whenever the user asks one agent to review another agent's diff.

• planning-theorem

  The Harness planning capability, backed by the durable plan substrate. Use when the task needs stable acceptance criteria, a multi-session plan, a migration shape, or a plan worth handing to another agent. Reachable as /harness mode=plan or, for users who explicitly want planning, the /planning-theo

• practice-system

  This skill should be used when the user asks to "use superpowers", "follow a systematic workflow", "work test-first", "debug systematically", "verify before completion", "use agents where valuable", or asks how Harness practices compound across runs. It teaches the source-attributed Harness practice

• programmable-wasm

  Use when a task involves installed Theorem app WASM exports or the durable programmable WASM lifecycle, and the agent must distinguish callable dynamic affordances from the Rust-only publish, promote, inspect, invoke-selected, receipt, and rollback kernel.

• replay-last-run

  This skill should be used when the user asks to replay the last Harness run, inspect what actually happened, audit event order, verify a persisted state hash, trace a failed run, or asks what tools and transitions fired. It uses only the registered replay_last_run contract and its GraphQL projection

• research

  The Harness research capability. Use when the user wants fractal expansion, gap-frontier discovery, code-symbol discovery, or a compact research brief grounded in Theseus evidence. Reachable as /research or as part of the /harness adaptive loop when the task needs evidence before commitment.

• rust-engineering

  Use when writing, reviewing, debugging, explaining, encoding, or improving Rust code, Cargo workspaces, Rust MCP/server crates, Rust validators, PyO3/FFI bridges, async Rust services, parsers/macros, systems code, Ensemble pack selection, affordance charters, or Rust skill-pack corpus work.

• session-offload

  Use this skill when a sub-task ends, a tool result is verbose, a decision or assumption should be preserved, or a plan step has just completed and should stop occupying live context.

• solvers

  Use when a task needs bounded constraint checking or pack optimization through the stable ConstraintCheck and ConstraintOptimize dynamic affordances, including provider refusal, budgets, cancellation, provenance, and proof eligibility.

• surface-idea

  Capture a non-blocking idea or improvement that arose during the current task as a structured memory atom, instead of letting it drop in chat. Auto-fires at end-of-task and on inline idea markers. Manual via /surface-idea.

• symbolic

  Neuro-symbolic reasoning over the RustyRed substrate. Use when the user wants to derive facts from rules, forward-chain over the graph, apply a Datalog ruleset, score how reliable or trustworthy a source is, or decide whether a validation or check is worth running. Triggers on "derive facts", "apply

• theorems-harness

  Theorem's Harness default plugin skill. Use when the user invokes /harness or asks for grounded planning, implementation, debugging, review, context preparation, validation, reporting, cross-agent coordination, typed memory, encode, run lifecycle, replay, fractal search, code search, or harness-back

• theorize

  The Harness exploration capability. Use when the task is fuzzy, multiple real approaches exist, or a short option pass will save churn. Reachable as /harness mode=theorize or, for users who explicitly want exploration, the /theorize compatibility command.

• verified-cognition

  Use when a decision, consistency check, reconstruction, repair, or voice workflow must separate proposals from proof using real receipts and the source-owned verified-cognition protocol, while respecting its current unprojected boundary.

• writing-engineering

  This skill should be used when the user says "writing engineering", "writing mode", "prose mode", "write tight", "write plain", "engineered writing", or invokes /writing-engineering; and at Harness synthesis, report, handoff, coordination, and postmortem boundaries. It includes the pinned 1918 Eleme

Slash commands (11)

• /theorems-harness:compute_code

  Route code ingest, discovery, explanation, specification, drift, feature, or obligation work through Harness GraphQL first, with real flat MCP tools and inline graph algorithms as fallbacks.

• /theorems-harness:coordinate

  Coordinate with another head over the shared substrate: read the room, announce your own work and semantic overlap, and use @mentions only for blocks and forks.

• /theorems-harness:design-engineering

  Toggle the Design Engineering skill-pack mode for CSS, tokens, APG, motion, accessibility, and design-system work.

• /theorems-harness:encode

  Record a feedback signal, preference, durable solution, or postmortem in the shared harness memory substrate.

• /theorems-harness:execute

  Compatibility command for the Harness execution capability. Prefer /harness for new work; use this when the user explicitly wants implementation now. Accepts a slug, a path to a plan-shaped file, or a plain task description.

• /theorems-harness:harness

  The default Theorem's Harness command. Treats the user's intent as permission to use the best harness capability mix for the session: observe, route, plan, coordinate, execute, validate, peer-review, encode, and report as the work demands.

• /theorems-harness:peer-review

  Request or perform cross-frontier-model peer review between Claude Code and Codex.

• /theorems-harness:replay-last-run

  Replay the latest eligible Harness run or an explicit run and report its integrity receipt and event timeline.

• /theorems-harness:research

  Run Theorem's Harness research mode for fractal expansion, gap-frontier discovery, or code-symbol discovery.

• /theorems-harness:surface-idea

  Capture a non-blocking idea or improvement that arose during this task as a structured memory atom. Auto-fires at end-of-task; manual via slash.

• /theorems-harness:writing-engineering

  Toggle the Writing Engineering prose mode (plain/spare/wire), the harness analog of /caveman. Persistent until "normal mode".

Subagents (10)

• Agent Theorem
• action-rail-specialist

  Use this internal agent to produce an action rail with next actions, risk, validators, approval gates, expected outcomes, and delegated routes.

• checklist-manifest

  Use this agent when Orchestrate needs a codebase-grounded checklist manifest before work begins or a completion reconciliation after work ends. Typical triggers include clarifying what the user wants before implementation, comparing requested scope against the current codebase, identifying what must

• codex-sdk-harness-product

  Use this agent when Orchestrate needs a read-only SDK/product context brief for TheoremContextClient, TheoremHotGraphClient, current Plan actions, deterministic run replay, product graph routes, or TypeScript/Python SDK contract parity. Typical triggers include reconciling a product plan against the

• context-artifact-specialist

  Use this internal agent to define Context Artifact, Capsule, Brief, trust-boundary, token budget, and SDK/database harness context requirements.

• epistemic-graphrag-specialist

  Use this agent when Orchestrate needs a read-only GraphRAG or GNN-RAG context brief from THG or other graph evidence surfaces. Typical triggers include choosing retrieval operators, mapping evidence paths, preserving graph traces, and identifying tensions or memory graph opportunities. Do not use it

• federation-learning-recorder

  Use this internal agent to prepare local learning candidates and safe structural federation signals after an Orchestrate run.

• orchestrate-planner

  Use this internal agent to turn grounded context into a Harness Plan with stable checklist IDs, acceptance criteria, validation, risk, and execution instructions.

• plugin-router

  Use this internal agent to choose the next Theorem's Harness capability mix, specialist agents, validators, and direct-tool exposure recommendations for an adaptive harness run.

• validator-reporter

  Use this internal agent to choose validation commands, expected proof, result reconciliation, production gates, and final reporting gaps for an Orchestrate run.

MCP servers (1)

• theorems-harness

  connects to: https://rustyredcore-theorem-production.up.railway.app/mcp

Hooks (30)

• SessionStart

  ${CLAUDE_PLUGIN_ROOT}/scripts/hook-doctor.sh SessionStart

• SessionStart

  ${CLAUDE_PLUGIN_ROOT}/scripts/begin-run.sh

• SessionStart

  ${CLAUDE_PLUGIN_ROOT}/scripts/ambient-health-hook.sh

• SessionStart

  ${CLAUDE_PLUGIN_ROOT}/scripts/sessionstart-codebase.sh

• SessionStart

  ${CLAUDE_PLUGIN_ROOT}/scripts/lint-sessionstart.sh

• SessionStart

  ${CLAUDE_PLUGIN_ROOT}/scripts/inject-harness-directives.sh

• SessionStart

  ${CLAUDE_PLUGIN_ROOT}/scripts/sessionstart-writing-engineering.sh

• UserPromptSubmit

  ${CLAUDE_PLUGIN_ROOT}/scripts/hook-doctor.sh UserPromptSubmit

• UserPromptSubmit

  ${CLAUDE_PLUGIN_ROOT}/scripts/prepare-context.sh

• UserPromptSubmit

  ${CLAUDE_PLUGIN_ROOT}/scripts/ambient-health-hook.sh

• UserPromptSubmit

  ${CLAUDE_PLUGIN_ROOT}/scripts/code-neighborhood.sh

• UserPromptSubmit

  ${CLAUDE_PLUGIN_ROOT}/scripts/inject-harness-directives.sh

• UserPromptSubmit

  ${CLAUDE_PLUGIN_ROOT}/scripts/checklist-contract.sh

• UserPromptSubmit

  ${CLAUDE_PLUGIN_ROOT}/scripts/subagent-suggest.sh

• PreToolUse

  ${CLAUDE_PLUGIN_ROOT}/scripts/hook-doctor.sh PreToolUse

• PreToolUse

  ${CLAUDE_PLUGIN_ROOT}/scripts/auto-approve-harness.sh

• PreToolUse

  ${CLAUDE_PLUGIN_ROOT}/scripts/lint-pretool.sh

• PreToolUse

  ${CLAUDE_PLUGIN_ROOT}/scripts/enforce-action-rail.sh

• PreToolUse

  ${CLAUDE_PLUGIN_ROOT}/scripts/pretool-context.sh

• PostToolUse

  ${CLAUDE_PLUGIN_ROOT}/scripts/hook-doctor.sh PostToolUse

• PostToolUse

  ${CLAUDE_PLUGIN_ROOT}/scripts/record-action.sh

• PostToolUse

  ${CLAUDE_PLUGIN_ROOT}/scripts/posttool-context.sh

• PostToolUse

  ${CLAUDE_PLUGIN_ROOT}/scripts/posttool-event.sh

• PostToolUse

  ${CLAUDE_PLUGIN_ROOT}/scripts/delta-queue.sh

• PostToolUse

  ${CLAUDE_PLUGIN_ROOT}/scripts/lint-posttool.sh

• PostToolUseFailure

  ${CLAUDE_PLUGIN_ROOT}/scripts/lint-posttool.sh

• FileChanged

  ${CLAUDE_PLUGIN_ROOT}/scripts/filechange-context.sh

• FileChanged

  ${CLAUDE_PLUGIN_ROOT}/scripts/filechange-reingest.sh

• FileChanged

  ${CLAUDE_PLUGIN_ROOT}/scripts/delta-queue.sh

• Stop

  ${CLAUDE_PLUGIN_ROOT}/scripts/hook-doctor.sh Stop