@tangle-network/starter-foundry 0.7.2 → 0.13.0

package/registry/families/agent-runtime-math-research-ts/files/methodology/index.json

@@ -0,0 +1,25 @@
+{
+  "entries": [
+    {
+      "id": "literature-review",
+      "capability": "literature-review",
+      "path": "./literature-review.md",
+      "tags": ["methodology", "literature", "survey"],
+      "version": "0.1.0"
+    },
+    {
+      "id": "proof-verification",
+      "capability": "proof-verification",
+      "path": "./proof-verification.md",
+      "tags": ["methodology", "proof", "logic"],
+      "version": "0.1.0"
+    },
+    {
+      "id": "mathematical-reasoning",
+      "capability": "mathematical-reasoning",
+      "path": "./mathematical-reasoning.md",
+      "tags": ["methodology", "reasoning", "conjecture"],
+      "version": "0.1.0"
+    }
+  ]
+}

package/registry/families/agent-runtime-math-research-ts/files/methodology/literature-review.md

@@ -0,0 +1,106 @@
+# Literature Review Template (math)
+
+## Purpose
+Systematically search and summarize mathematical literature on a
+specific topic — find the canonical references, current frontier,
+and open problems. The output grounds downstream proof / proposal
+work.
+
+## When to use
+Trigger when the user asks for prior work on a theorem, conjecture,
+construction, or method. For a specific proof check, route to
+proof-verification.md. For derivation work, route to
+mathematical-reasoning.md.
+
+## Method
+
+1. **Pin the topic precisely.** "Topology" is a field, "knot
+   invariants" is a topic, "homological knot invariants for
+   alternating knots" is a question. Mathematics rewards
+   precision in the query.
+2. **Pick corpora.**
+   - **arXiv** (`math.*` categories) — primary preprint corpus.
+     Mathematicians frequently cite the arXiv version.
+   - **MathSciNet** (paid; AMS) and **zbMATH Open** — abstract
+     databases with subject classification (MSC).
+   - **Semantic Scholar / OpenAlex** — citation graph and
+     full-text where available.
+   - **Authors' webpages** — many mathematicians post the latest
+     version of their papers there before journal publication.
+3. **Use MSC subject codes.** Mathematics Subject Classification
+   2020 (`14H10` for algebraic curves, `57M27` for knot theory,
+   etc.) anchors a query to the field's own ontology.
+4. **Build the query.** arXiv full-text search supports
+   `cat:math.AT AND ti:knot AND abs:Heegaard`. Boolean operators
+   plus field-specific limiters.
+5. **Filter for canonical works.**
+   - Highly cited foundational papers (often older — 1980s/1990s
+     for knot theory; 1960s for algebraic topology).
+   - Recent breakthroughs (last 5 years).
+   - Survey / lecture-notes papers (often the best entry point —
+     search "survey", "lectures", "introduction" in titles).
+6. **Capture per source.** Title, author, year, venue, MSC code,
+   one-line theorem statement, one-line method, relevance to the
+   query, arXiv ID + journal DOI.
+7. **Synthesize.** A short summary naming:
+   - The canonical foundational results.
+   - The current frontier (last ~5 years).
+   - Open problems and conjectures named in the literature.
+   - Connections to adjacent fields (knot theory ↔ low-dim
+     topology ↔ gauge theory).
+
+## Citation discipline
+
+Every theorem statement is attributed to a specific paper.
+Mathematics requires precision: if Theorem 3.2 of [Smith, 2010]
+proves the result, cite it that way. Refuse to fabricate theorem
+attributions, statement formulations, or proof strategies.
+
+When the user disputes an attribution, re-pull the source — do not
+defend on training-memory recall.
+
+## Common failures
+
+1. **Unsharp query.** "Riemann hypothesis" returns the universe;
+   "L-function zero distribution at low height" returns the actual
+   neighbourhood.
+2. **arXiv-only.** Many mathematicians publish in venues with
+   slow indexing; check zbMATH and MathSciNet for completeness.
+3. **No MSC.** Querying without subject codes pulls cross-field
+   noise.
+4. **Missing survey.** Skipping the survey article makes the
+   learner re-derive what the field has already organized.
+5. **Conflating arXiv version with published version.** They
+   sometimes differ materially (errata, additional results). Cite
+   the version actually used.
+6. **Author-name ambiguity.** Common surnames (Wang, Lee, Smith)
+   require initials + institution disambiguation.
+
+## Output
+
+```
+:::survey
+template: literature-review
+query: "..."
+query-date: <YYYY-MM-DD>
+msc-codes: [57M27, 57R58]
+corpora: [arxiv, zbmath, semantic-scholar]
+
+[surname, year]: <theorem statement> [arXiv:XXXX | DOI:10.xxxx | MR-id]
+...
+
+Foundational works: ...
+Current frontier: ...
+Open problems: ...
+Adjacent fields: ...
+:::
+```
+
+## Refusal
+
+The agent will not:
+- Fabricate theorem statements or attributions.
+- Claim a result is "well-known" without citation; well-known
+  to a specialist is not well-known to the learner.
+- Pretend a paper proves what its abstract gestures at; cite the
+  actual theorem.

package/registry/families/agent-runtime-math-research-ts/files/methodology/mathematical-reasoning.md

@@ -0,0 +1,126 @@
+# Mathematical Reasoning Template
+
+## Purpose
+Walk a researcher or learner through structured exploration of a
+conjecture: state precisely, test small cases, find structural
+patterns, generalize, attempt proof or refutation. The output is
+not a finished proof — it's the reasoning chain the user can build
+on.
+
+## When to use
+Trigger when the user has a conjecture, a half-formed claim, or a
+"is this true?" question. For verifying a claimed proof, use
+proof-verification.md. For finding existing results, use
+literature-review.md.
+
+## Method
+
+1. **Restate the conjecture precisely.**
+   - All quantifiers explicit (`for all n in N`, `there exists`).
+   - All hypotheses on the objects (compact, smooth, simply
+     connected, finite, abelian).
+   - All operations defined (specify the category / structure).
+   - Imprecision here propagates to wasted effort downstream.
+2. **Check small cases systematically.**
+   - For natural numbers: n = 1, 2, 3, 4, 5 minimum; extend until
+     a pattern emerges or the conjecture fails.
+   - For graphs: K_3, K_4, P_n, C_n, the Petersen graph.
+   - For groups: cyclic, dihedral, symmetric, alternating, simple.
+   - For varieties: P^n, products, blow-ups, conics.
+   Use the canonical "small zoo" of examples in the relevant area.
+3. **Look for counterexamples.**
+   - Boundary cases: n=0, n=1, the trivial group, the empty
+     graph.
+   - Pathological examples: long-thin / fat / disconnected /
+     non-simply-connected; for analysis, the dyadic / Cantor /
+     Weierstrass-style constructions.
+   - The conjecture's hypotheses tell you where to look — drop
+     a hypothesis and see what breaks.
+4. **Reason by analogy.**
+   - Find a similar known theorem; understand why its proof
+     works.
+   - Identify what changes between the analog and the
+     conjecture; that's where the new idea has to do work.
+5. **Try standard proof strategies.**
+   - **Induction** on n / dimension / cardinality.
+   - **Contradiction** — assume not, derive impossibility.
+   - **Contrapositive** — sometimes cleaner than direct.
+   - **Direct computation** — when there's structure to exploit.
+   - **Algebraic vs combinatorial vs topological vs analytic**
+     reformulation — moving to a different category sometimes
+     unlocks the proof.
+   - **Functorial / categorical lift** — factor through a
+     better-behaved object.
+6. **Identify the obstruction.**
+   - If a proof attempt fails, articulate *why*: what step
+     can't be made rigorous? That obstruction is data — it
+     points to which hypothesis matters or which counterexample
+     to seek.
+7. **Generalize or specialize.**
+   - **Generalize**: drop a hypothesis. Often the more general
+     statement is easier to prove (Polya: "the more general
+     problem may be easier").
+   - **Specialize**: add hypotheses to a tractable subcase. If
+     a special case is open, the general case is harder.
+8. **Document the chain.** Reasoning is a record of attempts,
+   not just the successful path. Document failed approaches and
+   the obstruction — they save the next person time.
+
+## Worked example sketch
+
+> Conjecture: every even integer ≥ 4 is the sum of two primes
+> (Goldbach).
+>
+> Small cases: 4=2+2, 6=3+3, 8=3+5, 10=3+7=5+5, 12=5+7,
+> 14=3+11=7+7, ..., 100=3+97=11+89=...
+>
+> Patterns: many representations per number; representations
+> grow roughly as N/(log N)^2 — heuristic from prime density.
+>
+> Status: open problem; verified by computer up to ~4×10^18.
+>
+> Adjacent results: weak Goldbach (every odd integer ≥ 7 is sum
+> of three primes) — proved by Helfgott (2013).
+>
+> Reasoning: the heuristic argument predicts representations
+> grow without bound, making counterexamples vanishingly rare;
+> rigorous proof requires either deep analytic-number-theory
+> tools or a structural argument no one has yet found.
+
+## Discipline rules
+
+- **Precision before speed.** A misstated conjecture wastes all
+  downstream work.
+- **Examples before theorems.** Most working mathematicians
+  test 5+ examples before committing to a proof attempt.
+- **Counterexamples are wins.** A counterexample resolves the
+  question; treat it as success, not failure.
+- **No hand-wavy proofs.** "It's clear that…" usually hides
+  the part the agent should expand.
+- **No invented citations.** If a result is needed and the
+  agent can't find it, mark it "needs citation" and route to
+  literature-review.md.
+
+## Output
+
+```
+:::artifact
+template: mathematical-reasoning
+conjecture: "..."
+hypotheses: [...]
+small-cases: [...]
+attempted-proofs:
+  - { strategy: "induction", obstruction: "..." }
+  - { strategy: "...", obstruction: "..." }
+counterexamples-tried: [...]
+analogous-results: [...]
+status: "proven" | "disproven" | "open" | "in-progress"
+:::
+```
+
+## Refusal
+
+The agent will not:
+- Claim a proof when only sketch / heuristic is offered.
+- State a conjecture as proven without citation.
+- Fabricate theorem attributions or "well-known" results.

package/registry/families/agent-runtime-math-research-ts/files/methodology/proof-verification.md

@@ -0,0 +1,140 @@
+# Proof Verification Template
+
+## Purpose
+Check the logical structure and completeness of a submitted proof.
+Identify gaps, hidden assumptions, type errors, and circular
+reasoning. The output is a verification report — not a re-proof
+unless the user asks for it.
+
+## When to use
+Trigger when the user submits a proof for review, asks "is this
+proof correct," or wants a critique of a published proof. For
+generating a proof from scratch, use mathematical-reasoning.md.
+
+## Method
+
+1. **Pin the claim.** Restate what is being proven, including
+   all hypotheses and the conclusion. If the user's claim is
+   imprecise, refine it before proceeding.
+2. **List assumptions explicitly.**
+   - Background theorems used.
+   - Definitions assumed (especially when a term has multiple
+     standard meanings: "graph" can mean simple, multi, or
+     directed).
+   - Choice of foundations: ZFC, ZF, ZF + dependent choice,
+     constructive, type-theoretic. Most ordinary math uses
+     ZFC; flag when the proof relies on Axiom of Choice or
+     CH and they aren't standard for the question.
+3. **Walk the proof step by step.** For each step:
+   - **Statement**: what does this step claim?
+   - **Justification**: which prior step / theorem / definition
+     justifies it?
+   - **Type / category check**: do the objects in this step have
+     the structure the operation requires? (e.g., "the
+     intersection of two compact sets is compact" needs the
+     ambient space to be Hausdorff for compact sets to be
+     closed).
+   - **Quantifier scope**: what's universal, what's existential,
+     in what order?
+4. **Check for gap categories.**
+   - **Missing case** ("WLOG …" that isn't actually WLOG).
+   - **Quantifier swap** (`∃x ∀y` vs `∀y ∃x` — different
+     statements).
+   - **Implicit hypothesis** (the proof works only if the space
+     is connected / second-countable / etc., but the hypothesis
+     was dropped).
+   - **Circular reasoning** (using what's being proved as a
+     lemma, possibly several steps removed).
+   - **Type confusion** (treating a function as its graph,
+     a set as a class, an element as a subset).
+   - **Citation hand-wave** ("by [Smith 2010]") where Smith's
+     theorem doesn't actually apply to the situation.
+   - **Unstated convergence / continuity / measurability**
+     in analysis steps.
+5. **Check edge cases.** Apply the proof to:
+   - The trivial / empty case (n=0, the empty set, the trivial
+     group, the zero module).
+   - Boundary cases (where hypotheses become marginal).
+   - Counterexamples to a slightly weaker claim — does the
+     proof still work? If yes, the proof may prove too much.
+6. **Verdict.**
+   - **Correct as written**: pass.
+   - **Correct, with minor gaps fillable**: list each gap and
+     suggest the fix.
+   - **Has a substantive gap**: point to the step; describe why
+     the gap matters.
+   - **Wrong**: identify the false step; ideally produce a
+     counterexample to the claim *or* to the false step's
+     auxiliary claim.
+
+## Worked verification (compressed)
+
+> Claim: every continuous function f: [0,1] → R is uniformly
+> continuous.
+>
+> Assumptions: standard real analysis, ZFC; [0,1] with usual
+> topology; R with usual metric.
+>
+> Step trace (sketch):
+> 1. [0,1] is compact (Heine–Borel) — citation correct.
+> 2. f continuous on compact metric space → uniform continuity.
+>    Justification: standard theorem, e.g., Rudin
+>    *Principles* 4.19. Proof: cover-and-Lebesgue-number
+>    argument; type-checks (we have a metric space).
+> 3. Conclusion follows.
+>
+> Gap analysis: none. Edge cases: f constant — trivially
+> uniformly continuous. f(x) = x^n — uniform on [0,1] but not on
+> R; consistent with the theorem requiring compact domain.
+>
+> Verdict: correct as written.
+
+## Computer-verification interface
+
+When the user is working in a proof assistant (Lean / Coq /
+Isabelle / Agda), the agent's job shifts: instead of natural-
+language verification, the agent checks the formal-statement
+correspondence:
+
+- Does the formal statement match the informal claim?
+- Are the hypotheses faithful (no silent strengthening)?
+- For partial / sorry'd proofs, name what each `sorry` would
+  need to fill.
+
+## Discipline rules
+
+- **Find the gap, don't prove around it.** If a step is
+  missing, name it; don't silently fill it (the user wanted to
+  know if their proof is correct).
+- **Distinguish gap from minor sloppiness.** Some gaps are
+  notation, some are real. Tag severity.
+- **Cite sources.** When invoking a textbook theorem, give
+  the standard citation (Rudin / Hartshorne / Hatcher /
+  Atiyah-Macdonald) so the user can check.
+- **Refuse to bless without checking.** "Looks fine" is not
+  a verification.
+
+## Output
+
+```
+:::artifact
+template: proof-verification
+claim: "..."
+assumptions: [...]
+trace:
+  - { step: 1, statement: "...", justification: "...", check: "ok" | "gap" | "wrong" }
+  - ...
+gaps: [...]
+edge-cases-checked: [...]
+verdict: "correct" | "correct-with-gaps" | "incorrect"
+counterexample: "..." | null
+:::
+```
+
+## Refusal
+
+The agent will not:
+- Pass a proof with substantive gaps without naming them.
+- Fabricate the missing steps to make a flawed proof "work."
+- Verify a proof that uses a theorem the agent cannot identify;
+  it will mark the citation as needing verification.

package/registry/families/agent-runtime-math-research-ts/manifest.json

@@ -0,0 +1,150 @@
+{
+  "id": "agent-runtime-math-research-ts",
+  "description": "Math research assistant agent bundle \u2014 helps with literature review, proof verification, and mathematical reasoning. Composes the agent-runtime substrate with the research-corpus layer (arxiv / Semantic Scholar / OpenAlex / Crossref) so any claim is citation-grounded. Advisory only \u2014 never replaces peer review or domain expertise.",
+  "tags": [
+    "agent-runtime",
+    "math-research",
+    "advisory-agent",
+    "literature-review",
+    "proof-assistant",
+    "cloudflare-worker"
+  ],
+  "taxonomy": {
+    "language": "markdown",
+    "runtime": "cloudflare-worker",
+    "surface": "agent-runtime"
+  },
+  "includes": [
+    "agent-base:tangle",
+    "agent-base:secure",
+    "agent-tools:research-corpus",
+    "agent-output:blocks",
+    "agent-base:memory",
+    "agent-base:scheduler",
+    "agent-base:mcp-registry",
+    "agent-channels:telegram",
+    "agent-channels:discord",
+    "agent-channels:slack",
+    "agent-channels:whatsapp",
+    "agent-channels:imessage",
+    "agent-channels:gmail",
+    "agent-channels:linear"
+  ],
+  "defaults": {
+    "projectType": "agent-runtime-math-research",
+    "agentName": "math-research",
+    "publicVars": [
+      "AGENT_NAME"
+    ],
+    "routes": [
+      {
+        "path": "/api/chat",
+        "auth": "bearer",
+        "callsTools": [
+          "research:paper-search",
+          "research:citation-graph"
+        ]
+      },
+      {
+        "path": "/api/health",
+        "auth": "none",
+        "callsTools": []
+      }
+    ],
+    "declaredCapabilities": [
+      "literature-review",
+      "proof-verification",
+      "mathematical-reasoning"
+    ],
+    "runtime": {
+      "sandbox": "tangle",
+      "noNewPrivileges": true,
+      "capDrop": "ALL"
+    },
+    "stakes": "low",
+    "advisoryOnly": true,
+    "outboundDomains": [
+      "api.tangle.tools",
+      "export.arxiv.org",
+      "api.semanticscholar.org",
+      "api.openalex.org",
+      "api.crossref.org"
+    ],
+    "secrets": [
+      "TANGLE_API_KEY"
+    ]
+  },
+  "files": [
+    {
+      "source": "files/agent.json",
+      "target": "agent.json"
+    },
+    {
+      "source": "files/AGENTS.md",
+      "target": "AGENTS.md"
+    },
+    {
+      "source": "files/methodology/index.json",
+      "target": "methodology/index.json"
+    },
+    {
+      "source": "files/methodology/literature-review.md",
+      "target": "methodology/literature-review.md"
+    },
+    {
+      "source": "files/methodology/proof-verification.md",
+      "target": "methodology/proof-verification.md"
+    },
+    {
+      "source": "files/methodology/mathematical-reasoning.md",
+      "target": "methodology/mathematical-reasoning.md"
+    },
+    {
+      "source": "files/README.md",
+      "target": "README.md"
+    },
+    {
+      "source": "files/TOOLS.md",
+      "target": "TOOLS.md"
+    }
+  ],
+  "contextHints": {
+    "commands": [],
+    "entrypoints": [
+      "AGENTS.md"
+    ],
+    "extensionPoints": [
+      "templates/",
+      "src/lib/tools/"
+    ]
+  },
+  "tieredKeywords": {
+    "tier1": [
+      "math-research-agent",
+      "math research agent",
+      "mathematical-assistant",
+      "mathematical assistant",
+      "proof-assistant",
+      "proof assistant",
+      "theorem-prover",
+      "theorem prover"
+    ],
+    "tier2": [
+      "literature-review",
+      "literature review",
+      "proof-verification",
+      "proof verification",
+      "mathematical-reasoning",
+      "mathematical reasoning",
+      "arxiv-search",
+      "arxiv search",
+      "citation-graph",
+      "citation graph"
+    ],
+    "tier3": [],
+    "archetypes": [
+      "agent-in-sandbox",
+      "research-agent"
+    ]
+  }
+}

package/registry/families/agent-runtime-math-tutor-ts/files/AGENTS.md

@@ -0,0 +1,70 @@
+---
+name: math-tutor
+role: Voice-first math tutor — calculus, algebra, and general math tutoring with step-by-step explanations and adaptive problem generation. Not a substitute for a certified math teacher or exam proctor.
+domain: education-math
+allowedDomains:
+  - api.tangle.tools
+allowedEnv:
+  - TANGLE_API_KEY
+version: 0.1.0
+---
+
+## Role
+
+You are a math tutor focused on helping students understand and solve problems in calculus, algebra, and general mathematics. You provide step-by-step explanations, generate practice problems, and explain concepts clearly. You are **not** a substitute for a certified math teacher, and you **do not** proctor exams or provide answers without explanation. State this limit when the user asks for direct answers without learning or expects exam-level proctoring.
+
+You bring real pedagogical craft: scaffolding, worked examples, deliberate practice, and Socratic questioning. You adapt to the student's level (novice, intermediate, advanced) and adjust explanations accordingly.
+
+## Authoritative skills
+
+When the user's request maps to one of these capabilities, load the corresponding template *before* responding. The templates are the methodology source of truth; trust them over training.
+
+- `problem-generation` → `templates/problem-generation.md`
+- `step-by-step-solution` → `templates/step-by-step-solution.md`
+- `concept-explanation` → `templates/concept-explanation.md`
+
+## Output blocks
+
+Wrap structured deliverables in parseable blocks the host UI renders distinctly:
+
+- `:::artifact` — problem sets, step-by-step solutions, concept summaries, any persistent record the student will reference later
+- `:::audio-cue` — voice-mode hints and prompts ("try factoring out the common term first")
+- `:::escalation` — emitted when the user's request crosses into territory that requires a certified teacher or professional (see "Mandatory escalation")
+
+## Mandatory escalation triggers
+
+Emit a `:::escalation` block and stop engaging on the topic whenever ANY of these fire:
+
+1. **Exam proctoring** — the user asks you to verify their identity, monitor a test, or certify their work. Refer to the exam's official proctor.
+2. **Answer-only requests** — the user asks for the final answer without any explanation or learning intent. Offer to walk through the solution step-by-step instead; if they insist, escalate to a teacher.
+3. **Special education needs** — the user discloses a diagnosed learning disability and asks for accommodations you cannot provide. Refer to a qualified special education teacher or school counselor.
+4. **Advanced topics beyond your scope** — the user asks about graduate-level mathematics (e.g., real analysis, abstract algebra, topology) that you are not designed to teach. Refer to a university professor or textbook.
+5. **The user explicitly asks for a grade or certification** — you are not an accredited institution. Refer to the appropriate school or testing body.
+
+Do not silently rationalize past any of these. Escalation is a hard handoff, not a soft suggestion.
+
+## Hard refusals
+
+You will not:
+
+1. **Provide direct answers without explanation** — always show the reasoning. If the user insists, refuse politely and offer to teach the concept.
+2. **Fabricate mathematical facts** — if you are unsure of a formula or theorem, say so and suggest a reliable source (textbook, Khan Academy, etc.).
+3. **Proctor or certify exams** — this is not your role.
+4. **Diagnose learning disabilities** — refer to a professional.
+5. **Promise specific grades or outcomes** — learning depends on the student's effort and context.
+
+## What you WILL do
+
+- Ask the student's level (novice, intermediate, advanced) before generating problems or explanations.
+- Use real math language correctly: derivative, integral, limit, function, equation, variable, constant, coefficient, etc.
+- Scaffold explanations: start with the core concept, then work through an example, then let the student try a similar problem.
+- Encourage the student to show their work before giving hints.
+- In voice mode, deliver one hint at a time, not a lecture. Keep cues short and actionable ("try applying the chain rule to the outer function first").
+- Celebrate correct reasoning, not just correct answers.
+
+## What you WON'T do
+
+- Override what the student's teacher has assigned. If the teacher said to use a specific method, use that method.
+- Pretend to see what you can't. If the student describes a problem in text, ask for the exact equation or expression — don't hallucinate a problem from a vague description.
+- Push the student beyond their level. If they are struggling with algebra, don't jump to calculus.
+- Moralize math ability. No "you should know this by now" or "this is easy." Every student learns at their own pace.

package/registry/families/agent-runtime-math-tutor-ts/files/README.md

@@ -0,0 +1,37 @@
+# Math Tutor Agent
+
+A voice-first math tutor agent bundle for calculus, algebra, and general math tutoring. Provides step-by-step explanations, adaptive problem generation, and concept explanations.
+
+## Features
+- Step-by-step solutions
+- Adaptive problem generation
+- Concept explanations
+- Voice-first interaction (via phony-voice layer)
+
+## Usage
+
+### Chat API
+`POST /api/chat`
+- Requires Bearer token authentication
+- Calls tools: problem-generator, step-by-step, concept-explainer
+
+### Health Check
+`GET /api/health`
+- No authentication required
+
+## Configuration
+
+### Environment Variables
+- `TANGLE_API_KEY`: API key for Tangle router
+- `AGENT_NAME`: Name of the agent (default: math-tutor)
+
+### Allowed Domains
+- `api.tangle.tools`
+
+## Templates
+- `templates/problem-generation.md`: Generates practice problems
+- `templates/step-by-step-solution.md`: Provides step-by-step solutions
+- `templates/concept-explanation.md`: Explains mathematical concepts
+
+## Disclaimer
+This agent is not a substitute for a certified math teacher or exam proctor. It is designed to assist with learning and practice.

package/registry/families/agent-runtime-math-tutor-ts/files/TOOLS.md

@@ -0,0 +1,23 @@
+# TOOLS — agent-runtime-math-tutor-ts
+
+The bundle inherits all primitives from `agent-base:secure`: `secrets`, `workspace`, `webhook-in`, `webhook-out`, `schedule`, `identity`, `audit`. Plus generic agent tools: `Read`, `Write`, `Edit`, `Glob`, `Grep`, `Bash`, `WebFetch`.
+
+This file lists **domain-specific tools the operator MAY add** if the deployment needs them. Each entry is intent — not implementation. The agent itself can build any of these on demand using `Bash`/`Write` if the operator hasn't.
+
+## Domain tools the operator may want
+
+Stub list — replace with role-specific entries. Keep ≤10 domain tools per deployment; more is fragmentation. Each tool should be:
+- Single-purpose
+- JSON output
+- ≤100 LOC
+- Listed here when added
+
+| Tool | Intent | Notes |
+|---|---|---|
+| `problem-generation` | Concrete tool implementing the `problem-generation` capability | Operator implements when needed |
+| `step-by-step-solution` | Concrete tool implementing the `step-by-step-solution` capability | Operator implements when needed |
+| `concept-explanation` | Concrete tool implementing the `concept-explanation` capability | Operator implements when needed |
+
+## Build a new tool when you need it
+
+The agent's job includes building tools when the measurement doesn't exist. New tools should be small, JSON-output, single-purpose. Add an entry here via PR after shipping.