Fissuredocumentation v5.3.1
On this page

Volume III - Automation

Automation in Fissure is a force multiplier, not a replacement for manual testing. Good automation collects information while you browse, highlights unusual responses, keeps evidence organized, and repeats safe low-risk checks consistently, so you can focus on the most promising leads. The core principle: automate discovery and classification, and verify exploitation manually.

Every automation feature below stays inside the scope allowlist and the safe/aggressive toggle, and reports its work on screen.

Chapter 1 - Automation Philosophy and Safety

1.1 The automation loop

A professional loop repeats: observe traffic, classify patterns, form a hypothesis, run narrow automation, verify manually, document evidence, and refine the rules. This keeps tool-driven testing from turning into noise.

1.2 Safety boundaries

Boundary Rule
Authorization Run automation only on targets and accounts explicitly allowed.
Scope Set the Fissure scope allowlist before launching.
Traffic volume Estimate request counts and throttle conservatively.
State changes Prefer read-only endpoints until behavior is understood.
Data handling Do not store secrets or personal data unnecessarily.
Verification Confirm every finding manually and record exact reproduction.

Bad automation floods the target without a question, creates so many findings that nothing can be trusted, breaks sessions, produces results that cannot be reproduced in the Repeater, or runs outside scope. Never let automation define the scope or the ethics of the engagement.

1.3 The Logger: auditable cross-tool traffic

Automation without visibility becomes chaos. Open Logger from the command palette (Ctrl+K, "Open Logger") to see one filterable log of every request the engine issued, each tagged with its source tool: repeater, intruder, scanner, discover, and the proxy mirrored in. Cycle the Tool and Status filters and type a host, URL, or method substring, then Refresh to re-read the log (newest first); Clear empties it. Where the per-tool views scatter traffic, the Logger aggregates it so you can answer "which tool produced this request, and what did it get?", the attribution testers otherwise reach for a dedicated logging extension to get. Use it to separate automation traffic from manual traffic, spot the anomalous status or length in a run, and send the interesting request back to the Repeater.

Chapter 2 - Passive-First Workflow

A passive-first strategy extracts value from traffic you already generate. It minimizes noise, preserves target stability, and gives active tools better context.

2.1 What passive analysis reveals

Passive analysis looks at requests and responses without changing the target. In Fissure, the passive checks flag missing security headers, weak cookie flags, server banners, exposed secrets, permissive CORS, and a suspected DOM-based XSS sink. These cost almost no extra target traffic.

Passive analysis runs both during a scan (Volume I, Chapter 7) and live on the proxy. As each in-scope flow is captured, Fissure runs the native passive suite (headers, cookies, banners, secrets, CORS, DOM-XSS) plus the user scripts and imported BChecks on it, and adds any findings to the Findings store without a scan (Chapters 3 and 6). Out-of-scope hosts blind-tunnel and are never captured, so the live audit is inherently scope-limited, and its findings deduplicate against a later scan. Browsing with the proxy on is therefore already reconnaissance.

2.2 Feeding active tests

Passive results should steer active testing. If passive analysis indicates a PHP backend, focus file and parser checks accordingly. If it reveals a GraphQL endpoint, prepare introspection and authorization tests. If it reveals verbose errors, design smaller payloads to reproduce the condition. Low-noise active discovery means asking fewer, better questions adapted to what you observed.

Chapter 3 - BCheck Import: Lightweight Custom Checks

BChecks add small, focused scanner logic without writing a full extension: detect a header, test a small behavior, report a pattern.

3.1 Importing BChecks

Drop .bcheck files into resources/checks/. Fissure compiles the common single-probe shape (metadata plus given / send / if-condition / report) into an equivalent QuickJS check that runs in both the scan and the live Proxy passive pass. A slice of the public BCheck library therefore runs unchanged.

metadata:
  language: v1-beta
  name: "Example passive header check"
  description: "Reports when a debug-style header appears."
  tags: "passive", "headers"

given response then
  if {latest.response.headers} matches "(?i)X-Debug" then
    report issue:
      severity: info
      confidence: firm
      detail: "Debug-style header observed."
  end if
end given

3.2 Quality over quantity

A library of 20 accurate checks beats 500 noisy ones. Every check should answer a defined question and produce actionable output. Write the rule, run it against a lab, inspect false positives, tighten the conditions, tag it, and document its purpose before using it in a real engagement.

Chapter 4 - HaE: Pattern-Driven Passive Discovery

The Highlighter and Extractor (HaE) turns Proxy traffic into a searchable stream of clues. Large applications leak small hints everywhere: routes, framework names, stack traces, source-map references, admin words, and tokens. HaE makes those hints visible while you browse.

4.1 Rules and actions

Open the HaE popup from the toolbar. Each rule has a scope (request, response, or any) and an action set: Highlight colors the flow (the highest-priority color wins when several rules match), and Extract records the first capture-group value. The Proxy grid shows the color in the Highlight column and the values in the Extracted column. A starter ruleset ships on first run (JWTs, keys, emails, private IPs, cookies, server banners, error traces), and edits save to hae.json. Use (?i) in a pattern for case-insensitive matching.

4.2 Regex quality

The key skill is reducing false positives, not writing clever regex. A weak pattern turns every response one color and becomes useless. Prefer a pattern that looks for a reference context (for example a file path following href, src, or url) over one that matches any text ending in .log. Do not build secret-hunting rules that store large amounts of sensitive data without a clear data-handling plan.

4.3 From highlight to test

A highlighted pattern is a lead, not a vulnerability. A discovered admin route becomes an authorization test; a source-map hint becomes source review; a detected DOM sink becomes XSS analysis; a JWT string becomes token analysis in the Tokens workshop (Volume IV). HaE is grouped with these categories so a rule maps directly to a follow-up.

Chapter 5 - Auto-replay: Request Mutation Automation

Auto-replay is Fissure's AutoRepeater: it replays a modified version of a request automatically and logs the response diff. It extends match-and-replace into a repeatable mutation workflow with comparison.

5.1 Rules

Open the Auto-replay popup from the toolbar. A rule has boolean conditions (one field op value per line over host, method, scheme, ext, url, source), an optional base replacement (to keep the request valid), and a test replacement (the mutation). A rule should express one hypothesis; avoid giant replacement sets that make it impossible to tell which change caused which response. A starter set ships disabled.

Hypothesis Test replacement What to compare
Auth required? remove the Cookie or Authorization status, redirect, length
Role enforced? swap an admin token for a member token object visibility, errors
IDOR possible? replace a user_id or UUID response data ownership
Method confusion? change PATCH to PUT or POST status and side effects
Proxy trust issue? add X-Forwarded-* headers routing, redirects, privilege

5.2 Running

Right-click a request and choose Auto-replay. For each matching rule, Fissure resends one mutant on a worker thread and diffs it against a fresh baseline, logging the original versus modified status and length and a similarity score. Open in Repeater loads a log row's mutant for manual work. It is gated by the scope allowlist, and rules persist to autorepeater.json.

Always keep the original request, modified request, and both responses together: authorization findings are comparison findings. Begin with read-only endpoints, throttle when many rules are enabled, and verify anomalies manually.

Chapter 6 - Inline Transform Tags and User Scripts

6.1 Inline transform tags (Hackvertor-style)

Some applications do not accept plain payloads: values may be base64-encoded, URL-encoded, hashed, timestamped, or signed. Inline tags transform request values at send time, so a test stays realistic without manual encoding.

Wrap part of a Repeater or Intruder request in <@name>...<@/name> and it is transformed at send time, innermost-first, so tags nest: <@base64><@upper>hi<@/upper><@/base64>. Built-ins include base64, base64url, url, hex, zlib and their d_ decoders; md5, sha1, sha256, sha512; hmac_sha256(key); upper and lower; <@timestamp/>, <@date(fmt)/>, <@random(n)/>, <@random_int(a,b)/>; <@oast/> (a fresh OAST canary); and <@get(name)/> and <@set(name)>...<@/set> variables. In the Intruder, each request is expanded after payload substitution, so generators and encoders are fresh per request. The Tags toolbar popup manages custom JavaScript tags (the tag content is input; return the result) and variables, saved to tags.json. Unknown or malformed tags pass through unchanged.

Treat dynamic tags as executable logic: they run transforms you defined, so control them carefully and do not expand tags in traffic you did not author.

6.2 User scripts

User scripts are JavaScript checks under resources/checks/ using the fs.* API (Volume V). They run two ways: as passive hooks on live Proxy traffic (Chapter 2), and on demand through the Findings or Proxy right-click Run scripts action, which fetches the request once and runs every script against the response (a script's fs.send() may probe further), adding any findings to the Findings view. A popup reports how many ran. This is the no-C path for encoding your own testing experience into repeatable checks, alongside imported BChecks.

Chapter 7 - Session-Handling Rules

Long automated runs lose their session unless something keeps them authenticated. Session-handling rules are a scope-gated automation engine applied uniformly by the request engine, so the Scanner, and by scope the other tools, stay logged in.

7.1 Rule types

Open the Session popup from the toolbar. Each rule has a scope (a host regex and a tool set) and a trigger:

  • An "always" rule injects or replaces request headers before every matching send, with {{token}} placeholders filled from the login's captured variables (a fresh CSRF or bearer value).
  • An "on-status" rule marks a response status (for example 401) as a signal to re-run the login and retry the request.

Rules persist to sessrules.json, and a starter set ships disabled. Combined with the Settings Login config (Volume I, Chapter 7) they keep a scan or an Intruder run valid across token rotation and session expiry.

7.2 The maturity test

A teammate should be able to read your rules, tags, and notes and understand exactly what every automated request was trying to prove. If a rule or a tag cannot be explained in one sentence, simplify it.

Chapter 8 - The Workflow Builder: Node Pipelines

The Auto-replay tool (Chapter 5) mutates one field of a request and diffs the result. The Workflow builder goes a step further: it composes a pipeline of typed nodes that run in order over a single HTTP exchange (a request and its response), so a test that is really a sequence of steps becomes one named, saved, repeatable unit.

8.1 What a workflow is

A workflow is an ordered list of nodes. Each node acts on the current exchange and hands it to the next. The nodes reuse the same scriptable primitives the rest of Fissure is built on, so nothing here is a new language to learn:

Node What it does
filter A traffic-query gate. It evaluates an HTTPQL query (the same field vocabulary the Logger and filter boxes use, for example status = 200) against the current exchange; if the query does not match, the pipeline stops at this node.
match_replace A literal or regex rewrite of one leg and part (request or response, headers or body).
transform Runs a JavaScript snippet over one leg and part; the string it returns replaces that field.
passive Runs a JavaScript check against the current response and records any findings it reports.
active Same as passive, but fs.send() is permitted so the check can probe further. Needs the Active toggle.
send Replays the current request and captures the fresh response back into the exchange.
js Runs a JavaScript snippet over the WHOLE exchange serialized as one JSON object (method, url, req_headers, req_body, status, resp_headers, resp_body): parse it, rewrite any field, return JSON.stringify.
shell Pipes one leg and part through an external command. The field is written to a temp file whose path replaces {{in}} in the command, and the command's stdout replaces the field. Aggressive-gated.

Two of these are first-class JavaScript nodes: transform runs JS over a single field, and js runs JS over the entire exchange as a JSON object. Between them you can reshape any part of a request or response with a few lines of code, without writing a full check.

8.2 When to reach for it

Reach for a workflow when one match-replace or one check is not enough because the test is a sequence: fetch a page, reshape a value, decide whether to continue, then run a check and report. Auto-replay answers "what changes if I mutate this one field?"; a workflow answers "run these steps in order and tell me what each one did." A workflow is also the unit you save under a name and re-run later, or drive headless over the control API and MCP, so a reproducible multi-step probe travels with the engagement.

8.3 Building and running a pipeline

Open Workflows from the toolbar's Organize & collaborate category, or from the command palette (Ctrl+K, "Open Workflows").

  1. Click New for an empty workflow, pick a saved one from the dropdown and Load, or pick a shipped template from the "From template" dropdown and click New from template to load a ready-made pipeline as your starting point (see 8.5).
  2. Add node appends a node (a filter by default). Select a row in the grid to edit it.
  3. For the selected node, the editor controls are: Type cycles the node type; Enabled toggles whether it runs; Leg cycles request or response and Part cycles headers or body (for the field-oriented nodes); Regex toggles literal against regex for match_replace; the match and replace boxes feed match_replace; and the single script/query box holds either the query (filter), the JS source (transform, passive, active, js), or the command (shell), depending on the type. Name the node so it reads clearly in the trace.
  4. Up and Down reorder the selected node; Remove deletes it.
  5. Type a name in the name box and Save (it writes to workflows.json under that name). Load replaces the editor with a saved workflow.
  6. Enter an input URL to run against. The Active toggle governs whether active, send, and shell nodes may generate traffic (authorized, in-scope targets only). Click Run.

When you Run, Fissure first fetches the input URL (a GET by default) so the passive and transform nodes have a real response to work on, then executes the nodes in order.

8.4 Where the results land

The result pane fills in with the run output: a per-node trace where each node reports its name, its type, the action it took (for example "sent -> status 200", "rewrote response body", "passed", "reported 1", or "stopped (no match)"), how many findings it reported, and whether it changed the exchange. Alongside the trace you get the final status code, the response length, whether the pipeline stopped early at a filter, and a total findings count.

Findings do not stay in the popup. Any finding a passive or active node reports is merged into the shared Findings store, so it appears in the Findings view and in the report exactly like a scan finding, deduplicated and carrying its own evidence. The run itself is synchronous inside the popup; the broader background work covered in Chapter 10 (Jobs and the Event log) is a separate concern.

8.5 Starting from a template

You do not have to build every pipeline from an empty canvas. Fissure ships a small library of ready-made workflow templates, the same idea as the built-in scan profiles (Passive/Quick/Balanced/Deep): a curated starting point you load, then edit, save, or run as-is. Pick one from the "From template" dropdown and click New from template; the editor fills with its nodes and the name box takes the template's name. It is now an ordinary workflow, so Save it (optionally under a new name) to keep your edits in your own library, without touching the shipped file.

The shipped templates are:

Template Kind What it does
Passive triage - secrets and errors passive Gates to in-scope traffic, then flags leaked secrets (AWS/Google keys, JWTs, private keys) and stack traces in the body.
Security header audit passive Reports responses missing CSP, X-Frame-Options, X-Content-Type-Options, HSTS, or Referrer-Policy.
Cookie security flags passive Flags Set-Cookie headers missing HttpOnly, Secure (on HTTPS), or SameSite.
Sensitive data in URL passive Reports credential- or token-like parameters carried in the URL query string, where they leak into logs, browser history, and the Referer header.
CORS misconfiguration probe active Sends a request with a foreign Origin and reports if the response reflects it in Access-Control-Allow-Origin (high when combined with Allow-Credentials: true).
Reflected input probe (XSS candidate) active Injects a unique marker into a query parameter and reports it if reflected unencoded.
SQL error probe active Appends SQL meta-characters to a parameter and reports database error signatures.
Normalize JSON response convert Pretty-prints a JSON response body; non-JSON bodies pass through unchanged.
Replay and re-check active Replays the request, then re-runs the error-disclosure and security-header checks on the fresh response.

The active templates need the Active toggle (and an in-scope URL) before their send/active nodes will generate traffic. Headless, the same library is listed by GET /api/workflow-templates (MCP workflow_templates) and copied into your saved store by POST /api/workflows {"op":"instantiate","name":...} (MCP workflows_op("instantiate", name=..)), so an agent can start from a template too.

8.6 A worked example: send, transform, gate, report

Build a four-node pipeline that replays a request, normalizes the body, gates on a successful load, and reports a banner leak.

  1. Add a send node. It replays the request so the rest of the pipeline works against a fresh response.

  2. Add a transform node, Leg response, Part body, with the script input.toLowerCase(). The node's input is the current body and the string it returns replaces it, so downstream matching is case-insensitive.

  3. Add a filter node with the query status = 200. If the replay did not return 200, the pipeline stops here and the later node never runs.

  4. Add a passive node with a short check:

    if ((fs.body || "").indexOf("x-powered-by") >= 0)
      fs.report({ severity: "info", category: "Information Disclosure",
                  title: "Backend banner leaked",
                  evidence: "x-powered-by present in body" });

Name the workflow (for example banner-probe) and Save. Enter an in-scope input URL, turn Active on so the send node is allowed to fire, and Run. The trace reads down the four nodes, and if the marker is present the passive node reports "reported 1" and the finding shows up in the Findings view.

The same run is available headless: POST /api/workflow/run takes an inline workflow object or a saved name, plus a url and an active flag, and GET/POST /api/workflows manage the saved set (op save, delete, or instantiate a template). Over the MCP bridge these are the workflow_run, workflows, workflows_op, and workflow_templates tools, so an agent drives the exact pipeline you built in the GUI, or starts from a shipped template.

8.7 Safety

Active, send, and shell nodes are gated by both the Active toggle and the scope allowlist, and the input URL must be in scope or the run is refused. Shell nodes additionally require the aggressive/Active state because they run an external command, which is arbitrary code; the exchange bytes reach that command only through a temp file, never on the command line, so response data cannot inject shell syntax. Treat a workflow the way you treat any automation: one hypothesis per pipeline, read-only endpoints first, and verify manually before you trust a reported finding.

Chapter 9 - Recurring Scans: The Scheduler

A single scan is a snapshot. On a long engagement you often want a target re-scanned on a schedule, so a newly introduced issue is caught without a manual run and so you can see what changed since last time. The Scheduler turns a saved scan into a recurring one.

9.1 What it is

A schedule is a saved scan: a target URL, an optional scan profile, the active and aggressive flags, and an interval in seconds. The control server runs a scheduler thread that wakes on a fixed tick, fires every schedule that is due, runs the scan profile-aware and scope-enforced, records the finding count, and computes the delta since the previous run. That delta is the point: it pairs with the recon asset-diff to answer "what is new on this target since last time?"

9.2 The control-API prerequisite

Schedules only fire while the control API is enabled (Settings). The Schedules popup manages the list through the in-process control dispatch, so you can add, edit, and remove schedules with the API off, but nothing actually runs until it is on. The popup's status line tells you which state you are in: "The scheduler is running." when the API is enabled, or a reminder to enable it otherwise. If a schedule never seems to fire, check that line first.

9.3 Defining and managing a schedule

Open Schedules from the toolbar's Organize & collaborate category (or the command palette).

  1. Enter a target URL (required). Optionally add a name, a profile name (the same scan profiles offered by the Target-view profile picker), and an interval in seconds; leaving the interval blank defaults to 3600 (one hour).
  2. Active toggles active scanning (off means a passive crawl only); Aggressive toggles the aggressive check families. Click Add.
  3. The grid lists each schedule with its name, URL, interval, on/off state, last finding count, and the delta since the previous run.
  4. Select a row to act on it: Run now, Enable/disable, or Remove. Refresh reloads the list.
  5. Enable the control API in Settings so the scheduler thread fires due schedules.

Schedules persist to schedules.json in the config directory, so they survive a restart along with their per-run history.

9.4 Run now and force-due behavior

Run now does not scan on the spot. It marks the selected schedule as due (by clearing its last-run time), and the scheduler thread picks it up on its next tick. The thread wakes on a short granularity (about fifteen seconds), so a forced schedule starts within moments once the API is on, not instantly. With the API off, Run now still just marks the schedule due, and it fires when you next enable the API. This is deliberate: the same due logic drives both the interval firing and the manual push, so there is one behavior to reason about.

9.5 A worked example: a nightly re-scan

Suppose an authorized staging target at http://localhost:8080.

  1. In Schedules, enter the URL, name it staging-nightly, leave the profile blank, set the interval to 86400 (24 hours), turn Active on and Aggressive off (a gentle recurring crawl), and click Add.
  2. Open Settings and enable the control API. The status line switches to "The scheduler is running."
  3. Select the row and click Run now to get a first baseline without waiting a day. Within a tick or two the Last column fills with the finding count; Refresh to see it. The first run's delta is a baseline; on the next run the Delta column shows +2 or -1 and so on, telling you exactly what moved.

Headless, this is GET/POST /api/schedules with op one of add, remove, enable, disable, or run, and the MCP schedules and schedules_op tools, so an agent can stand up the same recurring monitor.

9.6 Safety

A schedule inherits the same rules as any scan: authorized, in-scope targets only. An aggressive scan repeated on a short interval will wear a fragile target down and can degrade a stateful application's session or security posture, which then makes its own findings unreliable. Prefer a passive recurring crawl, a modest interval, and the aggressive flag reserved for a deliberate, spaced-out active pass.

Chapter 10 - Watching Automated Work: Jobs and the Event Log

Automation you cannot see is automation you cannot trust. Two panels give background and agent-driven work a control room and an audit trail: the Jobs monitor shows what is running right now, and the Event log shows what happened and in what order. Both were introduced in Volume I, Chapter 14; this chapter is how you lean on them once work is scheduled, scripted, or agent-driven.

10.1 The Jobs monitor

Open Jobs from the toolbar's Results category, or the command palette ("Open Jobs monitor"). It is a self-refreshing grid of every running scan and every on-demand check, whether you launched it from the Target view or an agent drove it over the control API and MCP. Each row shows the job's kind (scan or check), its name, its target, its status (queued, running, done, error, or cancelled), and its elapsed time. The grid reloads itself every few seconds.

The status line summarizes the whole set: how many jobs there are, how many are running, how many are queued, and the concurrency cap. That cap is the control_api_max_jobs setting (default 4): it bounds how many jobs run at once so a burst of checks never exhausts threads or sockets; the rest queue and are promoted as slots free.

Four controls act on the list:

  • Show findings lists what the selected job found (severity, title, location) in a popup, and says so when a job with no findings is still running; the same findings are also merged into the Findings view.
  • Cancel selected stops the chosen job; its in-flight requests abort within a poll interval.
  • Cancel all stops every running or queued job.
  • Clear done drops the finished rows (done, error, cancelled) and keeps the live work, so a long session's list stays readable.

Because your own Target-view scans and the right-click context checks register as jobs too, the operator and the agent watch the same unified list. A manual scan shows here with live status and its finding count, and a Cancel from this window stops it.

10.2 The Event log

Open Event log from the toolbar's Analysis & inspection category, or the command palette ("Open Event log"). It is a chronological, in-memory feed of engine events and errors, newest first, each tagged with a source and a level (info, notice, warn, or error). It captures the scan lifecycle, out-of-scope refusals, the code-of-conduct warnings for control-bypass actions, and every message surfaced to you through the shared info and error dialog, so a blockage is not lost the moment its popup is dismissed.

Keep it distinct from the Logger (Chapter 1.3): the Logger records HTTP exchanges, one row per request; the Event log records engine events, one row per thing that happened. They answer different questions. And every job emits its lifecycle here (started, queued, done with a finding count, cancelled, or error), so the Event log is the time-ordered feed that complements the Jobs monitor's current-state view: the monitor tells you what is running, the log tells you the order in which everything ran and finished.

Refresh pulls new events; Clear empties the buffer (a capped ring, so it never grows without bound).

10.3 When to reach for each

Reach for the Jobs monitor while work is in flight: to confirm a scan is progressing, to see how many checks are queued behind the cap, to cancel one that is stalled, and to prune the finished rows. It is the automation control room.

Reach for the Event log to reconstruct order across many concurrent jobs, to catch a completion you missed, and above all to find out why something did not run. A refusal (an out-of-scope seed, a missing input) surfaces here as well as in a popup, because a log line alone is never enough; the Event log is where that reason persists after the dialog is gone.

10.4 A worked example

Start a scan from the Target view (or the "Scan this" context action), then open Jobs. Watch the row move from queued to running to done, its finding count settling as it finishes. Start a second scan and, while it runs, select it and Cancel; the row flips to cancelled. Now open Event log: you see the started and done events for the first scan and the cancelled event for the second, in the order they happened, each with its source and level. Clear done in the Jobs monitor to drop the two finished rows and leave only live work.

All of this is available headless, so the agent driving Fissure sees the same state: GET /api/jobs (with the running, queued, and max counts), POST /api/jobs/<id>/cancel, and POST /api/jobs/clear for the monitor, and GET /api/events for the log, exposed over MCP as the jobs, job_cancel, jobs_clear, and events tools.

Chapter 11 - Automation Playbooks and Lab

11.1 New-target baseline

Set scope, browse manually with the proxy on, run Discover for content mapping, let the live passive scripts and HaE rules run, review the Target map and the Dashboard, and write target notes: technologies, routes, the authentication model, interesting patterns, and a noise list for filters.

11.2 Authorization automation

Create two or more legitimate test accounts, tag traffic by identity (Volume IV), capture a baseline per role, use Auto-replay or the Auth matrix for narrow replay, filter by status and length differences, and compare original, modified, and unauthenticated responses in the Comparer.

11.3 Lab

Use a legal training application.

  1. Configure scope, then browse five features with the proxy on.
  2. Confirm the live passive scripts and HaE rules populate the Findings and the Highlight/Extracted columns.
  3. Add one HaE rule for a technology or error pattern, then tighten it until the false positives are acceptable.
  4. Drop one passive .bcheck into resources/checks/ and confirm it runs on proxy traffic.
  5. Create one Auto-replay rule that swaps account A's token for account B's, run it on a captured request, and read the diff log.
  6. Enable one session-handling rule so a scan survives a forced re-login.
  7. Build a four-node workflow (send, transform, filter gate, passive report), Save it, Run it against one in-scope URL, and read the per-node trace and any finding it produced.
  8. Add one recurring schedule for a target, enable the control API, click Run now, and after a scheduler tick read the Last and Delta columns.
  9. Open the Jobs monitor while a scan runs, cancel a second scan, then open the Event log and find both the completion and the cancellation events.
  10. Verify one automated result manually in the Repeater and write an evidence note. Report nothing from a color or status label alone.