Anti-Violence Tech — Research Wiki

A zetl vault that collects research into anti-violence and women’s safety technology and structures it into a navigable wiki — so that every participant in the project shares a common understanding rather than a pile of disconnected docs and bookmarks.

Scope: personal-safety apps, domestic- and intimate-partner-violence support tools, bystander-intervention platforms, evidence-documentation tools, safety wearables — and the threats they respond to (stalkerware, coercive control, location tracking).

Each note is a plain Markdown file connected to others by [[wikilinks]], forming a queryable knowledge graph. Start with concept-map for the guided tour, or browse index (the Map of Content).

Toolchain directive

This project is built with three CLI tools. Use them — they each own one stage of the loop; don’t reinvent their jobs.

Tool	Role	Job in this project
`ar-crawl`	Agent-first web crawler (clean JSON/CSV/SQLite)	Gather. Crawl app-store listings, vendor sites, NGO/government reports, news, and academic sources into structured data for an agent to read.
`zetl`	Bidirectional `[[wikilink]]` graph CLI	Structure. Turn findings into wikilinked Markdown notes. This vault is a zetl graph. Query, validate, and build the site with zetl.
`hence`	Multi-agent plan coordination via defeasible logic	Coordinate. Plan and track research/curation work across agents; record decisions and let stronger evidence defeat weaker conclusions.

The loop

   ┌──────────┐   raw structured data   ┌─────────────────────┐   notes    ┌──────────┐
   │ ar-crawl │ ─────────────────────▶  │ agent reads + writes │ ────────▶  │   zetl   │
   └──────────┘                         └─────────────────────┘            └──────────┘
        ▲                                                                        │
        │                          hence plan tracks the work                   │ check / build
        └────────────────────────────────────────────────────────────────────◀─┘

Gather — ar-crawl. Point the crawler at a source (an app’s store page, a vendor site, a tech-abuse report) and capture clean structured output:
```
ar-crawl <url> --format json -o scratch/<source>.json
```
The crawler does retrieval only — AI is in your agent, not in the tool. An agent reads the JSON and writes the note.
Structure — zetl. Write or update a Markdown note under apps/, concepts/, or research/, cross-linking with [[wikilinks]]. Then validate and preview:
```
zetl check          # dead links, orphans, syntax
zetl serve          # browse locally
zetl build --out-dir dist
```
Coordinate — hence. Capture the plan (which sources to crawl, which notes to write/review) as a hence plan so multiple agents can work without colliding and conclusions stay revisable:
```
hence plan ...      # see `hence --help`
```

Conventions

One Markdown file per entity. An app, a concept, or a research source each gets its own slugified file (bSafe → apps/bsafe.md).
Wikilinks are the connective tissue. Link liberally. A [[Coercive Control]] link that has no page yet is a wanted page, not an error — it marks something to backfill later (expected zetl pattern).
Type your edges with named predicates. In a note’s relationship lists, record how two pages connect, not just that they do, using zetl’s named-edge syntax — a lowercase snake_case predicate before the link:
```
- implements::[[Panic Button]]
- risks::[[Location Tracking Abuse]]
  - Continuous location sharing is the same capability an abuser exploits.
```
Predicates are only recognised at the start of a list item (the canonical - predicate::[[Target]] form) — links inside prose stay untyped, which is fine. Query them with zetl edges --predicate <p>; lint vocabulary drift with zetl check.
Concept hubs ([[Panic Button]], [[Trauma-Informed Design]], [[Stalkerware]]) act as junctions. App notes assert app→concept edges; concept pages stay focused on concept→concept edges and let backlinks surface their members.
index is the Map of Content; concept-map is the prose tour.

Predicate vocabulary

The vocabulary is emergent — just type the edge, and converge on this set (reach for the most specific one; related_to is the catch-all):

Predicate	From → To	Meaning
`instance_of::`	app → category	belongs to a category/type
`implements::`	app → feature	provides this capability
`addresses::`	app/concept → violence	targets this form of harm
`protects_against::`	app/feature → threat	defends the user against it
`risks::`	app/feature → abuse	can be misused into / carries this risk
`inverts_to::`	feature → abuse	benign capability and its abuse twin
`informed_by::`	design → principle	built on this design principle
`subtype_of::`	concept → concept	narrower kind of a broader concept
`part_of::` · `paired_with::`	concept → concept	composition / common combination
`enables::` · `used_in::`	threat → harm	a threat facilitates / appears in
`documents::` · `documented_in::`	research ↔ subject	evidence link
`related_to::`	any	catch-all (prefer something more specific)

App note structure (`apps/`)

# <App Name>

**Vendor** · **Platform** · **Cost** · **Status**

## Summary
1–3 paragraphs in your own words.

## Safety features
- implements::[[Panic Button]]
- implements::[[Location Sharing]]

## Addresses
- addresses::[[Gender-Based Violence]]

## Privacy & risks
- risks::[[Location Tracking Abuse]]
  - Why this capability can be turned against the user (edge annotation).

## Connections
- instance_of::[[Personal Safety Apps]]
- documented_in::[[Tech Abuse and Coercive Control]]

## Sources
- Crawled URLs (what ar-crawl fetched).

**Tags:** #app #personal-safety

Concept notes (concepts/) and research notes (research/) follow the same spirit: a definition/summary, then In this vault / Connections wikilink sections. See existing notes for the pattern.

Layout

apps/ — one note per app / product / device
orgs/ — organisations and initiatives (e.g. Insight Exchange, the Apps Against Abuse Challenge)
resources/ — practice resources, kits, frameworks (e.g. My Safety Kit)
concepts/ — concept hubs and definitions
research/ — papers, NGO/government reports, studies, news analyses
index.md — Map of Content
concept-map.md — the conceptual tour
scratch/ — raw ar-crawl output (gitignored; not part of the graph)

Commands

zetl list           # list notes
zetl check          # validate links
zetl stats          # graph stats
zetl search "<q>"   # full-text search
zetl serve          # browse
zetl build          # static site

Install the tools

curl -fsSL https://files.anuna.io/zetl/latest/install.sh | bash    # zetl
curl -fsSL https://files.anuna.io/hence/latest/install.sh | bash   # hence
# ar-crawl: see the ar-crawl repo for build/run instructions