-
scripts/orchestrator.py — THE ENTRY POINT. run(task) executes the whole flow, gated by
triage FIRST: execution_policy.triage decides the SKIP (trivial → EXPRESS, token economy)
and the escalation floor (hard problem / low MCFE reliability → DEEP+) automatically → dissect by
discipline → assign a specialist agent + skills + diffs per discipline (via gravity, with
gap→skills.sh install requests) → pick the mode → PMI convergence. run never raises
(ERROR_DEGRADED on unexpected failure). KERNEL CHECKLIST + GATE (v1.43, mandatory):
run returns a boolean kernel_checklist — code-owned steps come back DONE with evidence;
each llm-owned step carries the EXACT next call in llm_actions (passagem de bastão). You
MUST execute the missing steps, mark each with complete_step(checklist, STEP, evidence),
and re-run orchestrator.gate(checklist) — a run is NOT complete until the gate says
COMPLETE. Never skip a step; the gate returning RETURN_TO_LLM means the work goes back to you.
-
scripts/pot.py — Program-of-Thought: run_chain([{name,code}]) runs each step
in a separate subprocess and chains outputs. run_parallel() only for slow steps.
Hardened v1.52.0: scrubbed env (no parent-secret inheritance), disposable working dir,
output capped, process-tree killed on timeout. This is crash/leak CONTAINMENT, not a
security sandbox for hostile code — real isolation still needs an OS container.
-
scripts/numeric.py — rk4(deriv,s0,dt,steps) / euler(...) for multidimensional
ODE systems. Prefer RK4 (orders of magnitude more accurate). solve_ode(...,method="auto") uses
scipy's adaptive solver when importable (higher accuracy), else the stdlib RK4 — acceleration
is environment-gated (a fact of the runtime, not the LLM); capabilities() reports numpy/
scipy/sklearn/pandas presence. Precision Claude lacks alone.
-
scripts/uco_gate.py — gate(code): objective code check before running (loop risk,
dead code). Uses UCO if present, else an AST fallback.
-
scripts/verify.py — verify_identity(lhs,rhs): symbolic proof/refutation via sympy.
-
scripts/router.py — route(task,catalog): rank skills by relevance (TF-IDF).
-
scripts/skill_scout.py — fetch (allowlist only) + AST-scan + STAGE an external skill.
-
scripts/snapshot.py — standardized session state with provenance-carrying findings.
-
scripts/hypothesis_dag.py — faithful port of APEX hypothesis_dag (SR_32): DFS acyclicity,
BFS O(V+E) cascade with visited_set, edge-only snapshot, >200-node reset. Full API.
-
scripts/mental_interpreter.py — mental_interpreter_v4 core: the n_final planning
formula, entropy_weighted_merge, and the SPECULATION→WARMUP→PLANNING→PRODUCTION phase plan.
-
scripts/code_genetics.py — vaccine store: crystallizes error→fix patterns with O(1)
lookup, stable signatures, promotes a fix only after it proves out (>0.85 over >=2 uses).
-
scripts/geodesic_scheduler.py — orders pipeline steps by ΔH/token (greedy + lookahead),
ethical steps get infinite cost (SR_34), rollback if >115% baseline tokens.
-
scripts/verification_gate.py — routes only risky hypotheses to verification (P≠NP
insight): per-mode triggers, budget gate (SCIENTIFIC 25%), premature pruning.
-
scripts/fractal_compression.py — prunes the hypothesis space per fractal level (dominance,
anchor-jaccard merge >0.80, skill refutation, absurdity), keeps >=2.
-
scripts/geometry_estimator.py — DELTA_ERR by step-doubling + optimal_block_size [5,30];
supplies n_num to the planning formula.
-
scripts/apex_st_metric.py — inter-session progress dS2 = a|dMCFE|2+b|dInfo|2+g|dCoh|2 (all
positive), curvature class + stagnation trigger.
-
scripts/guards.py — enforceable APEX guards SR_36..SR_40: JIT crystallization thresholds
(per-class 0.02/0.05/0.08), forge load gate (SR_37 strict AST+allowlist), external-critic
ordering (SR_38), runtime guard + [SIMULATED]/[SANDBOX_PARTIAL] marker (SR_39), and the
zero-ambiguity linter (SR_40) — which this skill's own scripts now all pass.
-
scripts/skill_forge.py — native APEX skill generator (neoformat-valid create/promote).
-
scripts/asset_manager.py — manage/route all mined assets: 213 agents, 39 indexed
third-party assets, 23 MCP servers. route(need), summary(), mcps(domain).
-
scripts/bayes.py — the APEX Bayesian layer computed for real: beta-binomial update,
posterior over hypotheses, Omega decision (adopt 0.72 / review 0.5), and the R_acum
reliability gate (product over window 20; <0.50 replan, <0.30 early-exit). Wired into PMI.
-
scripts/gravity.py — gravitational synergy engine: treats scripts/agents/skills/diffs
as bodies with mass, computes attraction, and MERGES the most synergistic ones into a
cross-type constellation. constellation(task); plan(task) adds gap-detection + a
skills.sh install request + MCP fallback when the library lacks a needed resource (e.g. SA/HMC).
v1.59: _load caches parsed catalogs keyed by (mtime,size) — no more re-parsing the same
JSONs per call — invalidated on any catalog edit so it never serves stale data.
-
scripts/universal_code_optimizer_v4.py — the nativized UCO engine (author's own);
uco_gate.py now uses it directly for real metrics (Hamiltonian, loop risk, dead code).
-
scripts/repo_bridge.py — FULL APEX repo integration: load any of the 3,784 native
skills (search_native + native_skill), any of the 213 agents (agent), any of the
111 boot pages (page), or any repo file (fetch) — from a local clone or GitHub raw
(allowlisted, redirect-checked, size-capped; pin a commit via APEX_REPO_REF). Content is
data until vetted (SR_37/H5 still apply before anything runs).
-
scripts/_tfidf.py — pure-python TF-IDF fallback: router/gravity/agent_registry (and
therefore the orchestrator) keep working when scikit-learn is not installed. Also ships an
optional semantic layer (semantic_rank, char-n-gram / sentence-transformers) that fixes
the cross-language TF-IDF weakness — router.route(..., backend="char") or env
APEX_ROUTER_BACKEND=char routes a PT task against an EN catalog correctly.
-
scripts/taxonomy.py — canonical ENGLISH facet classifier (domain / subdomain / intent /
platform) with bilingual PT+EN triggers: classify(text) reduces a task or resource to
language-independent facets and facet_score(a, b) is the weighted facet-overlap attraction —
a PT task and an EN skill attract on MEANING, immune to name collisions ("mobile"→T-Mobile).
Wired as orchestrator.dissect's first no-keyword fallback (audit: shipped orphan in v1.41).
SELF-EVOLVING (v1.56, two-tier SQLite): the base tables are a seed; learned vocabulary lives
in a durable INDEXED SQLite overlay (APEX_METHOD_HOME/library/taxonomy_evolved.db, stdlib) so it
scales by PARTIAL lookup — classify() queries ONLY the task's tokens (term IN (…)), never loads
the whole file, and adds zero overhead when no overlay exists. HOT tier triggers(term,axis,facet, status,uses); COLD tier term_meta(term,en,pt,validated_by,ts). evolve(task, domain, subdomain, …) (from finalize on a validated success) records terms CANDIDATE→ADOPTED after PROMOTE_N
validations (classify reads ADOPTED only — one run never pollutes it). translate(term, en, pt) is
the LLM-validated bilingual pair (propagates facets to both languages). relate_facets(a, b, rel)
records dependency/escalation in the EXISTING Knowledge Graph (memory.relate vocabulary — no new
relation language). v1.55 JSON overlays migrate once, losslessly. The base also adds the
engineering domain + structural/geotechnical/mechanical/electrical subdomains (a structural task
classifies as engineering/structural, not the old legal/calculus mislabel). See
references/self-evolution.md.
-
scripts/attraction_graph.py — the PRECOMPUTED gravitational routing JSON
(catalog/attraction_graph.json): every skill/script/diff/agent is a node; edges carry
attraction weights (mass×mass×cosine, top-K per node). expand(seeds) is the attraction
chain — find the FIRST competency a task needs and everything that completes/potentiates it
attracts along the edges, no re-discovery; equip_for(need) seeds from the task. Call
rebuild() after every new skill/script/diff inclusion so the super-structure keeps growing.
-
scripts/agent_spawn.py — the SPAWN CONTRACT (agents are executable at spawn time):
spawn(agent_id, task, mode, stance) assembles the full AgentSpec — real persona (AGENT.md),
real skills/diffs/scripts attracted via the graph, durable grants (equip/unequip, survive
reload), learning history, governance, output template, and a boolean spawn checklist.
NEVER spawn a subagent from a bare name; refuse spawn_ready=False. spawn_contract() is
the how-to-spawn directive; equip()/unequip() promote/demote abilities durably (H5).
CONTEXT PACK (v1.44 — context beats prompt): context_pack(task) assembles a bounded,
provenance-carrying briefing from VALIDATED experience — durable vaccines (error→fix lessons),
deduped memory, PROVEN/DEMOTED personas (learning), rag_index pointers — and every spawn()
injects it into the agent's window; orchestrator.run attaches the session-level pack too, so
future instances never reason cold. AGENT BUNDLE: export_agent(id) serializes a TRAINED
agent (persona + grants + validated history + provenance, SHA-256 signed);
import_agent(bundle, approved=True) installs it on another machine (fail-closed integrity +
H5) — agents become portable, verifiable, evolving artifacts.
-
scripts/agent_lifecycle.py — the CLOSED-LOOP agent pipeline (v1.53, the O-2 full flow):
run(task) wires the eight steps end to end — dissect (orchestrator.dissect) → competence
matrix (taxonomy.classify: discipline→subdomain→specialization) → tools/diffs (gravity.plan)
→ find-or-create agent (match_task_to_ext_agents/repo_bridge.agent; if none clears the
bar, spawn(synthesize=True) fabricates a generic-but-honest persona from the facets) → validate
equipment + discovery cascade (native search_native → skills_sh → GitHub) → STAGE a
skill_forge scaffold when nothing is found → executable spec for the host to run. After a
validated run, finalize(task, agent_id, matrix, validated=True) EVOLVES the library — records
the outcome (learning), persists equipment durably (agent_registry.save_grant), drops a
memory anchor, and re-syncs the node RAG (rag_index.sync). GATES: nothing auto-installs/equips
(H5); the library evolves ONLY on a validated success (no reputation poisoning). The host
executes the subagent and authors any forged skill body — Python returns the plan, not the run.
LEARN FROM FAILURE (v1.54): finalize(..., validated=False, error=…, why=…) (or
record_failure) does NOT promote, but records a DEMOTION + a VACCINE (the error text + WHY it
was wrong) so context_pack surfaces it next time as LESSONS/DEMOTED — the same mistake is
not repeated. The swap carries promoted (grants/learning), demoted (learning), and error→why
(vaccines) across machines. See references/self-evolution.md.
-
scripts/agent_materializer.py — GENERIC→SPECIALIST crystallization (v1.54, the
auto-evolutive library): on a validated success, materialize(agent_id, matrix, validated=True, …)
renders the grown agent as a STANDARDIZED AGENT.md (canonical frontmatter: agent_id / anchors /
activates_in / capabilities / input_schema / output_schema / what_if_fails / security /
primary_domain, plus honest origin: grown_from_generic_spawn) and each forged skill as a
standardized SKILL.md, writes them to the durable grown-library
(APEX_METHOD_HOME/library/{agents,skills}), and registers the specialist in the roster
overlay (agent_registry.register_grown_agent, anchored on facets + salient task terms) so
NEXT session resolve_agent finds the specialist instead of re-synthesizing. finalize calls
this automatically for a grown (generic-…) agent. consolidate_to_repo(repo_root, commit=False)
copies the grown artifacts into the repo's agents/grown/ + skills/grown/ and STAGES a git
commit (H5) — never auto-commits. A generic that solved a problem becomes a permanent,
discoverable engineer. See references/self-evolution.md.
-
scripts/rag_index.py — SOLID-STATE node RAG (v1.47, the author's crystallized-memory
architecture): nodes for modules/catalogs/references/repo-areas/capabilities AND per-chapter
SECTIONS extracted from each document's outline, every node carrying its taxonomic DIMENSION
(discipline→specialization→mode) + content hash. search() returns the MACRO view (dim, who
it affects via the exact import matrix, what it attracts, parent section) — no remapping.
v1.60 (pointers by default, expand on demand): search() hands back POINTERS (id + path +
summary[:160] + relations as ids); when the LLM decides WHICH node matters, expand(id)
pulls only that node — the FULL stored summary/section (not the truncated one), resolved macro
relations, and, for a doc, its section children — trading "re-read the whole file" for "fetch
exactly the node" (aliases resolve; missing id → {found:False}).
sync() is the INCREMENTAL trigger: only changed nodes re-embed, deleted ones prune in
cascade, renames become ALIASES (hash fast-path + cosine >= 0.85; identity preserved,
resolve() follows). merge_index(other) fuses divergent instance states (idempotent, local
wins). overview() is the crystallized memory: a DETERMINISTIC macro map (no timestamps —
same content = same prompt prefix = provider prompt-cache hit). LOAD IT FIRST in every new
session instead of remapping the repository. Full build() refreshes the global IDF.
v1.50 (closes item 3): search(..., dim="mathematics/simulation") filters by the
taxonomic matrix (prefix match on discipline/specialization/mode — the TagRAG idea via the
dims every node already carries). solid_prefix() is the STABLE-PREFIX CONVENTION:
provider KV/prompt caches match prefixes token-by-token, so EVERY session/spawn prompt must
open with this deterministic block (overview + stable environment + governance constants),
put semi-stable task context next, and the volatile question LAST — identical content =
cache hit = cheaper prefill. Never edit inside the prefix mid-session.
v1.48 — REPO-WIDE + SEMANTIC DRIFT: the index now covers the 111 BOOT PAGES (registry
purpose + YAML head; boot:<module> nodes) and reference-docs/ with per-chapter sections
(refdoc: nodes, local clone). sync() also detects SEMANTIC DRIFT (the author's spec):
Jaccard over a node's old vs new term neighborhood < 0.30 = the MEANING changed, not just
the text — the node is flagged (drifted, with dim before/after) and the result recommends
to realign the topology.
-
scripts/capability_map.py — TOOL-USE MEMORY (v1.45): maps every capability the runtime
can wield — the 46 syscalls' CLIs, INSTALLED skills (SKILL.md commands/triggers, scans
~/.claude/skills + APEX_SKILLS_DIRS), design/document templates, and a REAL environment probe
(languages on PATH, importable libraries). how_to("como faço X?") answers with the capability
- exact commands via the node RAG;
record_use(id, success) feeds real outcomes into learning
so "I know how to extract the maximum from X" is EARNED (promotion), never assumed. Mapping
documents commands — it NEVER executes them (gates/H5 still govern). rebuild() after every
install, together with attraction_graph + rag_index (the three memories grow as one).
-
scripts/routine_composer.py — the persona composes its OWN ROUTINE (v1.46): a chained
flow of COMPLEMENTARY capabilities that potentiate each other (the canonical example: UX/UI +
color-psychology/marketing + CSS/HTML5 transitions + SQL + responsive performance + audit for
a NON-generic landing page). Canonical stages (research→design→marketing→frontend→backend→
performance→verify); every step carries WHAT TO SEND and WHAT YOU RECEIVE (I/O contracts from
capability_map), and each step's receive feeds the next step's send. Candidates come from
capability_map + attraction_graph + curated; learning boosts the PROVEN and removes the
DEMOTED; stages with no capable tool become HONEST GAPS that drive the discovery cascade + H5.
Routines persist per persona (travel in the swap bundle), record_routine_outcome promotes by
real results, and record_feedback turns external LLM audits + user positive feedback into
memory with provenance + equip/unequip/discover SUGGESTIONS (H5 decides). spawn() injects the
routine — the agent knows HOW to work, not just WITH WHAT. RUN LOOP (v1.47):
start_run/record_step_result/finish_run — the persona RUNS the routine and the routine
LEARNS: each step's handoff is rewritten with what was REALLY received (persisted, feeds the
next step's send), real outcomes auto-PROMOTE/DEMOTE the routine, and a failed step becomes a
durable vaccine (future context).
-
scripts/pipeline_dsm.py — the DSM turned on the runtime itself (v1.45): EXACT module
import matrix (parallel load levels, cycles, load-bearing core) + per-mode step flow ordered
by geodesic ΔH/token (run/skip + [APPROX] savings: EXPRESS ~5.1k tokens saved, STANDARD ~3.8k).
Two APPLIED optimizations, one per token direction: context_budget(mode) sizes the
context_pack injection (what ENTERS — 0 on EXPRESS → 2000 chars on RESEARCH), and its v1.58
twin output_budget(mode) sizes the ANSWER (what LEAVES — output tokens cost ~5x input on
Opus 4.8). output_budget compresses generation on cheap paths (compress:True + a terse
directive on EXPRESS/STANDARD) and keeps full verbosity on DEEP+ where the reasoning chain is
the deliverable — the caveman output-compression idea applied only where it is safe, with code/
commands/paths/numbers always preserved verbatim. orchestrator.run emits both on every call.
-
scripts/federation.py — FEDERATION (v1.50, unblocked by the per-device ledger):
export_pack() builds a SIGNED knowledge pack carrying ONLY gate-validated learning
(PROMOTED personas/routines, promotable vaccines, approved grants) + the exporting device's
ledger chain as verifiable PROVENANCE (SHA-256; HMAC when both sides set APEX_FED_KEY).
verify_pack() fails closed (schema, signature, chain re-verified link by link);
import_pack(pack, approved=True) requires the H5 human gate, merges LOCAL-WINS
(idempotent re-import), and appends the sender's intact chain to the local ledger.
Successful experience from one instance becomes evolution input for all — with governance.
TRANSPORT (v1.51): publish_pack() is the publication routine — pack -> staging/ tier
(canonical versioned name) -> apex-method/federation/packs/ in the local repo clone ->
git COMMIT (the DISK of the RAM->SWAP->DISK hierarchy; push/PR stays a user action).
Content-addressed by knowledge hash: republishing without new learning = ALREADY_PUBLISHED.
The return path after git pull: list_published() (each pack verified) ->
import_from_repo(approved=True) (H5 per pack, local-wins, idempotent).
CLI: python scripts/federation.py publish | list-remote | import-repo --approved.
-
scripts/token_tracker.py — REAL token measurement per round/step (OPP-99, v1.47):
every FULL_PIPELINE run records the payload each kernel step produced (chars/4 proxy,
declared); with >=3 samples the MEASURED average replaces the [APPROX] estimate in
pipeline_dsm.mode_flow (calibration map says measured vs estimated). First real data:
DISSECT ~6tk vs 80 estimated; CONTEXT_PACK ~119tk vs 350. report() shows where estimates
were wrong. capability_map scans also got an incremental cache (mtime+size; unchanged
SKILL.md served from cache, deleted pruned) for hundreds of installed skills.
-
scripts/monte_carlo.py — REAL Monte Carlo (OPP-73): simulate(model_fn, distributions)
returns P10/P50/P90 + CV. Wired into PMI so QUANTIFIABLE candidates are decided by simulation,
never by calling a weighted vote "Monte Carlo" (§10). numpy optional (stdlib fallback).
-
scripts/skills_sh.py — skills.sh marketplace discovery: leaderboard()/search()/
official() query the registry ranked by installs and keep only skills over a quality bar
(default >=1000 installs, the find-skills convention). Read-only JSON allowlist; emits
npx skills add owner/repo as STAGED (H5) — never auto-installs. Degrades to ready-to-run
discovery commands offline. Wired into gravity.plan (native -> skills.sh -> GitHub).
