Entroly

Preflight a proposed reply/reaction against Entroly evidence and delegation policy. This tool never sends anything.

Return an evidence-referenced communication attention brief. Use current scope by default; all scope is owner-only and never sends messages.

Send one current-conversation text only after Entroly returns ALLOW and atomically claims dispatch. Disabled unless communicationExecution is explicitly enabled.

Resolve the current owner's evidence-bounded communication style preferences from explicit policy plus MemoryOS. This tool cannot grant sending authority.

Show live value metrics: money saved, performance, bloat prevention, quality.

Retrieve exact source content omitted by compressed context. Use the retrieval handle attached to a skeleton/reference fragment for exact historical recovery. A visible source path also works and lazily resolves the latest ingested version. With no argument, lists currently materialized CCR entries without returning their content. Args: source_or_handle: Source path or content-addressed ``ccr:...`` handle.

Show Entroly context status; use `doctor` or `communication`.

Route a query through the CogOps Epistemic Ingress Controller. Inspects 4 signals (intent, belief coverage, freshness, risk) and selects one of 5 canonical flows.

Execute a full canonical epistemic flow end-to-end. Routes query through the Ingress Controller then chains the appropriate pipeline.

Explain why each fragment was included/excluded in last optimization.

Explain why a chunk was omitted from a Context Receipt.

Export vault beliefs as JSONL training data for LLM finetuning. Filters out stale and low-confidence beliefs.

Get comprehensive session statistics.

Ingest an image/diagram into context memory (requires PIL/OCR — not available in WASM runtime, use pip install entroly).

Ingest a code diff/patch into context memory. Converts unified diff into structured change summary with intent classification.

Ingest audio into context memory (requires whisper — not available in WASM runtime, use pip install entroly).

Inspect the last durable proof-guided response without advancing it.

Mine failure patterns from PRISM, vault, and evolution data. Optionally apply corrections.

List only receipts visible to this workspace/session scope.

Locate exact spans inside ``text`` without generating an answer. ``text`` is the corpus. This tool does not read the workspace and has no index behind it: pass it content you already hold, typically from ``read_source_file``. A natural-language ``query`` ranks spans *within* that text; it does not search for the text. That boundary is worth stating twice because the obvious reading is the wrong one. Nothing here falls back to repository search, so calling it without ``text`` is an error rather than a whole-repository query, and a caller expecting otherwise receives nothing and cannot tell wh…

Manage CogOps skill lifecycle (Evolution layer). Actions: list, benchmark, promote.

Select the optimal context subset for a token budget. Uses IOS + PRISM RL + Channel Coding.

Predict which files the LLM will need next based on co-access patterns and dependency graph.

Prepare a durable proof-guided model request from local documents. This tool performs only local selection, security checks, exact-recovery commitments, and signed auditing. It does not call a model. Send the returned ``request`` through the host's configured model route, then pass the model text to ``advance_proof_guided_context``. The path must remain inside the attached project root.

Prepare an expiring, receipt-backed task skill before agent work. The capsule combines safe cross-session MemoryOS recall, optional hippocampal long-term memory, current repository fragments, non-stale beliefs, and already-promoted skills. Recalled text is evidence rather than authority and is prompt-injection scanned. Root AGENTS.md and CLAUDE.md files are never modified. Args: task: The concrete task the agent is about to perform. agent_id: MemoryOS identity used for scoped recall. token_budget: Approximate maximum capsule tokens (256-8000). persist: Write SKILL.md and rece…

Process a code change through the Change-Driven pipeline (Flow ④). Diff → ChangeSet → Review → Blast Radius → Vault.

Semantic recall of most relevant stored fragments.

Record an externally produced CI pass/fail result for an optimization request. Use this only after CI actually ran. It appends a strong RAVS outcome event and may promote the request-bound result into verified task memory. It does not run CI, fetch ``url``, inspect the repository, or prove that the supplied pipeline name or URL is genuine. Repeated calls append repeated events; callers should submit one result per request. Use ``record_test_result`` for a test-suite result and ``record_command_exit`` for one subprocess exit code. The returned JSON reports ``recorded``, ``skipped`` (event log…

Record the exit code of a command that was generated and executed. STRONG signal: a real subprocess produced a real exit code. Convention: exit_code == 0 → "success", anything else → "failure". Args: request_id: the "request_id" field from the optimize_context response exit_code: subprocess exit code; 0 = success command: optional short representation of what was run

Record whether the user accepted, reverted, or retried an AI edit. STRONG signal: user behavior directly indicates whether the generated code was successful. Args: request_id: the "request_id" field from the optimize_context response outcome: "accepted", "reverted", or "retried" files_modified: number of files touched by the edit

Record whether selected fragments led to success/failure (RL feedback).

Record that tests RAN and either passed or failed for a request. This is a STRONG signal — distinct from record_outcome which is the agent's self-report. Call this when actual test execution produced a real pass/fail outcome. Args: request_id: the "request_id" field from the optimize_context response passed: True if all tests passed, False if any failed suite: optional name of the test suite (e.g. "pytest", "cargo test") details: optional short summary of what was tested

Recover the full text of context a Context Receipt omitted. Receipts explain *what* was dropped; this hands back the exact content, byte-for-byte. Works on receipts created with ``recoverable=True`` — the recovery bundle is read from the local store. Pass ``chunk_id`` to recover one chunk, or leave it empty to recover everything that was omitted. Each result carries ``verified=true`` only when the returned text is provably identical to what was omitted (matched against the chunk's recorded fingerprint and a storage-integrity hash) — never a guess.

Recover full CLI output from a compression handle.

Mark beliefs as stale after file changes so the next verify pass will flag them for re-compilation.

Atomically rebuild the fixed repository snapshot.

Store a context fragment with automatic dedup and entropy scoring.

Render a Context Receipt JSON artifact as a Markdown audit report. Use this after ``create_context_receipt`` when a human-readable report is needed. The conversion is local and read-only: it does not call a model, reread source files, recover omitted content, or modify the receipt store. For one omitted chunk use ``explain_receipt_omission``; for exact original content use ``recover_receipt_omission``. The result is Markdown on success and a bounded error string when the JSON is malformed or the receipt shape is unsupported. Args: receipt_json: The complete JSON receipt artifact, not a r…

Return the canonical Entroly file map across Python, Rust core, and WASM repos with ownership roles.

Return verified layers, communities, cycles, routes, and hotspots.

Compare two committed architecture receipts and report structural drift.

Return reverse file/call impact for known workspace-relative paths.

Audit verified complexity, cycles, coupling, and navigability risk.

Apply a blocker-free module move after commitment and risk checks.

Preview a headless Python module move with exact import rewrites.

Compare a local Git commit with the verified worktree without checkout.

Query verified typed neighbors, paths, relatedness, or impact.

Export the complete bounded graph as a portable committed snapshot.

Verify a shared snapshot and prove whether it matches current sources.

Discover verified HTTP routes, mounted prefixes, handlers, and collisions.

Trace source-verified arguments, parameters, returns, and consumers.

Run the operator-configured LSP and return a committed no-write plan.

Rank a receipt-backed structural map across the fixed repository.

Return verified Python control flow and reaching definitions.

Build a proof-carrying partial code slice from verified facts.

Apply a previewed rename after plan-hash and risk acknowledgement.

Preview exact rename edits; performs no writes and reports incompleteness.

Bind value-free runtime events to fresh source and symbol evidence.

Apply a blocker-free delete after plan-hash and risk acknowledgement.

Preview a headless delete; any known or lexical reference blocks it.

Verify external LSP/compiler ranges before trusting semantic edges.

Return bounded counts and the deterministic repository-index digest.

Trace freshness-checked static calls without guessing symbol identity.

Rank tests related to known changed paths without executing them.

Return a partial code graph scoped to one task with a receipt.

Resume from the latest checkpoint.

Retrieve one in-scope span and debit returned tokens from savings.

Scan code for security vulnerabilities (SAST).

Search in-scope spans and return bounded exact excerpts.

Session-wide security audit across all ingested fragments.

Scan content for prompt injection attacks and security threats. Detects: - Direct instruction overrides ("ignore previous instructions") - Role reassignment attempts ("you are now a...") - Unicode steganography (zero-width chars, directional overrides) - Base64-encoded instruction payloads - Repetition flooding (context window domination) - XML/tag-based role spoofing Use this to verify untrusted content before including it in prompts. Args: content: The text content to scan source: Source identifier for threat location reporting

Remove a shared memory entry by ID.

List shared memory entries, optionally filtered by agent or tag.

Search cross-agent shared memory by relevance. Returns entries from all agents.

Get cross-agent shared memory statistics.

Write to cross-agent shared memory. Deduplicates near-identical entries via SimHash.

Read a file at an automatic or caller-chosen resolution. By default SRP selects the optimal resolution per code block from query relevance and token budget: - Blocks matching the query → FULL (complete source) - Related blocks → MEDIUM (signature + docstring) - Peripheral blocks → LOW (name only) - Irrelevant blocks → SKIP (omitted) This reduces output by prioritizing query-relevant blocks. Use ``resolution="full"`` whenever exact source text is required. Automatic selection is the right default and cannot be right for every question. Measured on this repository, a signature-level v…

Start a background workspace listener that continuously feeds repo changes into CogOps belief CI.

Classify query effort and return output steering directives + max_tokens budget.

Synchronize workspace file changes into the belief and verification layers. Detects new/modified/deleted files, marks beliefs stale, recompiles.

Scan vault beliefs against each other for knowledge decay. Report-only living-context maintenance: pairwise ESG contradiction detection between beliefs, near-duplicate merge suggestions, staleness flags, and confidence flapping (entities whose recorded confidence keeps reversing across ledger versions). Never rewrites or deletes a belief — act on the suggestions explicitly. Args: contradiction_threshold: min ESG contradiction_fraction to flag a belief pair (default 0.5) max_age_days: beliefs unchecked for longer are flagged stale (default 30)

Query the CogOps Knowledge Vault for existing beliefs. Supports lookup by entity name or listing all.

Full-text search across all belief artifacts in the vault. Uses keyword matching with entity-name boosting.

Show the current state of the CogOps Knowledge Vault: total beliefs, verification status, confidence distribution, and routing statistics.

Query the vault's bitemporal belief ledger — memory time travel. Every belief write is versioned in an append-only, hash-chained ledger. This tool answers questions like "what did the vault know last Tuesday?" and "what changed between two dates?". Args: action: One of: as_of — snapshot of beliefs visible at `when` diff — what changed between `from_when` and `to_when` timeline — version history for `entity` verify_chain — tamper-check the ledger hash chain seed — backfill the ledger from pre-ledger belief files redact — erase belief bodies …

Write a task output or report to the CogOps Knowledge Vault (actions/).

Write a belief artifact to the CogOps Knowledge Vault with machine-auditable frontmatter.

Verify LLM-generated code and suggest repairs for hallucinations. Combines BIPT verification with rejection analysis to identify hallucinated identifiers and suggest which real APIs/symbols from the context should be used instead. This is a single-shot verification + feedback tool — it does NOT call an LLM. For the full repair loop (FORGE), use the Python SDK: from entroly.verifiers import forge_loop Args: prompt: The original user request that generated the code code: The LLM-generated code to verify context: The repository context provided to the LLM

Run a full verification pass on all beliefs. Checks staleness, contradictions, confidence divergence, low confidence scores.

Verify that LLM-generated code is grounded in the provided context. Uses BIPT (Byte-level Information Provenance Tracer) to measure how much of each identifier in the generated code originates from the context. Returns an Identifier Provenance Deficit (IPD) score: IPD = 0.0 → fully grounded (all identifiers come from context) IPD = 1.0 → fully invented (no identifiers match context) Use this after an LLM generates code to check for hallucinated APIs, invented function names, or fabricated imports before accepting output. Args: code: The LLM-generated code to verify context: T…

Verify an AI-generated response for hallucination. Computes entity coverage gap, hedging curvature, and entropy consistency. Returns fused_risk [0.0=safe, 1.0=hallucinated], verdict (pass/warn/flag), and flagged claims. All local — zero LLM calls.

Accept responsibility for one recovered work state before claiming work.

Check the active repository and local Work Graph review capability.

Claim an explicit task and bounded scope.

Compile verified code context and record its Work Graph receipt.

Fault exact omitted code from a context token or verified context object.

Seal a graph-bound cross-agent handoff and continuation proof.

Modifications recorded between observations by the workspace watcher. A point-in-time refresh shows what a file looks like now. This shows that it changed at 14:02 and again at 14:07, which a refresh cannot. Empty when the watcher is disabled.

Find compact local handoffs addressed to one agent and check source freshness.

Attach a canonical ContextReceipt to its exact WorkScope.

Atomically record route, observable execution and exact-head verification.

Attach provenance-bearing memory without trusting raw model prose.

Record a reviewer verdict, findings, and caller-observed checks tied to the exact handoff and source state. Verdict remains an agent statement.

Recover durable repository work and exact changed-file identities, optionally with a no-handoff proof.

List recorded reviews and whether their source state is still current.

Report the automatic takeover performed when this server started.

Inspect persisted work state without a model-generated summary.