pentesting 0.100.7 → 0.100.10

package/ARCHITECTURE.md

@@ -54,11 +54,11 @@ bound expensive operations.
 - **One Security Surface** — Session, process, finding, flag verification, and
   frontier operations are ordinary tools. Engagement context, permission,
   resource budget, and proof remain separate responsibilities.
-- **Prompt Ownership** — Prompt mode owns Enter submission. Buffered replay may
-  preserve typed-ahead input, but live terminal control responses, redraws, and
-  resize noise are not allowed to turn a normal Enter into a pasted newline.
-  Modal return restores the transcript scroll region and its pre-modal saved
-  cursor before the fixed bottom UI is redrawn.
+- **Prompt Ownership** — Prompt mode owns Enter submission. Buffered replay may
+  preserve typed-ahead input, but live terminal control responses, redraws, and
+  resize noise are not allowed to turn a normal Enter into a pasted newline.
+  Modal return restores the transcript scroll region and its pre-modal saved
+  cursor before the fixed bottom UI is redrawn.
 - **Lab Session Multiplexing** — `shell-listener` runs multiple authorized TCP,
   local PTY, and local pipe sessions. A single actor exclusively owns each
   session's descriptors, command queue, transcript, raw log, and child
@@ -130,12 +130,11 @@ request hot path. Explicit event metadata is routed deterministically; absent
 metadata receives one general strategy. Named profiles may add context, but
 coarse labels do not authorize or reject tool calls.
 
-CTF engagement metadata may select `ctf-competition` prompt context, and
-`flag_check` remains a verification tool and evidence source rather than a
-default completion gate. `explore` is always available; `[exploration]` only
-sets node and fan-out caps. See `docs/config/ctf.toml`,
-`docs/plans/2026/07/08/PLAN_CtfFrontierExploration_2026-07-08.md`, and the
-decision record beside it.
+CTF engagement metadata may select `ctf-competition` prompt context, and
+`flag_check` remains a verification tool and evidence source rather than a
+default completion gate. `explore` is always available; `[exploration]` only
+sets node and fan-out caps. Installed users edit the relevant engagement, flag,
+and frontier fields through `/config`.
 
 The shipped exploration tool does not replace the core execution strategy.
 It provides a bounded `EvidenceKind::Lead` ledger and explicit dispatch. Stable
@@ -180,13 +179,16 @@ flowchart TD
 The core agent team is domain-neutral. Each agent ships as a markdown persona
 definition under `crates/builder_repo/src/agents/`.
 
-Subagents are retained as an explicit, bounded capability. The default is one
-agent turn loop; the model delegates only work that is independently scoped or
-benefits from parallel exploration. A delegated child receives a focused
-overlay and budget, runs through the same tool/policy gateway, records
-parent-child lineage, and returns evidence references for conservative merge.
-Removing always-on classifier/judge agents did not remove the `task` tool,
-child conversations, specialist agents, or frontier fan-out.
+Subagents are explicit and bounded. A `task` call selects one agent; its tasks
+run concurrently up to four per call and delegation stops at depth two.
+Separate top-level tool calls are sequenced. Built-ins include `crypto`, `rev`,
+and `pwn`.
+
+`explore dispatch` is a separate path. It runs selected leads as `builder`
+clones with category overlays, defaults to breadth one, is hard-capped at four,
+and waits for the batch. It does not auto-route leads to specialist personas.
+Every child uses the same tool/policy gateway, budget, lineage, and evidence
+merge contracts.
 
 | Agent | Default role | Runtime profile |
 | --- | --- | --- |
@@ -207,11 +209,11 @@ child conversations, specialist agents, or frontier fan-out.
 
 ## Named Autonomy Profiles
 
-Optionally pin the top-level profile (`autonomy_profile = "ctf-competition"`);
-leave unset for the deterministic general default. CTF engagement config may
-select CTF prompt context when no explicit profile is set, but it never changes
-tool reachability. Delegated subagent contracts stay intact. Defined in
-`crates/builder_domain/src/autonomy_profile.rs`.
+Optionally pin the top-level profile (`autonomy_profile = "ctf-competition"`);
+leave unset for the deterministic general default. CTF engagement config may
+select CTF prompt context when no explicit profile is set, but it never changes
+tool reachability. Delegated subagent contracts stay intact. Defined in
+`crates/builder_domain/src/autonomy_profile.rs`.
 
 | Profile | Purpose |
 | --- | --- |
@@ -401,11 +403,11 @@ npm install -g pentesting
 
 ## Supported Runtime Targets
 
-The npm launcher currently resolves a managed native release asset for Linux
-x64. Docker is the recommended runtime on Windows and macOS. Published Docker
-images support `linux/amd64` only; Apple Silicon Macs use Docker Desktop's amd64
-emulation. Native ARM64 images and binaries are not supported. Advanced users
-may set `PENTESTING_BIN` to a locally supplied compatible binary.
+The npm launcher currently resolves a managed native release asset for Linux
+x64. Docker is the recommended runtime on Windows and macOS. Published Docker
+images support `linux/amd64` only; Apple Silicon Macs use Docker Desktop's amd64
+emulation. Native ARM64 images and binaries are not supported. Advanced users
+may set `PENTESTING_BIN` to a locally supplied compatible binary.
 
 | OS | CPU | Release asset |
 | --- | --- | --- |
@@ -421,7 +423,8 @@ through resource-capped Docker wrappers. Host Cargo is not an emergency
 fallback. `dbuild.sh` owns individual Cargo commands, `dverify.sh` owns
 sequential gate profiles, and `dbuild-image.sh` owns BuildKit. Each path shares
 storage admission, effective-limit inspection, a machine-wide lock, watchdogs,
-and structured failure reports. CI invokes the same container boundary. The
+and structured failure reports. Automated CI/CD is disabled; maintainers invoke
+these wrappers explicitly. The
 normative contract is [Docker-only build safety](https://github.com/agnusdei1207/pentesting/blob/main/docs/BUILD_SAFETY.md).
 
 The measured next-stage simplification and deletion plan is indexed at
@@ -436,9 +439,9 @@ overridden by project-local `.pentesting.toml` files discovered by walking up
 from the working directory. Local storage is the default; normal setup only
 needs the public model endpoint environment.
 
-The same shape is represented in `builder.schema.json`, `.pentesting.toml`, and
-the interactive `/config` UI. Set `PENTESTING_CONFIG` to override the global
-config directory.
+The full file shape is represented in `builder.schema.json`; common runtime and
+CTF fields are editable through `/config`. Set `PENTESTING_CONFIG` to override
+the global config directory.
 
 | Variable | Description |
 | --- | --- |
@@ -475,8 +478,8 @@ Inside an interactive session, these commands inspect and drive runtime state
 /tools         List the currently available tools and schemas
 /agent         Switch the active agent
 /conversation  Browse conversations for the active workspace
-/goal <task>   Set the active goal without enabling autonomous mode
-/auto          Explicitly toggle autonomous mode for the current goal (default: off)
+/goal <task>   Set the active goal without enabling autonomous mode
+/auto          Toggle autonomous mode for the current goal (default: off; Esc stops it)
 /update        Download and apply the latest public release asset for supported native targets
 /help          Show all commands
 /exit          Quit
@@ -501,15 +504,18 @@ pentesting shell-listener --bind 127.0.0.1 --port 4444
 
 Manages multiple accepted TCP sessions with per-session routing, buffered
 output, raw byte logging, full-duplex transcripts, command history, attach /
-detach events, replay, and evidence manifests. `pty-upgrade` sends the helper
-only; `upgrade` runs the helper plus a probe and records `pty_state` as verified
-or failed. The upgrade helper is drawn from a named technique catalog
-(`python3`, `python`, `python2`, `script`, `expect`) selectable per request —
-there is no default, so the request is rejected unless the caller picks a
-technique or supplies a full custom command, forcing the agent to recon the
-target and match what it actually has instead of assuming one interpreter; a
-missing tool is recorded as `pty_state=failed` with reason `<technique> helper
-unavailable`. Raw logs and transcripts are capped per session and closed sessions
+detach events, replay, and evidence manifests. `pty-upgrade` sends one concrete
+helper only; `upgrade` runs a helper plus a probe and records `pty_state` as
+verified or failed. Explicit `technique=auto` adds a bounded listener-side state
+machine: framed capability recon, allowlisted `bash`/`sh` selection, ordered
+helper attempts (`python3`, `python`, `python2`, `script`, `expect`), generic
+prompt observation, and phase-local probe verification. Only unavailable,
+early-returned, or completed-but-unverified attempts advance to the next
+candidate; timeout, disconnect, or writer failure stops without blind input.
+The entire operation keeps one command id, deadline, session lease, ledger, and
+final response. There is still no silent default: omission is rejected, manual
+techniques keep their single-attempt behavior, and custom text remains the
+escape hatch for unusual targets. Raw logs and transcripts are capped per session and closed sessions
 are archived automatically so a noisy peer cannot grow memory or disk without
 bound. Secret redaction is applied before new raw/transcript/display records are
 written; it is not retroactive for output that arrived before the secret value

package/README.md

@@ -21,20 +21,33 @@ Agent-loop essentials plus a security-focused runtime layer.
 | Tool guardrails             | Read-before-edit enforcement, repeat-call guard, policy-gated file/shell/network                                                                                      |
 | Permissions                 | Allow / Deny / Confirm, with once/always decisions persisted                                                                                                          |
 | Context compaction          | Automatic micro-pruning + model-triggered summarization, pre/post hooks                                                                                               |
-| Interrupt & steering        | ESC interruption plus a revisioned FIFO queue with explicit amend/replace intent and deterministic PTY Enter ownership                                                |
+| Interrupt & steering        | ESC stops the current turn and auto loop; queued input uses revisioned FIFO amend/replace semantics and deterministic PTY Enter ownership                              |
 | Reverse-shell control plane | Accept and track multiple authorized callbacks, tag/probe sessions, send/observe/run commands, verify PTY upgrades, and keep transcript/ledger/evidence records       |
 | PTY session control         | One actor owns each socket/PTY/pipe, command queue, transcript, and child lifecycle, with resize gating, FD accounting, and deterministic close/revoke/gc reclamation |
-| Frontier-guided exploration | Always-available bounded security tool with a lead ledger, explicit dispatch, and knowledge-preserving dead-probe pivots                                              |
-| Subagents                   | Broad-clone delegates with category focus overlays; independent deep-specialist leads (crypto/rev/pwn) run in the same parallel batch so the main line keeps moving   |
+| Frontier-guided exploration | Persistent lead ledger with explicit dispatch; breadth defaults to one and is hard-capped at four                                                                   |
+| Subagents                   | Explicit delegation to built-in specialists, including `crypto`, `rev`, and `pwn`; one selected agent can run up to four tasks concurrently                           |
 | MCP & skills                | Dynamic MCP tool discovery, layered markdown skills                                                                                                                   |
 | Memory                      | Ebbinghaus-style decaying notes + hybrid lexical/semantic/graph retrieval                                                                                             |
 
 ---
 
-The default execution path is one agent loop, but subagents remain available
-through the `task` tool for independently scoped work and bounded parallel
-exploration. Child runs use the same permissions and tool gateway, carry a
-focused overlay and runtime budget, and merge evidence back by reference.
+Delegation is explicit. One `task` call selects one agent and may run its tasks
+concurrently; separate top-level calls are sequenced. `explore dispatch` instead
+uses `builder` clones with category overlays and waits for the batch. Both paths
+share permissions, budgets, lineage, and evidence checks.
+
+### Core algorithms
+
+| Area | Implementation | Time / space |
+| --- | --- | --- |
+| Exploration | Score-ranked BFS/DFS guidance, parent backtracking, global reseeding; append-only leads folded into a `HashMap` | Snapshot/advice `O(R + L log L)` time, `O(L)` working and `O(R)` stored space |
+| Knowledge | BM25 + 768-D cosine search + BFS over adjacency maps/visited sets, fused by RRF; fixed 20-round PageRank at index build | Query `O(M + N(Q + D + log N) + V log V + E)` time and `O(N + V + D)` working space; index storage `O(M + ND + V + E)` |
+| Runtime control | FIFO queues plus semaphore-bounded `join_all` fan-out | `O(T)` scheduling/result state, at most four active children per batch |
+
+`R` is lead records, `L` live leads, `M` searchable text, `N` notes, `Q` query
+terms, `D = 768`, and `V/E` graph nodes/links. Memory decay is constant-time per
+note. Kruskal, Prim, and a generic divide-and-conquer engine are not runtime
+components; agents may apply them to a target when useful.
 
 ---
 
@@ -58,26 +71,26 @@ wrappers. Host Cargo compilation is fail-closed; free disk or RAM does not make
 it an approved path.
 
 ```bash
-scripts/dbuild.sh check --workspace --all-targets
-scripts/dbuild.sh test -p builder_domain
-scripts/dverify.sh focused
-scripts/dverify.sh full
-scripts/dbuild-image.sh validation                                                # once per fresh Docker cache
-powershell -NoProfile -ExecutionPolicy Bypass -File scripts/dbuild.ps1 test -p builder_domain  # Windows
-powershell -NoProfile -ExecutionPolicy Bypass -File scripts/nverify.ps1                  # Windows npm verify
+scripts/dbuild.sh check --workspace --all-targets
+scripts/dbuild.sh test -p builder_domain
+scripts/dverify.sh focused
+scripts/dverify.sh full
+scripts/dbuild-image.sh validation                                                # once per fresh Docker cache
+powershell -NoProfile -ExecutionPolicy Bypass -File scripts/dbuild.ps1 test -p builder_domain  # Windows
+powershell -NoProfile -ExecutionPolicy Bypass -File scripts/nverify.ps1                  # Windows npm verify
 ```
 
 The wrappers cap memory, CPU, PIDs, jobs, test threads, and time; verify storage
-before launch; serialize heavy work; and leave a redacted resource report. CI
-uses the same Docker-only path. Full policy: [Docker-only build safety](https://github.com/agnusdei1207/pentesting/blob/main/docs/BUILD_SAFETY.md).
+before launch; serialize resource-intensive work; and leave a redacted resource
+report. Automated CI/CD is disabled. Full policy: [Docker-only build safety](https://github.com/agnusdei1207/pentesting/blob/main/docs/BUILD_SAFETY.md).
 
-### 🐳 Run with Docker
-
-No local Rust toolchain needed:
-
-Published images support `linux/amd64` only. Docker is the recommended runtime
-on Windows and macOS; Apple Silicon Macs run the amd64 image through Docker
-Desktop emulation. Native ARM64 images and binaries are not supported.
+### 🐳 Run with Docker
+
+No local Rust toolchain needed:
+
+Published images support `linux/amd64` only. Docker is the recommended runtime
+on Windows and macOS; Apple Silicon Macs run the amd64 image through Docker
+Desktop emulation. Native ARM64 images and binaries are not supported.
 
 ```bash
 export OPENAI_API_KEY="sk-..."                 # provider API key or gateway token
@@ -111,7 +124,7 @@ OPENAI_MAX_TOKENS=4096 \
 docker compose run --rm pentesting
 ```
 
-### Common commands
+### Common commands
 
 ```bash
 pentesting                                                # Interactive TUI
@@ -120,32 +133,35 @@ pentesting shell-listener --bind 127.0.0.1 --port 4444   # Authorized reverse-sh
 pentesting --version
 ```
 
-Use `shell-listener` in authorized CTF/lab work to accept callbacks, tag sessions, run sentinel-tracked commands, verify PTY upgrades, and retain transcripts/evidence.
-
-Short version: the agent can catch a dumb reverse shell, upgrade it to a verified PTY, pivot to a second callback, and reclaim both sessions cleanly with `close` / `revoke` / `gc`.
-
-### Interactive control defaults
-
-- `/model` owns a modal terminal surface. Returning from it restores the prior
-  transcript cursor before the fixed prompt/status rows are redrawn, so later
-  responses and errors append instead of overwriting the input area.
-- `/goal <task>` records the goal only. Autonomous continuation starts off and
-  can be enabled or stopped only with an explicit `/auto` command.
-- Tool/request budget exhaustion does not create a fresh turn while auto mode
-  is off. A submitted queued input takes precedence over autonomous follow-up.
-- Submitted type-ahead is consumed once in FIFO order at the next safe turn
-  boundary. Only explicit amend/replace intent may change that handoff.
+Use `shell-listener` in authorized CTF/lab work to accept callbacks, tag sessions, run sentinel-tracked commands, verify PTY upgrades, and retain transcripts/evidence.
+
+Short version: the agent can catch a dumb reverse shell, upgrade it to a verified PTY, pivot to a second callback, and reclaim both sessions cleanly with `close` / `revoke` / `gc`.
+
+### Interactive commands
 
-On native Windows Git Bash, the repository smoke path builds the capped Docker
-image and then opens this interactive TUI without WSL:
+Sessions start with auto mode off. Esc stops both the current turn and autonomous continuation. Queued input is replayed in FIFO order.
 
-```bash
-npm run check
-```
+| Command | Purpose |
+| --- | --- |
+| `/help` | List every command |
+| `/model [query]` | Choose a provider/model or custom endpoint |
+| `/goal <objective>` · `/auto` | Record a goal, then toggle autonomous continuation; Esc stops it |
+| `/status` · `/usage` | Inspect run state, gates, budgets, tokens, and requests |
+| `/context` · `/memory` | Inspect context-budget snapshots and stored memories |
+| `/agent` · `/builder` · `/planner` · `/researcher` | Select the active agent |
+| `/new` · `/retry` · `/compact` | Start fresh, retry the last turn, or compact context |
+| `/config` · `/tools` · `/skill` | Configure the runtime and inspect capabilities |
+| `/workflow report` | Export the active run as Markdown |
+| `/update` · `/exit` | Update the native release or quit |
+
+On native Windows Git Bash, the repository smoke path builds the capped Docker
+image and then opens this interactive TUI without WSL:
 
-Inside a session, `/help` lists every command and `/update` pulls the latest release for supported native targets.
+```bash
+npm run check
+```
 
-### 🔌 Reverse-shell & PTY sessions
+### 🔌 Reverse-shell & PTY sessions
 
 Catch and manage authorized shell callbacks: one listener, many targets, audited cleanup.
 
@@ -153,15 +169,16 @@ Catch and manage authorized shell callbacks: one listener, many targets, audited
 pentesting shell-listener --port 4444             # 1. Catch callbacks (tracks many at once)
 pentesting shell-session list                     # 2. See every live session + FD ownership
 pentesting shell-session run -- id                # 3. Run sentinel-bounded commands, capture output
-pentesting shell-session pty-upgrade              # 4. Inject the PTY helper; `upgrade` then verifies it
+pentesting shell-session upgrade --technique auto # 4. Recon, select, retry, and verify a real PTY
 pentesting shell-session revoke --session 1       # 5. Hard-close: reclaim FDs + archive evidence
 ```
 
 - **Track** — each callback is accepted, numbered, and tagged; one session actor exclusively owns its live descriptors, transcript, and child lifecycle. `list` / `info` / `fdstat` / `lifecycle` show state and byte counts without cloned reader/writer descriptors.
 - **Drive** — `run` wraps commands in a sentinel to capture exactly their output; `send` / `raw` / `signal` / `resize` give interactive control.
-- **Upgrade** — `pty-upgrade` sends the built-in helper and `upgrade` verifies a real PTY before remote resize is allowed; the agent must pick the method with `--technique` (`python3`, `python`, `python2`, `script`, `expect` — no default) after reconning what the target actually has, or send a fully custom command instead.
+- **Upgrade** — `upgrade --technique auto` explicitly runs a bounded `recon → select → helper → probe` controller, choosing an allowlisted shell and retrying only evidence-backed failures across `python3`, `python`, `python2`, `script`, and `expect`. Omission is still rejected: use a concrete technique for one exact CLI attempt; unusual custom `text` commands are available through the `session_control`/JSONL API. CLI `pty-upgrade` sends one concrete catalog helper and never starts adaptive fallback.
 - **Record** — per-session raw log, full-duplex transcript, command ledger, replay, and evidence manifest — with secret redaction for registered values.
 - **Reclaim** — `close` (graceful) and `revoke` (hard) release file descriptors immediately and archive the session; `gc` prunes closed sessions. Reclamation is tracked end-to-end, so FDs never leak.
+- **Guard** — the JSONL control plane is a workspace-internal Unix socket only (absolute paths, symlink escapes, and non-socket files are rejected). Every request carries a protocol version and a correlating `request_id`, is bounded to 1 MiB in / 4 MiB out, and `timeout_ms` is capped at 5 minutes and rejected before any bytes reach the session. A small fixed worker pool multiplexes the socket so a long adaptive `upgrade` never blocks `health` / `observe` / `close`, and injected secrets are redacted from responses and sensitive audit records. `probe` / recon fields are the target's own self-report, not a security attestation.
 
 ---
 
@@ -185,48 +202,12 @@ export PENTESTING_SKIP_DOWNLOAD=1                        # skip postinstall bina
 
 The TUI pre-fills output max tokens from known model names/provider metadata. `OPENAI_MAX_TOKENS` and the TUI field are explicit overrides for custom/self-hosted models.
 
-### Frontier-guided CTF exploration
-
-There are no separate security, CTF, and frontier modes. Session/process,
-finding/verification, `flag_check`, and `explore` tools share one default
-security surface. Engagement metadata describes scope, target, and flag format;
-it does not unlock tools. CTF-shaped context may tailor the prompt, while
-`flag_check` remains a verification tool and evidence source instead of a
-default completion gate. `[exploration]` contains only resource caps. A
-ready-to-copy context lives at
-`docs/config/ctf.toml`:
-
-```toml
-[engagement]
-kind = "ctf"
-flag_format = "flag\\{[^}]+\\}"
-require_flag_evidence = false
-
-[exploration]
-max_frontier_nodes = 256
-max_breadth = 4
-```
-
-With the profile active, the runtime stores `explore` leads as bounded
-`EvidenceKind::Lead` events and reuses prior-run records by reference rather
-than copying them. A repeated dead probe suppresses that execution path but
-does not reject the underlying hypothesis; fresh evidence reopens it. The model
-still drives work through the explicit `explore` and `task` tools. Exploration
-does not replace the core execution strategy, add a background scheduler, or
-expose a passive `/frontier` UI/query path. Node, breadth, and depth limits bound
-its cost.
-
-Malformed tool-call output is fail-loud: unparsed tool-shaped markup is retried
-instead of accepted as a final answer, the TUI suppresses raw control markup, and
-long no-newline streams flush at soft text boundaries so rendering cannot hang
-behind usage-only progress ticks. The startup banner and live status row stay
-compact; generic run, token, and queued-input detail lives in `/status`.
-
-The shipped contract is covered by
-`scripts/dbuild.sh test -p builder_app orch_spec::exploration_e2e`: it verifies the
-always-available tool path plus breadth enumeration, depth descent, sibling
-breadth, dead-probe pivot, global reseed, seed digest, broad-clone overlay, and
-child result promotion.
+### Frontier-guided CTF exploration
+
+`explore` is always available. Use `/config` to set the engagement kind, flag
+verification, and frontier limits; settings persist in the installed runtime's
+user config. Breadth defaults to one and is capped at four. Leads are persistent,
+deduplicated, and dispatched explicitly.
 
 With Docker, mount both your project and the persistent runtime config volume, then pass the same variables through with `-e`:
 

package/lib/runtime.mjs

@@ -15,7 +15,7 @@ const MANAGED_BINARY_MANIFEST = path.join(MANAGED_BINARY_DIR, "pentesting-manife
 
 const RELEASE_TARGETS = {
   // Native binaries published as release assets. Linux x64 uses musl (static).
-  // Other platforms use the published linux/amd64 image through Docker.
+  // Other platforms use the published linux/amd64 image through Docker.
   "linux:x64": {
     assetName: "pentesting-x86_64-unknown-linux-musl",
     binaryFileName: "builder",
@@ -53,7 +53,7 @@ export function resolveReleaseAsset(platform = process.platform, arch = process.
     throw new Error(
         `No native pentesting binary for '${platform}/${arch}'. ` +
         `Native targets: ${supported}. ` +
-        `On macOS or Windows, or on a non-amd64 host, use the linux/amd64 Docker image instead: ` +
+        `On macOS or Windows, or on a non-amd64 host, use the linux/amd64 Docker image instead: ` +
         `docker run -it --rm -v "$(pwd):/workspace" -v pentesting-config:/root/.pentesting -w /workspace -e OPENAI_API_KEY -e OPENAI_BASE_URL -e OPENAI_MODEL -e OPENAI_MAX_TOKENS agnusdei1207/pentesting`,
     );
   }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "pentesting",
-  "version": "0.100.7",
-  "builderReleaseTag": "v0.100.7",
+  "version": "0.100.10",
+  "builderReleaseTag": "v0.100.10",
   "description": "pentesting — coding agent runtime with audited reverse-shell capture, verified PTY session upgrades, pivot control, evidence transcripts, and safe session reclamation.",
   "license": "MIT",
   "author": "agnusdei1207",