Delentia Sovereign AI Operating System

Computes the FDIA safety score F = (D^I) x A to decide whether a proposed action should be authorized before it runs. F is a single 0.0-1.0 number that collapses to exactly 0 whenever A = 0 (no amount of good data can rescue an unauthorized action); otherwise it grows with D (data quality) raised to the I (intent precision) exponent. AUTHORIZED means F met the policy's safety_threshold (default 0.5); BLOCKED_PREEMPTION or a SECURITY_* verdict means it did not, or A was denied outright — read `verdict` and `reason` to decide how to proceed. USE WHEN: immediately before executing a specific action, especially one that is destructive, irreversible, or security/credential-sensitive. DO NOT USE WHEN: the action is routine and read-only (adds latency for no behavior change), you need to change the rules being checked (use configure_policy instead), or you are still planning multi-step work (use rct_think or orchestrate_swarm first, then evaluate_fdia on the resulting concrete action). OPTIONAL RCT-7 SYNTHESIS: pass `problem_statement` (and optionally `environment_context`/`target_desired_outcome`) instead of `intent_precision` to have this worker run the real RCT-7 7-stage decomposition and derive intent_precision from its actual alignment score (range 0.5-2.0) rather than you supplying an arbitrary number — the response then includes an `rct7_synthesis` field. Omit `problem_statement` for byte-identical behavior to before this option existed. Every call also steps a real, Durable-Object-persisted MEE growth tracker (delta = future_score - 0.5, a governance violation when unauthorized) and returns it as `mee_growth` — see `session_id` below to scope it per-caller instead of the shared deployment-wide default.

Sets the authorization policy that evaluate_fdia checks against FOR YOUR SESSION ONLY. REQUIRES `session_id`: the policy is stored in that session's Durable Object and applies only to evaluate_fdia calls that pass the same session_id; other callers, and calls without a session_id, keep using the deployment's default policy (which this tool cannot change). IMPACT: this is a full REPLACE of your session's policy, not a merge — any rule you don't include is dropped, so resend the complete rule set. REVERSIBLE: yes — call configure_policy again with the previous policy JSON to roll back; no automatic version history is kept, so save the current policy yourself before changing it if you may need to undo. PARAMETER A: each rule assigns a binary authorization gate via `assigned_A` — A=1 lets matching actions proceed to normal F=(D^I)*A scoring, A=0 hard-blocks them regardless of data quality (this is how you make a category of actions always fail evaluate_fdia). USE WHEN: onboarding a new action type, changing RBAC/role rules, or adjusting the safety threshold. DO NOT USE WHEN: you only need to check one action (use evaluate_fdia) or reason about a task (use rct_think) — and avoid calling it speculatively per-request.

Performs a structured 7-stage causal reasoning walkthrough (Observe, Analyze, Deconstruct, Reverse Reasoning, Identify Core Intent, Reconstruct, Compare with Intent) to produce an explicit, auditable reasoning trail before acting on a complex or ambiguous task. USE WHEN: a task has multiple plausible approaches or unclear scope and you want a documented plan before execution. DO NOT USE WHEN: the task is simple and unambiguous — this tool only produces a reasoning report, it does not check authorization (pair it with evaluate_fdia before acting) or execute anything itself (pair it with orchestrate_swarm or your own tooling to carry out the plan).

Compresses verbose conversation history, logs, or codebase context by deduplicating repeated content lines and, when `aggressive_mode` is true and `intent_focus` is provided, keeping only lines that contain the intent's meaningful keywords (plus one line of context on each side; skipped gaps are marked with "…"). Token reduction is computed fresh per request from the actual input (highly variable — near-zero or even negative on already-short/unique input, higher on repetitive logs) — it is not a fixed guaranteed range. USE WHEN: context is large or repetitive and approaching a token budget; supply `intent_focus` AND `aggressive_mode: true` for real filtering — otherwise only deduplication is applied (measured ~6-12% on real code/logs/docs). Measured on real code/logs/docs (benchmarks/compression-real): aggressive mode cut ~70-75% of tokens and kept the answer line for 100% of questions that reuse the source's words, but only ~60% of paraphrased questions — use the exact identifiers/terms you are looking for in `intent_focus`. DO NOT USE WHEN: you need the content reasoned about (use rct_think) or expect true semantic summarization — this is line-level filtering, not an LLM rewrite, so it can drop details a summarizer would keep.

Fetches lines from an original that compress_context stored (retain_original: true). Use it when the compressed text is missing something you need: search by terms (`pattern`: any of the space-separated terms, case-insensitive, with `context_lines` of surrounding lines) or by `start_line`/`end_line`. Returns numbered lines, capped at `max_lines` (default 200, max 400). Much cheaper than re-sending the whole original.

Decomposes a high-level objective into a JITNA packet — a 6-field record: I (Intent: a normalized action code derived from your objective), D (Data readiness, 0-100%), delta (gap remaining to completion = 100-D), A (which of the 4 pillars — Router, Guardian, Executor, or Scribe — is assigned as primary handler), R (a short rationale string), and M (a key-value memory/context map) — then returns a dispatch roster describing what each of the 4 pillars would handle. USE WHEN: you need to break a broad objective into role-based subtasks or want a standardized packet format for downstream coordination. DO NOT USE WHEN: you need to authorize or execute something — it does not call evaluate_fdia itself, so run evaluate_fdia separately on any subtask (especially ones routed to Executor) before acting on it.