ikanban 0.4.1 → 0.4.3

package/README.md

@@ -32,8 +32,11 @@ No CI is needed.
 (`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.
+Infrastructure, so it always needs `--team` and a key. Findings show on the Infrastructure tab.
+Without a `trivy` command, `infrascan` runs Trivy's official container (`aquasec/trivy:0.76.0`)
+when Docker is running: the repository is mounted read-only, and the Docker socket only for an
+image that exists on this machine alone. The report names the Trivy that ran. With neither Trivy
+nor Docker, the scan is reported as SKIPPED with both fixes, 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
@@ -47,6 +50,14 @@ over 500 findings files the 500 worst and counts as incomplete. Trivy runs from
 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.
 
+## Dependencies without a lockfile
+
+`npm audit` needs a lockfile. When a folder has none and npm cannot resolve its tree (ERESOLVE, a
+peer conflict), `secscan` writes a lockfile for a copy of `package.json` in its scan folder
+(`npm install --package-lock-only --ignore-scripts --legacy-peer-deps`, without the folder's
+`.npmrc`) and audits that copy. Nothing is written into the repository. If npm still cannot
+resolve the tree, the folder is SKIPPED with the fix: commit a `package-lock.json`.
+
 ## Scan files
 
 Every scanner keeps its raw tool output and its report in `.iKanban/scans/<scanner>-<time>/` in
@@ -57,13 +68,14 @@ own `.gitignore`, so nothing in it is committed. Delete old runs whenever you li
 
 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.
+one-line summary, and the masked report as its log. While the scan runs, the stage log gets one
+line as each step starts and ends. 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.
+- `infrascan`: Trivy (macOS `brew install trivy`; other systems: a release binary), or Docker running. `dastscan`: Docker.
 
 ## Free and paid
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ikanban",
-  "version": "0.4.1",
+  "version": "0.4.3",
   "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.5.0"
+AISCAN_VERSION = "0.6.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).
@@ -741,6 +741,8 @@ def slug(text: str) -> str:
 # "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)
+# Every iKanban scanner reports into one named lane, not the server's "legacy" lane.
+PIPE_RUN = "security-scan"
 PIPE_CHUNK = 15 * 1024  # the server takes 16 KB per chunk
 LAST_RUN = {"report": "", "detail": "", "skipped": False}
 
@@ -786,6 +788,18 @@ def log_chunks(text: str) -> list:
         chunks.append(cur)
     return chunks
 
+# The running Pipeline (set by run_main with --task). Owner: Pipelines showed nothing while a
+# scan ran, so each step also sends one line as it starts and ends; the full report follows at the end.
+# Progress lines are fixed status text: never raw tool output or an error body (it can carry
+# secrets or text an attacker wrote). Those stay on local stderr and in the masked report.
+PIPE = None
+
+
+def progress(text: str) -> None:
+    if PIPE:
+        PIPE.log(text)
+
+
 
 class Pipeline:
     def __init__(self, stage, task, team, base_url, token):
@@ -824,7 +838,12 @@ class Pipeline:
 
     def start(self):
         self._post("pipeline-events", {"task": self.task, "stage": self.stage, "status": "running",
-                                       "source": "laptop", "actor": f"ikanban-{self.stage}"})
+                                       "run": PIPE_RUN, "source": "laptop", "actor": f"ikanban-{self.stage}"})
+
+    def log(self, line):
+        """One progress line, sent as it happens (masked like the report). A failure only turns Pipelines off."""
+        self._post("pipeline-logs", {"task": self.task, "run": PIPE_RUN, "stage": self.stage,
+                                     "text": mask_report(line.rstrip("\n"))[:PIPE_CHUNK - 1] + "\n"})
 
     def finish(self, code):
         status = "failed" if code else ("skipped" if LAST_RUN["skipped"] else "passed")
@@ -832,10 +851,10 @@ class Pipeline:
         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}",
+                                       "run": PIPE_RUN, "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})
+            self._post("pipeline-logs", {"task": self.task, "run": PIPE_RUN, "stage": self.stage, "text": chunk})
 
 
 def run_main(stage, main_fn, argv=None):
@@ -852,6 +871,8 @@ def run_main(stage, main_fn, argv=None):
     known, _ = pre.parse_known_args(raw)
     pl = Pipeline(stage, known.task, known.task_team or known.team, known.base_url, known.token)
     pl.start()
+    global PIPE
+    PIPE = pl if pl.on else None
     try:
         code = main_fn(argv)
     except SystemExit as e:
@@ -990,12 +1011,16 @@ def main(argv=None):
             skipped.append(label)
             per_category.append({"category": label, "asked": 0, "ran": 0, "skipped": []})
             log(f"{label}: SKIPPED — promptfoo ships no plugins for this category")
+            progress(f"{label} SKIPPED · no plugins for this category")
             continue
         log(f"{label}: generating and running {args.num_tests} tests per plugin…")
+        # Pipelines get fixed status lines only; log() also carries promptfoo's raw output.
+        progress(f"{label} started · {len(plugins)} plugins, {args.num_tests} tests each")
         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:
+            progress(f"{label} finished · did not run")
             failed.append(label)
             per_category.append(
                 {"category": label, "asked": len(plugins), "ran": 0, "skipped": sorted(plugins)}
@@ -1039,6 +1064,8 @@ def main(argv=None):
             scanned += 1
         log(f"  {len(category_findings)} finding(s)"
             + (f", {cat_errors} error(s)" if cat_errors else ""))
+        progress(f"{label} finished · {len(category_findings)} findings"
+                 + (f", {cat_errors} errors" if cat_errors else ""))
         findings.extend(category_findings)
 
     log("")

package/scanners/ikanban-dastscan.py

@@ -42,7 +42,7 @@ import urllib.request
 from datetime import datetime, timezone
 from pathlib import Path
 
-DASTSCAN_VERSION = "1.1.0"
+DASTSCAN_VERSION = "1.2.0"
 
 SEVERITIES = ["critical", "high", "medium", "low", "info"]
 SEVERITY_RANK = {s: i for i, s in enumerate(SEVERITIES)}
@@ -266,6 +266,8 @@ def slug(text: str) -> str:
 # "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)
+# Every iKanban scanner reports into one named lane, not the server's "legacy" lane.
+PIPE_RUN = "security-scan"
 PIPE_CHUNK = 15 * 1024  # the server takes 16 KB per chunk
 LAST_RUN = {"report": "", "detail": "", "skipped": False}
 
@@ -311,6 +313,18 @@ def log_chunks(text: str) -> list:
         chunks.append(cur)
     return chunks
 
+# The running Pipeline (set by run_main with --task). Owner: Pipelines showed nothing while a
+# scan ran, so each step also sends one line as it starts and ends; the full report follows at the end.
+# Progress lines are fixed status text: never raw tool output or an error body (it can carry
+# secrets or text an attacker wrote). Those stay on local stderr and in the masked report.
+PIPE = None
+
+
+def progress(text: str) -> None:
+    if PIPE:
+        PIPE.log(text)
+
+
 
 class Pipeline:
     def __init__(self, stage, task, team, base_url, token):
@@ -349,7 +363,12 @@ class Pipeline:
 
     def start(self):
         self._post("pipeline-events", {"task": self.task, "stage": self.stage, "status": "running",
-                                       "source": "laptop", "actor": f"ikanban-{self.stage}"})
+                                       "run": PIPE_RUN, "source": "laptop", "actor": f"ikanban-{self.stage}"})
+
+    def log(self, line):
+        """One progress line, sent as it happens (masked like the report). A failure only turns Pipelines off."""
+        self._post("pipeline-logs", {"task": self.task, "run": PIPE_RUN, "stage": self.stage,
+                                     "text": mask_report(line.rstrip("\n"))[:PIPE_CHUNK - 1] + "\n"})
 
     def finish(self, code):
         status = "failed" if code else ("skipped" if LAST_RUN["skipped"] else "passed")
@@ -357,10 +376,10 @@ class Pipeline:
         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}",
+                                       "run": PIPE_RUN, "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})
+            self._post("pipeline-logs", {"task": self.task, "run": PIPE_RUN, "stage": self.stage, "text": chunk})
 
 
 def run_main(stage, main_fn, argv=None):
@@ -377,6 +396,8 @@ def run_main(stage, main_fn, argv=None):
     known, _ = pre.parse_known_args(raw)
     pl = Pipeline(stage, known.task, known.task_team or known.team, known.base_url, known.token)
     pl.start()
+    global PIPE
+    PIPE = pl if pl.on else None
     try:
         code = main_fn(argv)
     except SystemExit as e:
@@ -443,8 +464,12 @@ def main(argv=None):
         return 2
 
     work = scan_work_dir("dastscan", Path.cwd(), args.work_dir)
+    progress(f"dastscan {DASTSCAN_VERSION} · ZAP baseline on {url}: spider {args.minutes} min, "
+             f"at most {args.max_minutes} min …")
     report, skipped_why = run_zap(url, args.minutes, args.max_minutes, work)
     findings = parse_zap(report) if report is not None else []
+    progress(f"ZAP baseline on {url} … " + (f"done, {len(findings)} alerts" if report is not None
+                                             else "SKIPPED (the reason is in the report)"))
     ran = [f"zap-baseline.py -t {url} -m {args.minutes}"] if report is not None else []
     md, counts, total = build_report(url, findings, [skipped_why] if skipped_why else [], ran)
     LAST_RUN.update(report=md, detail=summary_detail(counts, total, [] if ran else [skipped_why]),

package/scanners/ikanban-infrascan.py

@@ -37,6 +37,7 @@ Helpers below are copied from ikanban-secscan.py (the scanners ship as single fi
 from __future__ import annotations
 
 import argparse
+import functools
 import hashlib
 import json
 import os
@@ -51,15 +52,20 @@ from dataclasses import dataclass, field
 from datetime import datetime, timezone
 from pathlib import Path
 
-INFRASCAN_VERSION = "1.1.0"
+INFRASCAN_VERSION = "1.2.0"
 
 SEVERITIES = ["critical", "high", "medium", "low", "info"]
 SEVERITY_RANK = {s: i for i, s in enumerate(SEVERITIES)}
 # Trivy's severities; UNKNOWN (no score yet) is filed as low.
 TRIVY_SEVERITY = {"CRITICAL": "critical", "HIGH": "high", "MEDIUM": "medium", "LOW": "low", "UNKNOWN": "low"}
 
-TRIVY_INSTALL = ("Trivy is not installed — macOS: `brew install trivy`; Linux and Windows: a release "
-                 "binary from https://github.com/aquasecurity/trivy/releases, or `docker run aquasec/trivy`")
+TRIVY_INSTALL = ("Trivy is not installed and Docker is not running — install Trivy (macOS: `brew install trivy`; "
+                 "Linux and Windows: a release binary from https://github.com/aquasecurity/trivy/releases), "
+                 "or start Docker and the scan runs Trivy's official container")
+# Plan 11 H12-T14 (G13): without a trivy binary, Trivy runs from its official image. Pinned to a
+# released tag (hub.docker.com aquasec/trivy tags: 0.76.0); the DB is cached in a named volume.
+TRIVY_IMAGE = "aquasec/trivy:0.76.0"
+TRIVY_CACHE = "ikanban-trivy-cache:/root/.cache/trivy"
 
 CATEGORY = {"iac": "A05 — Security Misconfiguration",
             "container": "A06 — Vulnerable and Outdated Components"}
@@ -123,14 +129,42 @@ def run(cmd, cwd=None, timeout=900):
         return False, "", f"timed out after {timeout}s"
 
 
-def trivy_json(args: list, target: str, out: Path) -> tuple[dict | None, str]:
+@functools.lru_cache(maxsize=1)
+def trivy_mode() -> str:
+    """'binary' (trivy on PATH), 'container' (Docker answers) or '' (neither)."""
+    if shutil.which("trivy"):
+        return "binary"
+    if shutil.which("docker") and run(["docker", "info"], timeout=30)[0]:
+        return "container"
+    return ""
+
+
+def trivy_label() -> str:
+    return f"trivy (container {TRIVY_IMAGE})" if trivy_mode() == "container" else "trivy"
+
+
+def trivy_cmd(work: Path, ro_mounts: tuple = (), socket: bool = False) -> list:
+    """The command that starts Trivy. As a container it sees only the work folder (read-write),
+    the paths in ro_mounts (read-only, at their own absolute paths) and a cache volume; the
+    Docker socket only when asked (a local image), since the socket gives full control of Docker."""
+    if trivy_mode() == "binary":
+        return ["trivy"]
+    cmd = ["docker", "run", "--rm", "-w", str(work), "-v", f"{work}:{work}", "-v", TRIVY_CACHE]
+    for p in ro_mounts:
+        cmd += ["-v", f"{p}:{p}:ro"]
+    if socket:
+        cmd += ["-v", "/var/run/docker.sock:/var/run/docker.sock"]
+    return [*cmd, TRIVY_IMAGE]
+
+
+def trivy_json(args: list, target: str, out: Path, ro_mounts: tuple = (), socket: bool = False) -> tuple[dict | None, str]:
     """Run `trivy SUBCOMMAND [ARGS] -- TARGET` with --format json into `out`; (report, "") or
     (None, why skipped). Plan 11 H12-T10 review: trivy runs from the scan's work folder with a
     scanner-owned --config and --ignorefile (both default to files in the working folder,
     trivy.dev CLI reference: `-c, --config ... (default "trivy.yaml")`, `--ignorefile ...
     (default ".trivyignore")`), so a repository's trivy.yaml or .trivyignore changes nothing.
     The target comes after `--`, so a name starting with '-' can never be read as a flag."""
-    if not shutil.which("trivy"):
+    if not trivy_mode():
         return None, TRIVY_INSTALL
     work = out.parent
     conf, ignore = work / "trivy-config.yaml", work / "trivyignore"
@@ -138,7 +172,7 @@ def trivy_json(args: list, target: str, out: Path) -> tuple[dict | None, str]:
         write_private(conf, "{}\n")
     if not ignore.exists():
         write_private(ignore, "")
-    ok, _o, err = run(["trivy", *args[:1], "--config", str(conf), "--ignorefile", str(ignore),
+    ok, _o, err = run([*trivy_cmd(work, ro_mounts, socket), *args[:1], "--config", str(conf), "--ignorefile", str(ignore),
                        "--format", "json", "--output", str(out), *args[1:], "--", target], cwd=work)
     if not ok or not out.exists():
         return None, f"trivy {args[0]} failed: {(err or '').strip()[-300:] or 'no output'}"
@@ -196,11 +230,11 @@ def scan_iac(root: Path, scope: str, inv: dict, work: Path) -> Section:
     # the absolute and the ** form are both passed. A miss only means a vendored folder is read too.
     skip = [x for d in SKIP_DIRS for x in ("--skip-dirs", f"{root.resolve()}/{d}", "--skip-dirs", f"**/{d}")]
     report, why = trivy_json(["fs", "--scanners", "misconfig", *skip], str(root.resolve()),
-                             work / f"trivy-iac-{slug(scope)}.json")
+                             work / f"trivy-iac-{slug(scope)}.json", ro_mounts=(root.resolve(),))
     if report is None:
         sec.skipped.append(why)
         return sec
-    sec.ran.append(f"trivy fs --scanners misconfig {root.name}")
+    sec.ran.append(f"{trivy_label()} fs --scanners misconfig {root.name}")
     sec.findings = parse_misconfigurations(report)
     for f in sec.findings:  # paths relative to the repository, like secscan
         f.location = f.location.removeprefix(str(root) + os.sep).removeprefix(str(root.resolve()) + os.sep)
@@ -213,11 +247,19 @@ def scan_image(image: str, work: Path) -> Section:
     if not valid_image_ref(image):
         sec.skipped.append(f"`{image[:80]}` is not a valid image name; not scanned")
         return sec
-    report, why = trivy_json(["image"], image, work / f"trivy-image-{slug(image)}.json")
+    out = work / f"trivy-image-{slug(image)}.json"
+    if trivy_mode() == "container":
+        # A registry image is pulled inside Trivy, with no Docker socket. Only an image that exists
+        # just on this machine (built locally, e.g. by compose) is read through the socket.
+        report, why = trivy_json(["image", "--image-src", "remote"], image, out)
+        if report is None and run(["docker", "image", "inspect", "--", image], timeout=30)[0]:
+            report, why = trivy_json(["image", "--image-src", "docker"], image, out, socket=True)
+    else:
+        report, why = trivy_json(["image"], image, out)
     if report is None:
         sec.skipped.append(why)
         return sec
-    sec.ran.append(f"trivy image {image}")
+    sec.ran.append(f"{trivy_label()} image {image}")
     sec.findings = parse_vulnerabilities(report, image)
     sec.complete = True
     return sec
@@ -577,6 +619,8 @@ def slug(text: str) -> str:
 # "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)
+# Every iKanban scanner reports into one named lane, not the server's "legacy" lane.
+PIPE_RUN = "security-scan"
 PIPE_CHUNK = 15 * 1024  # the server takes 16 KB per chunk
 LAST_RUN = {"report": "", "detail": "", "skipped": False}
 INVENTORY: list = []  # (scope, table rows) per --path, for the report
@@ -623,6 +667,18 @@ def log_chunks(text: str) -> list:
         chunks.append(cur)
     return chunks
 
+# The running Pipeline (set by run_main with --task). Owner: Pipelines showed nothing while a
+# scan ran, so each step also sends one line as it starts and ends; the full report follows at the end.
+# Progress lines are fixed status text: never raw tool output or an error body (it can carry
+# secrets or text an attacker wrote). Those stay on local stderr and in the masked report.
+PIPE = None
+
+
+def progress(text: str) -> None:
+    if PIPE:
+        PIPE.log(text)
+
+
 
 class Pipeline:
     def __init__(self, stage, task, team, base_url, token):
@@ -661,7 +717,12 @@ class Pipeline:
 
     def start(self):
         self._post("pipeline-events", {"task": self.task, "stage": self.stage, "status": "running",
-                                       "source": "laptop", "actor": f"ikanban-{self.stage}"})
+                                       "run": PIPE_RUN, "source": "laptop", "actor": f"ikanban-{self.stage}"})
+
+    def log(self, line):
+        """One progress line, sent as it happens (masked like the report). A failure only turns Pipelines off."""
+        self._post("pipeline-logs", {"task": self.task, "run": PIPE_RUN, "stage": self.stage,
+                                     "text": mask_report(line.rstrip("\n"))[:PIPE_CHUNK - 1] + "\n"})
 
     def finish(self, code):
         status = "failed" if code else ("skipped" if LAST_RUN["skipped"] else "passed")
@@ -669,10 +730,10 @@ class Pipeline:
         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}",
+                                       "run": PIPE_RUN, "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})
+            self._post("pipeline-logs", {"task": self.task, "run": PIPE_RUN, "stage": self.stage, "text": chunk})
 
 
 def run_main(stage, main_fn, argv=None):
@@ -689,6 +750,8 @@ def run_main(stage, main_fn, argv=None):
     known, _ = pre.parse_known_args(raw)
     pl = Pipeline(stage, known.task, known.task_team or known.team, known.base_url, known.token)
     pl.start()
+    global PIPE
+    PIPE = pl if pl.on else None
     try:
         code = main_fn(argv)
     except SystemExit as e:
@@ -738,6 +801,7 @@ def main(argv=None):
         print("error: nothing to scan: drop --no-iac or add --image", file=sys.stderr)
         return 2
     work = scan_work_dir("infrascan", root, args.work_dir)
+    progress(f"infrascan {INFRASCAN_VERSION} · {trivy_label() if trivy_mode() else 'no Trivy and no Docker'}")
     sections, images, unresolved = [], list(args.image), []
     INVENTORY.clear()
     for r in roots:
@@ -748,12 +812,20 @@ def main(argv=None):
             images += [i for i in found if i not in images]
             unresolved += skipped_vars
         if not args.no_iac:
+            progress(f"trivy fs (IaC) in {r.name}/ …")
             sec = scan_iac(r, scan_scope(r), inv, work)
+            progress(f"trivy fs (IaC) in {r.name}/ … " + (f"done, {len(sec.findings)} findings" if sec.complete
+                                                            else "SKIPPED (the reason is in the report)"))
             sections.append(sec)
             INVENTORY.append((sec.scope, inventory_rows(inv, sec.complete, "; ".join(sec.skipped), rejected)))
         else:
             INVENTORY.append((scan_scope(r), inventory_rows(inv, False, "--no-iac", rejected)))
-    sections += [scan_image(i, work) for i in images]
+    for i in images:
+        progress(f"trivy image {i} …")
+        sec = scan_image(i, work)
+        progress(f"trivy image {i} … " + (f"done, {len(sec.findings)} critical/high" if sec.complete
+                                          else "SKIPPED (the reason is in the report)"))
+        sections.append(sec)
     if unresolved:
         sections.append(Section("Compose images not scanned", "container", "compose",
                                 skipped=[f"`{i}` uses a ${{VARIABLE}}; pass the real name with --image" for i in unresolved]))

package/scanners/ikanban-secscan.py

@@ -53,6 +53,7 @@ import shutil
 import stat
 import subprocess
 import sys
+import tempfile
 import urllib.error
 import urllib.parse
 import urllib.request
@@ -64,7 +65,7 @@ from pathlib import Path
 # that npm no longer hosts the package. Starting at 1.0.0 rather than continuing
 # the npm package's 0.1.x line: that counter belonged to the wrapper, not to
 # this file, and reusing it would suggest a continuity that does not exist.
-SECSCAN_VERSION = "1.5.0"
+SECSCAN_VERSION = "1.6.0"
 
 SEVERITIES = ["critical", "high", "medium", "low", "info"]
 SEVERITY_RANK = {s: i for i, s in enumerate(SEVERITIES)}
@@ -222,7 +223,7 @@ def iter_files(root: Path):
 
 
 # ── 1. Dependency audits ─────────────────────────────────────────────────────
-def audit_dependencies(root: Path) -> Section:
+def audit_dependencies(root: Path, work: Path | None = None) -> Section:
     sec = Section("Dependency vulnerabilities")
 
     if (root / "Cargo.lock").exists():
@@ -245,9 +246,18 @@ def audit_dependencies(root: Path) -> Section:
             sec.ran.append("pnpm audit")
             sec.findings += _parse_npm_audit(out)
             _note_unanswered(sec, "pnpm audit", out, err)
+        elif shutil.which("npm") and not _has_npm_lock(root) and _non_registry(root):
+            # Without a lockfile npm resolves the tree itself, and a git, file, link or URL
+            # dependency makes it fetch or read from outside the registry. Never do that here.
+            sec.skipped.append("npm audit: its package.json names non-registry dependencies; "
+                               "commit a package-lock.json to audit it")
         elif shutil.which("npm"):
             ok, out, err = run(["npm", "audit", "--json"], cwd=root)
-            sec.ran.append("npm audit")
+            tool = "npm audit"
+            if not audit_answered(out) and work is not None and not _has_npm_lock(root):
+                out, err = npm_audit_scratch(root, work)
+                tool = "npm audit (no lockfile in the repository: one resolved with --legacy-peer-deps in the scan folder)"
+            sec.ran.append(tool)
             sec.findings += _parse_npm_audit(out)
             _note_unanswered(sec, "npm audit", out, err)
         else:
@@ -269,6 +279,69 @@ def audit_dependencies(root: Path) -> Section:
     return sec
 
 
+# A registry semver range or a dist-tag: no ":" (git+, github:, file:, link:, workspace:, npm:,
+# URLs), no "/" (user/repo, paths), no tarball name. An override may also be "$name": the spec of
+# a direct dependency of that name, which is checked itself.
+_REGISTRY_SPEC = re.compile(r"^[A-Za-z0-9.\-+^~<>=| *]*$")
+_TARBALL = re.compile(r"\.(tgz|tar|tar\.gz)$", re.IGNORECASE)
+
+
+def non_registry_specs(pkg: dict) -> list:
+    """Every dependency spec in package.json that is not a registry range or dist-tag."""
+    bad = []
+    direct = {n for k in ("dependencies", "devDependencies", "optionalDependencies", "peerDependencies")
+              if isinstance(pkg.get(k), dict) for n in pkg[k]}
+
+    def walk(name, spec, override=False):
+        if isinstance(spec, dict):
+            for k, v in spec.items():
+                walk(k, v, override)
+        elif override and isinstance(spec, str) and spec.startswith("$") and spec[1:] in direct:
+            return
+        elif not isinstance(spec, str) or not _REGISTRY_SPEC.match(spec) or _TARBALL.search(spec):
+            bad.append(f"{name}: {spec!r}"[:120])
+
+    if pkg.get("workspaces"):
+        bad.append("workspaces")  # npm resolves local folders outside the checked lists
+    for key in ("dependencies", "devDependencies", "optionalDependencies", "peerDependencies", "overrides"):
+        section = pkg.get(key) or {}
+        if not isinstance(section, dict):
+            bad.append(key)
+            continue
+        for name, spec in section.items():
+            walk(name, spec, key == "overrides")
+    return bad
+
+
+def _has_npm_lock(root: Path) -> bool:
+    return any((root / f).exists() for f in ("package-lock.json", "npm-shrinkwrap.json"))
+
+
+def _non_registry(root: Path) -> bool:
+    try:
+        pkg = json.loads((root / "package.json").read_text(encoding="utf-8"))
+    except (OSError, ValueError):
+        return True  # unreadable: npm would fail too; never guess
+    return not isinstance(pkg, dict) or bool(non_registry_specs(pkg))
+
+
+def npm_audit_scratch(root: Path, work: Path):
+    """Plan 11 H12-T14 (G14): npm audit needs a lockfile. Without one npm builds the tree
+    itself, and a peer conflict stops it (ERESOLVE: Juice Shop's frontend). So write a
+    lockfile for a copy of package.json alone in the scan folder, then audit that copy.
+    No .npmrc (it may say package-lock=false), no node_modules, no install scripts."""
+    scratch = Path(tempfile.mkdtemp(prefix="npm-lock-", dir=work))
+    write_private(scratch / "package.json", (root / "package.json").read_text(encoding="utf-8"))
+    ok, out, err = run(["npm", "install", "--package-lock-only", "--ignore-scripts",
+                        "--legacy-peer-deps", "--no-audit"], cwd=scratch, timeout=600)
+    if not ok:
+        why = (err or out or "no output").strip().splitlines()
+        return "", (f"npm cannot resolve the dependency tree, even with --legacy-peer-deps "
+                    f"({why[0][:120] if why else ''}). Fix: commit a package-lock.json for {root.name}/")
+    ok, out, err = run(["npm", "audit", "--json"], cwd=scratch)
+    return out, err
+
+
 def audit_answered(out: str) -> bool:
     """Plan 11 H3: did the auditor return a result? Not JSON, or npm's {"error": …}
     (no lockfile, no network), is no answer, so it must not read as "nothing found"."""
@@ -901,6 +974,8 @@ def slug(text: str) -> str:
 # "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)
+# Every iKanban scanner reports into one named lane, not the server's "legacy" lane.
+PIPE_RUN = "security-scan"
 PIPE_CHUNK = 15 * 1024  # the server takes 16 KB per chunk
 LAST_RUN = {"report": "", "detail": "", "skipped": False}
 
@@ -946,6 +1021,18 @@ def log_chunks(text: str) -> list:
         chunks.append(cur)
     return chunks
 
+# The running Pipeline (set by run_main with --task). Owner: Pipelines showed nothing while a
+# scan ran, so each step also sends one line as it starts and ends; the full report follows at the end.
+# Progress lines are fixed status text: never raw tool output or an error body (it can carry
+# secrets or text an attacker wrote). Those stay on local stderr and in the masked report.
+PIPE = None
+
+
+def progress(text: str) -> None:
+    if PIPE:
+        PIPE.log(text)
+
+
 
 class Pipeline:
     def __init__(self, stage, task, team, base_url, token):
@@ -984,7 +1071,12 @@ class Pipeline:
 
     def start(self):
         self._post("pipeline-events", {"task": self.task, "stage": self.stage, "status": "running",
-                                       "source": "laptop", "actor": f"ikanban-{self.stage}"})
+                                       "run": PIPE_RUN, "source": "laptop", "actor": f"ikanban-{self.stage}"})
+
+    def log(self, line):
+        """One progress line, sent as it happens (masked like the report). A failure only turns Pipelines off."""
+        self._post("pipeline-logs", {"task": self.task, "run": PIPE_RUN, "stage": self.stage,
+                                     "text": mask_report(line.rstrip("\n"))[:PIPE_CHUNK - 1] + "\n"})
 
     def finish(self, code):
         status = "failed" if code else ("skipped" if LAST_RUN["skipped"] else "passed")
@@ -992,10 +1084,10 @@ class Pipeline:
         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}",
+                                       "run": PIPE_RUN, "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})
+            self._post("pipeline-logs", {"task": self.task, "run": PIPE_RUN, "stage": self.stage, "text": chunk})
 
 
 def run_main(stage, main_fn, argv=None):
@@ -1012,6 +1104,8 @@ def run_main(stage, main_fn, argv=None):
     known, _ = pre.parse_known_args(raw)
     pl = Pipeline(stage, known.task, known.task_team or known.team, known.base_url, known.token)
     pl.start()
+    global PIPE
+    PIPE = pl if pl.on else None
     try:
         code = main_fn(argv)
     except SystemExit as e:
@@ -1078,17 +1172,28 @@ def main(argv=None):
     except ValueError as e:
         print(f"error: {e}", file=sys.stderr)
         return 2
+    work = scan_work_dir("secscan", root, args.work_dir)
+    progress(f"secscan {SECSCAN_VERSION} · {root.name}")
+
+    def step(label, fn, *a):
+        progress(f"{label} …")
+        sec = fn(*a)
+        note = f"{len(sec.findings)} findings" if sec.ran else "SKIPPED"
+        progress(f"{label} … {note}" + (f" ({'; '.join(sec.ran)})" if sec.ran else "")
+                 + (f"; {len(sec.skipped)} skipped" if sec.skipped else ""))
+        return sec
+
     app_sections = []
     for path, name in app_maps:
-        sec = audit_dependencies(path)
-        sec.name = f"Dependency vulnerabilities — {path.relative_to(root) or '.'} ({name})"
+        rel = path.relative_to(root) or "."
+        sec = step(f"dependency audit in {rel}/", audit_dependencies, path, work)
+        sec.name = f"Dependency vulnerabilities — {rel} ({name})"
         app_sections.append((name, sec))
 
-    sections = [audit_dependencies(root), *(s for _, s in app_sections),
-                scan_secrets(root), scan_permissions(root)]
+    sections = [step("dependency audit in ./", audit_dependencies, root, work), *(s for _, s in app_sections),
+                step("committed secrets", scan_secrets, root), step("risky file permissions", scan_permissions, root)]
     md, counts, total = build_report(root, sections)
     LAST_RUN.update(report=md, detail=summary_detail(counts, total, []), skipped=False)
-    work = scan_work_dir("secscan", root, args.work_dir)
     write_private(work / "report.md", md)
 
     if args.out: