ikanban 0.3.4 → 0.4.1

package/README.md

@@ -7,6 +7,9 @@ results into [iKanban](https://i-kanban.com).
 npx ikanban secscan                 # dependencies, committed secrets, risky file permissions
 npx ikanban aiscan --help           # red-team scan of your AI app (OWASP LLM Top 10)
 npx ikanban secscan --publish       # also file the report and findings into iKanban
+npx ikanban infrascan --image app:1 # IaC misconfiguration and container image scan (Trivy)
+npx ikanban dastscan --url URL      # passive web scan of a registered URL (OWASP ZAP in Docker)
+npx ikanban secscan --task IKA-123  # also show the run in that task's Pipelines
 npx ikanban roadmap sync plan.json  # make the Roadmap plan match the plan file
 npx ikanban hooks install           # sync plan files on every agent write and git push
 ```
@@ -23,10 +26,44 @@ exits 1 when the Roadmap differs. With no file it syncs every tracked plan file.
 agent hook for Claude Code, Gemini CLI and Copilot CLI (`.iKanban/hooks/roadmap-sync.js`).
 No CI is needed.
 
+## Infrastructure scans
+
+`infrascan` runs [Trivy](https://github.com/aquasecurity/trivy) on the repository's IaC files
+(`trivy fs --scanners misconfig`) and on each `--image` (`trivy image`). `dastscan` runs the
+[OWASP ZAP](https://www.zaproxy.org/docs/docker/baseline-scan/) baseline scan in Docker: it reads
+the site's responses and does not attack. It scans only a URL the team registered in iKASecure →
+Infrastructure, so it always needs `--team` and a key. Findings show on the Infrastructure tab. A
+missing Trivy or Docker is reported as SKIPPED with the install command, never as a pass.
+
+`infrascan` starts with an inventory of each `--path` (repeat it when infrastructure lives in
+another folder or repository): what it found, what Trivy scanned, and what it could not scan and
+why. Trivy reads Dockerfile/Containerfile, Kubernetes, Helm, Terraform, CloudFormation and Azure
+ARM files. Images named in docker-compose files are scanned too (`--no-compose-images` to skip).
+Infrastructure written as code (AWS CDK, Pulumi, CDK for Terraform, Vagrant, Ansible, cloud-SDK
+scripts) is listed as found but not scannable, with the next step (for CDK: `npx cdk synth`, then
+rescan). A path with no infrastructure-as-code file is never a pass: its control stays Missing.
+Container images file critical and high findings (all severities stay in the report); a section
+over 500 findings files the 500 worst and counts as incomplete. Trivy runs from the scan folder with
+its own config and ignore file, so a repository's `trivy.yaml` or `.trivyignore` changes nothing, and
+only valid image names from compose files are scanned.
+
+## Scan files
+
+Every scanner keeps its raw tool output and its report in `.iKanban/scans/<scanner>-<time>/` in
+the repository (`--work-dir PATH` or `IKANBAN_SCAN_DIR` to put it elsewhere). The folder holds its
+own `.gitignore`, so nothing in it is committed. Delete old runs whenever you like.
+
+## Pipelines
+
+Every scanner takes `--task IKA-123` (or `IKANBAN_TASK`) and `--task-team` (default `--team`). The
+run then shows in that task's Pipelines view: running, then passed, failed or skipped with a
+one-line summary, and the masked report as its log. A plan without Pipelines never fails the scan.
+
 ## What you need
 
 - Node.js 18 or newer.
 - Python 3.9 or newer. The scanners are Python; `ikanban` finds `python3`, `python` or `py -3`.
+- `infrascan`: Trivy (macOS `brew install trivy`; other systems: a release binary). `dastscan`: Docker.
 
 ## Free and paid
 

package/bin/ikanban.js

@@ -10,10 +10,12 @@ const { version } = require("../package.json");
 const COMMANDS = {
   aiscan: { file: "ikanban-aiscan.py", about: "Red-team scan of your AI app (OWASP LLM Top 10)" },
   secscan: { file: "ikanban-secscan.py", about: "Dependency, secret and file-permission scan of a repo" },
+  infrascan: { file: "ikanban-infrascan.py", about: "Container image and IaC scan (needs Trivy)" },
+  dastscan: { file: "ikanban-dastscan.py", about: "Passive web scan of a registered URL (needs Docker)" },
 };
 
 function help() {
-  const lines = Object.entries(COMMANDS).map(([n, c]) => `  ${n.padEnd(9)}${c.about}`);
+  const lines = Object.entries(COMMANDS).map(([n, c]) => `  ${n.padEnd(10)}${c.about}`);
   console.log(`ikanban ${version}
 
 Usage: ikanban <command> [options]
@@ -26,7 +28,8 @@ ${lines.join("\n")}
   pipeline Report a task's stage and stream its log to iKanban (any CI)
 
 Run "ikanban <command> --help" for its options. Add --publish to file the
-results into iKanban (needs an API token; the server checks your plan).
+results into iKanban (needs an API token; the server checks your plan), and
+--task IKA-123 to show the run in that task's Pipelines.
 Needs Python 3.9 or newer.`);
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ikanban",
-  "version": "0.3.4",
+  "version": "0.4.1",
   "description": "iKanban CLI: AI and security scans of your own repo, with results filed into iKanban",
   "bin": { "ikanban": "bin/ikanban.js" },
   "files": ["bin", "lib", "hooks", "scanners", "README.md", "LICENSE.md"],

package/scanners/ikanban-aiscan.py

@@ -57,7 +57,7 @@ PROMPTFOO_VERSION = "0.123.1"
 # so this string is the release identity. Bump it when publishing a release —
 # a customer pinning a version is pinning this value, and re-uploading different
 # bytes under a version someone already fetched defeats the sha256 they pinned.
-AISCAN_VERSION = "0.3.2"
+AISCAN_VERSION = "0.5.0"
 
 # The ten categories, their labels, and their plugins -- the forward map, copied
 # from promptfoo's OWASP_LLM_TOP_10_MAPPING (src/redteam/constants/frameworks.ts).
@@ -386,14 +386,41 @@ def run_promptfoo(args, cwd, allow_remote):
 EVAL_FAILED_TESTS_EXIT = 100
 
 
+SECRET_KEY = re.compile(r"token|authorization|api.?key|secret|password|bearer", re.I)
+
+
+def config_secrets(node) -> set:
+    """Every credential-looking value in a promptfoo config (header, auth token, key)."""
+    out = set()
+    if isinstance(node, dict):
+        for k, v in node.items():
+            if isinstance(v, str) and SECRET_KEY.search(str(k)) and len(v) >= 8:
+                out |= {v, v.removeprefix("Bearer ").strip()}
+            out |= config_secrets(v)
+    elif isinstance(node, list):
+        for v in node:
+            out |= config_secrets(v)
+    return {x for x in out if len(x) >= 8}
+
+
 def scan_category(label, target, cfg, workdir, allow_remote):
-    """generate + eval one category. Returns (findings, plugins_that_ran, errors)."""
-    cfg_path = workdir / "config.yaml"
-    cases_path = workdir / "cases.yaml"
-    out_path = workdir / "results.json"
-    for p in (cases_path, out_path):
-        if p.exists():
-            p.unlink()
+    """generate + eval one category. Returns (findings, plugins_that_ran, errors).
+
+    Plan 11 H12-T10 review: promptfoo's config and cases hold the iKanban token, so they live
+    in a private folder (0700, deleted after the category) that is also promptfoo's working
+    folder, away from the repository and its .npmrc. Only the results, with every credential
+    replaced, are copied into the scan's work folder."""
+    private = Path(tempfile.mkdtemp(prefix="ikanban-aiscan-"))  # mkdtemp creates it 0700
+    try:
+        return _scan_category(label, target, cfg, workdir, allow_remote, private)
+    finally:
+        shutil.rmtree(private, ignore_errors=True)
+
+
+def _scan_category(label, target, cfg, workdir, allow_remote, private):
+    cfg_path = private / "config.yaml"
+    cases_path = private / "cases.yaml"
+    out_path = private / "results.json"
 
     # promptfoo reads YAML, but its config loader accepts JSON in a .yaml file
     # (YAML 1.2 is a JSON superset) -- which keeps this file free of a YAML
@@ -401,7 +428,7 @@ def scan_category(label, target, cfg, workdir, allow_remote):
     cfg_path.write_text(json.dumps(cfg, indent=2), encoding="utf-8")
 
     if not run_promptfoo(
-        ["redteam", "generate", "-c", str(cfg_path), "-o", str(cases_path)], workdir, allow_remote
+        ["redteam", "generate", "-c", str(cfg_path), "-o", str(cases_path)], private, allow_remote
     ):
         return None
     if not cases_path.exists():
@@ -411,13 +438,18 @@ def scan_category(label, target, cfg, workdir, allow_remote):
     # tests failed, i.e. attacks got through, i.e. exactly the findings we came
     # for. The results file decides, not the exit code.
     run_promptfoo(
-        ["redteam", "eval", "-c", str(cases_path), "-o", str(out_path), "--no-cache"], workdir, allow_remote
+        ["redteam", "eval", "-c", str(cases_path), "-o", str(out_path), "--no-cache"], private, allow_remote
     )
     if not out_path.exists():
         log("  promptfoo wrote no results file — the run genuinely failed")
         return None
 
-    doc = json.loads(out_path.read_text(encoding="utf-8"))
+    raw = out_path.read_text(encoding="utf-8")
+    redacted = raw
+    for secret in sorted(config_secrets(cfg), key=len, reverse=True):
+        redacted = redacted.replace(secret, "[hidden]")
+    write_private(workdir / f"results-{re.sub(r'[^A-Za-z0-9_-]+', '_', label)}.json", redacted)
+    doc = json.loads(raw)
     rows = doc.get("results", {}).get("results", [])
     # Coverage is whatever actually produced test rows. A plugin that needed the
     # hosted generator contributes none, and is named in the report rather than
@@ -669,6 +701,167 @@ def publish(findings, run_id, base_url, token, team_id, coverage, plugin_results
         return False, 0, 0
 
 
+# ── Scan work folder (plan 11 H12-T10, owner): raw tool output and the report live under
+# <repo>/.iKanban/scans/<scanner>-<UTC time>/, never the system temp folder. The scans folder
+# holds its own .gitignore ("*"), so nothing in it is committed and no repo .gitignore is edited.
+def add_work_dir_arg(ap):
+    ap.add_argument("--work-dir", default=os.environ.get("IKANBAN_SCAN_DIR", ""),
+                    help="Folder for this scan's files (or IKANBAN_SCAN_DIR; default "
+                         "<repository>/.iKanban/scans)")
+
+
+def scan_work_dir(scanner: str, base: Path, override: str = "") -> Path:
+    scans = Path(override).expanduser().resolve() if override else base / ".iKanban" / "scans"
+    scans.mkdir(parents=True, exist_ok=True)
+    ignore = scans / ".gitignore"
+    if not ignore.exists():
+        ignore.write_text("*\n")
+    run_dir = scans / f"{scanner}-{datetime.now(timezone.utc):%Y%m%d-%H%M%S}"
+    run_dir.mkdir(mode=0o700, exist_ok=True)
+    os.chmod(run_dir, 0o700)  # mkdir's mode is masked by umask; raw tool output stays private
+    return run_dir
+
+
+def write_private(path: Path, text: str) -> None:
+    """Write a file (0600) without following a symlink planted at its name: write a new
+    temp file next to it (O_EXCL | O_NOFOLLOW), then rename it over the name."""
+    tmp = path.with_name(f".{path.name}.{os.getpid()}.tmp")
+    fd = os.open(tmp, os.O_WRONLY | os.O_CREAT | os.O_EXCL | getattr(os, "O_NOFOLLOW", 0), 0o600)
+    with os.fdopen(fd, "w", encoding="utf-8") as f:
+        f.write(text)
+    os.replace(tmp, path)
+
+
+def slug(text: str) -> str:
+    return re.sub(r"[^A-Za-z0-9._-]+", "_", text).strip("_")[:80] or "x"
+
+
+# ── Pipelines (plan 11 H12, owner): with --task, the scan shows in that task's Pipelines view ──
+# Same calls as `ikanban pipeline` (vibe-cli/lib/pipeline.js → routes/pipeline.rs): an event
+# "running" at the start, "passed" / "failed" / "skipped" at the end with a one-line detail,
+# then the report as log chunks. A plan without Pipelines (402) or any error never fails the scan.
+_UUID = re.compile(r"^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$", re.I)
+PIPE_CHUNK = 15 * 1024  # the server takes 16 KB per chunk
+LAST_RUN = {"report": "", "detail": "", "skipped": False}
+
+
+def add_pipeline_args(ap):
+    ap.add_argument("--task", default=os.environ.get("IKANBAN_TASK", ""),
+                    help="Also show this run in the task's Pipelines (a key like IKA-123, or its id; "
+                         "or IKANBAN_TASK)")
+    ap.add_argument("--task-team", default=os.environ.get("IKANBAN_TASK_TEAM", ""),
+                    help="The task's team: id or identifier like IKA (or IKANBAN_TASK_TEAM; default --team)")
+
+
+def summary_detail(counts: dict, total: int, skipped: list) -> str:
+    if skipped and not total and all(s for s in skipped):
+        return ("SKIPPED: " + "; ".join(skipped))[:300]
+    worst = ", ".join(f"{counts[s]} {s}" for s in ("critical", "high", "medium", "low") if counts.get(s))
+    return f"{total} findings" + (f": {worst}" if worst else "")
+
+
+def mask_report(text: str) -> str:
+    """The report is masked already; mask again before it leaves for Pipelines."""
+    scrub = globals().get("scrub_report")
+    if scrub:
+        return scrub(text)[0]
+    text = re.sub(r"\bvk_[A-Za-z0-9_-]{8,}", lambda m: m.group(0)[:4] + "…[hidden]", text)
+    home = str(Path.home())
+    return text.replace(home, "~") if home and home != "/" else text
+
+
+def log_chunks(text: str) -> list:
+    """Whole lines, each chunk under PIPE_CHUNK bytes (a longer single line is cut)."""
+    chunks, cur = [], ""
+    for line in text.splitlines(keepends=True):
+        while len(line.encode()) > PIPE_CHUNK:
+            head = line.encode()[:PIPE_CHUNK].decode(errors="ignore")
+            chunks.append(head)
+            line = line[len(head):]
+        if len((cur + line).encode()) > PIPE_CHUNK:
+            chunks.append(cur)
+            cur = ""
+        cur += line
+    if cur:
+        chunks.append(cur)
+    return chunks
+
+
+class Pipeline:
+    def __init__(self, stage, task, team, base_url, token):
+        self.stage, self.task, self.team, self.base, self.token = stage, task, team, base_url, token
+        self.on = bool(task and team and token)
+        self.tid = None
+
+    def _off(self, why):
+        self.on = False
+        note = "the plan does not include Pipelines" if "402" in str(why) else why
+        print(f"ikanban: Pipelines not updated ({note}); the scan goes on", file=sys.stderr)
+
+    def _call(self, method, path, body=None):
+        try:
+            return api(method, path, self.base, self.token, body)
+        except SystemExit as e:  # ikanban_api refuses a base URL that is not iKanban's
+            return False, str(e)
+
+    def _post(self, path, body):
+        if not self.on:
+            return
+        if self.tid is None:
+            if _UUID.match(self.team):
+                self.tid = self.team
+            else:
+                ok, teams = self._call("GET", "/teams")
+                if not ok:
+                    return self._off(teams)
+                found = [t.get("id") for t in teams or [] if (t.get("identifier") or "").lower() == self.team.lower()]
+                if not found:
+                    return self._off(f"team {self.team} not found among your teams")
+                self.tid = found[0]
+        ok, data = self._call("POST", f"/teams/{self.tid}/{path}", body)
+        if not ok:
+            self._off(data or "this iKanban server has no Pipelines")
+
+    def start(self):
+        self._post("pipeline-events", {"task": self.task, "stage": self.stage, "status": "running",
+                                       "source": "laptop", "actor": f"ikanban-{self.stage}"})
+
+    def finish(self, code):
+        status = "failed" if code else ("skipped" if LAST_RUN["skipped"] else "passed")
+        detail = LAST_RUN["detail"] or ("the scan stopped with an error" if code == 2 else "")
+        if code == 1 and not LAST_RUN["skipped"]:
+            detail = (detail + " (at or above --fail-on)").strip()
+        self._post("pipeline-events", {"task": self.task, "stage": self.stage, "status": status,
+                                       "source": "laptop", "actor": f"ikanban-{self.stage}",
+                                       "detail": detail[:300] or None})
+        for chunk in log_chunks(mask_report(LAST_RUN["report"])):
+            self._post("pipeline-logs", {"task": self.task, "stage": self.stage, "text": chunk})
+
+
+def run_main(stage, main_fn, argv=None):
+    """main() as it is, wrapped in Pipelines events when --task is given."""
+    raw = sys.argv[1:] if argv is None else argv
+    if any(a in ("-h", "--help", "--version", "--list-apps") for a in raw):
+        return main_fn(argv)
+    pre = argparse.ArgumentParser(add_help=False)
+    pre.add_argument("--task", default=os.environ.get("IKANBAN_TASK", ""))
+    pre.add_argument("--task-team", default=os.environ.get("IKANBAN_TASK_TEAM", ""))
+    pre.add_argument("--team", default=os.environ.get("IKANBAN_TEAM_ID", ""))
+    pre.add_argument("--token", default=os.environ.get("VIBE_API_TOKEN", ""))
+    pre.add_argument("--base-url", default=os.environ.get("IKANBAN_BASE_URL", "https://api.i-kanban.com"))
+    known, _ = pre.parse_known_args(raw)
+    pl = Pipeline(stage, known.task, known.task_team or known.team, known.base_url, known.token)
+    pl.start()
+    try:
+        code = main_fn(argv)
+    except SystemExit as e:
+        if not isinstance(e.code, int):
+            print(e.code, file=sys.stderr)
+        code = e.code if isinstance(e.code, int) else 2
+    pl.finish(code)
+    return code
+
+
 def main(argv=None):
     ap = argparse.ArgumentParser(prog="ikanban aiscan")
     # Lets someone who downloaded a copy tell which release it is, and verify it
@@ -701,6 +894,8 @@ def main(argv=None):
                     help="Permit --config, --html and --out to point outside the working "
                          "directory. Off by default so a mistyped path cannot overwrite "
                          "something elsewhere; turn it on for CI writing to an artifacts dir.")
+    add_pipeline_args(ap)
+    add_work_dir_arg(ap)
     args = ap.parse_args(argv)
 
     # Resolve every caller-supplied path up front, before any scanning happens.
@@ -710,6 +905,9 @@ def main(argv=None):
         args.html = safe_path(args.html, "--html", args.allow_outside_cwd)
     if args.out:
         args.out = safe_path(args.out, "--out", args.allow_outside_cwd)
+    # Plan 11 H12-T10: the scan's own folder follows the same rule as every other path.
+    if args.work_dir:
+        args.work_dir = str(safe_path(args.work_dir, "--work-dir", args.allow_outside_cwd))
 
     if args.config:
         args.config = safe_path(args.config, "--config", args.allow_outside_cwd)
@@ -783,66 +981,65 @@ def main(argv=None):
     # than leaving 'no findings' to mean three different things.
     per_category = []
 
-    with tempfile.TemporaryDirectory(prefix="ikanban-aiscan-") as tmp:
-        workdir = Path(tmp)
-        for _collection, label, plugins in selected:
-            if not plugins:
-                # LLM03. promptfoo ships no supply-chain plugins at all, so this
-                # row can never be earned. Reporting "0 findings" would read as a
-                # pass, which is the one thing it must not do.
-                skipped.append(label)
-                per_category.append({"category": label, "asked": 0, "ran": 0, "skipped": []})
-                log(f"{label}: SKIPPED — promptfoo ships no plugins for this category")
-                continue
-            log(f"{label}: generating and running {args.num_tests} tests per plugin…")
-            cfg = build_config(args.target, spec, plugins, args.num_tests,
-                               args.base_url, args.token, args.workspace_id)
-            got = scan_category(label, args.target, cfg, workdir, args.allow_remote_generation)
-            if got is None:
-                failed.append(label)
-                per_category.append(
-                    {"category": label, "asked": len(plugins), "ran": 0, "skipped": sorted(plugins)}
-                )
-                continue
-            category_findings, ran, cat_errors, tally = got
-            total_errors += cat_errors
-            plugins_ran |= ran
-            # IKA-1786: one row per plugin per category. A plugin can appear in
-            # two categories (pii:* spans LLM02 and LLM08), and those are
-            # separate measurements -- 'prompt-extraction under LLM07' is the
-            # thing a weakest-areas ranking is about, not the plugin in general.
-            for plugin, t in sorted(tally.items()):
-                plugin_results.append(
-                    {
-                        "plugin_id": plugin,
-                        "llm_category": label,
-                        "target": args.target,
-                        "severity": t["severity"],
-                        "attempted": t["attempted"],
-                        "failed": t["failed"],
-                        "errored": t["errored"],
-                    }
-                )
-            missing = sorted(set(plugins) - ran)
-            plugins_skipped |= set(missing)
+    workdir = scan_work_dir("aiscan", Path.cwd(), args.work_dir)
+    for _collection, label, plugins in selected:
+        if not plugins:
+            # LLM03. promptfoo ships no supply-chain plugins at all, so this
+            # row can never be earned. Reporting "0 findings" would read as a
+            # pass, which is the one thing it must not do.
+            skipped.append(label)
+            per_category.append({"category": label, "asked": 0, "ran": 0, "skipped": []})
+            log(f"{label}: SKIPPED — promptfoo ships no plugins for this category")
+            continue
+        log(f"{label}: generating and running {args.num_tests} tests per plugin…")
+        cfg = build_config(args.target, spec, plugins, args.num_tests,
+                           args.base_url, args.token, args.workspace_id)
+        got = scan_category(label, args.target, cfg, workdir, args.allow_remote_generation)
+        if got is None:
+            failed.append(label)
             per_category.append(
+                {"category": label, "asked": len(plugins), "ran": 0, "skipped": sorted(plugins)}
+            )
+            continue
+        category_findings, ran, cat_errors, tally = got
+        total_errors += cat_errors
+        plugins_ran |= ran
+        # IKA-1786: one row per plugin per category. A plugin can appear in
+        # two categories (pii:* spans LLM02 and LLM08), and those are
+        # separate measurements -- 'prompt-extraction under LLM07' is the
+        # thing a weakest-areas ranking is about, not the plugin in general.
+        for plugin, t in sorted(tally.items()):
+            plugin_results.append(
                 {
-                    "category": label,
-                    "asked": len(plugins),
-                    "ran": len(set(plugins) & ran),
-                    "skipped": missing,
+                    "plugin_id": plugin,
+                    "llm_category": label,
+                    "target": args.target,
+                    "severity": t["severity"],
+                    "attempted": t["attempted"],
+                    "failed": t["failed"],
+                    "errored": t["errored"],
                 }
             )
-            if missing:
-                uncovered.append((label, missing))
-                log(f"  did not run: {', '.join(missing)}")
-            if not ran:
-                log("  NOTHING RAN — every plugin here needs promptfoo's hosted generator")
-            else:
-                scanned += 1
-            log(f"  {len(category_findings)} finding(s)"
-                + (f", {cat_errors} error(s)" if cat_errors else ""))
-            findings.extend(category_findings)
+        missing = sorted(set(plugins) - ran)
+        plugins_skipped |= set(missing)
+        per_category.append(
+            {
+                "category": label,
+                "asked": len(plugins),
+                "ran": len(set(plugins) & ran),
+                "skipped": missing,
+            }
+        )
+        if missing:
+            uncovered.append((label, missing))
+            log(f"  did not run: {', '.join(missing)}")
+        if not ran:
+            log("  NOTHING RAN — every plugin here needs promptfoo's hosted generator")
+        else:
+            scanned += 1
+        log(f"  {len(category_findings)} finding(s)"
+            + (f", {cat_errors} error(s)" if cat_errors else ""))
+        findings.extend(category_findings)
 
     log("")
     # Errors get their own number. A run where many tests errored is not a clean
@@ -857,6 +1054,20 @@ def main(argv=None):
     for label, missing in uncovered:
         log(f"  partial — {label}: {len(missing)} plugin(s) unavailable locally")
 
+    # Plan 11 H12: the Pipelines log (no attack prompts or answers: titles and counts only).
+    counts = {s: sum(1 for f in findings if f["severity"] == s) for s in SEVERITIES}
+    LAST_RUN.update(
+        report="\n".join(
+            [f"# AI endpoint scan — {args.target}", "", f"{len(findings)} finding(s) across {scanned} categories tested"]
+            + [f"- [{f['severity']}] {f['llm_category']}: {f['title']}" for f in findings]
+            + [f"- not covered: {label}" for label in skipped]
+            + [f"- DID NOT RUN: {label}" for label in failed]),
+        detail=summary_detail(counts, len(findings), []) + (f"; {len(failed)} categories did not run" if failed else ""),
+        skipped=scanned == 0 and not findings,
+    )
+    write_private(workdir / "report.md", LAST_RUN["report"])
+    log(f"scan files: {workdir}")
+
     coverage = {
         "target": args.target,
         "categories_tested": scanned,
@@ -911,4 +1122,4 @@ def main(argv=None):
 
 
 if __name__ == "__main__":
-    sys.exit(main())
+    sys.exit(run_main("aiscan", main))