flowforge-map 0.4.0__tar.gz → 0.4.2__tar.gz

{flowforge_map-0.4.0 → flowforge_map-0.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: flowforge-map
-Version: 0.4.0
+Version: 0.4.2
 Summary: Map what your app depends on (LLMs, MCP servers, APIs), check their health and security, and see what could run faster. Local and free; the scan needs no AI.
 Project-URL: Homepage, https://github.com/Vishwa-Thangapandiyan/flowforge-agent-orchestrator
 Project-URL: Issues, https://github.com/Vishwa-Thangapandiyan/flowforge-agent-orchestrator/issues
@@ -37,24 +37,30 @@ Description-Content-Type: text/markdown
 
 # FlowForge
 
-**An LLMOps tool for apps that already use AI: a map of how your app's LLM, MCP and API calls fit together, and a scheduler that runs them.**
+**See everything your AI app depends on: whether it's reachable, whether it's safe, and what's slowing it down.**
 
-You connect the apps your project uses (LLMs, MCP servers, HTTP APIs, local commands). The **Planner** reads your repo and runs the app in test mode, then draws the flow on the home page: the calls, the decisions, what runs together, the retries and fallbacks, and a gate in front of anything that moves money or sends a message. Only apps your code actually calls go on the map, and every block cites its evidence (a `file:line` or a traced call). You read the map, edit it if you want (your edits never touch your code), and re-check it when the code changes.
+```bash
+npx flowforge-map --example      # a sample app's map in your browser: no keys, nothing sent
+```
 
-Underneath, FlowForge runs workflows as a DAG: it orders the steps, runs independent ones together under rate limits, caches repeat calls, and (on the roadmap) holds the secrets and pauses risky steps for a human to approve.
+![The dependency map: every LLM, MCP server and API the app calls, with live health](docs/images/map.png)
 
-What makes it different: **it knows which chain of steps is the bottleneck and schedules around it.**
+| | |
+|---|---|
+| 🗺 **Map** | Every LLM, MCP server, HTTP API and local program your code calls, each with the `file:line` it came from |
+| 💚 **Check now** | Green, amber or red for each one, with its latency. When something is down, it tells you why |
+| ⚡ **Faster** | Reads the order your code makes its calls and shows which ones could run together, with the time you'd save |
+| 🛡 **Issues** | Keys written in code, plain `http://`, MCP servers that aren't pinned. Fix one on a new branch, or send it to your agent |
+| 🔑 **Keys** | Paste a key once. **Add to code** writes it to a git-ignored file your app reads; FlowForge only ever hands your agent a mask |
+| 🤖 **Your agent** | One MCP entry gives Claude Code, Codex or Antigravity the map, the advice and the issues |
 
-- orders steps with **topological sort** (Kahn's), and reports the exact loop if there is a cycle
-- finds the bottleneck chain with a **longest-path DP** (critical path), predicted before the run and measured after it
-- runs independent steps concurrently under limited resources (`k` slots + per-provider rate limits) using **critical-path list scheduling** (HLFET), which is within `(2 − 1/k)` of optimal (Graham's bound)
-- makes duplicate calls only once through **memoization** (single-flight in-run cache + a safe persistent cache)
+![Flow: 16.5 s as written, 11.6 s if four calls start together](docs/images/flow.png)
 
-**Free by default.** The default install, the tests and CI need no paid service: LLM steps use NVIDIA NIM's free tier, and local models (Ollama) are planned. Paid providers will work if you bring your own key, but are never needed.
+**Free and local.** MIT, no account, no paid service. FlowForge keeps its data on your machine, and the scan is plain code that sends nothing to any LLM.
 
-**Local first.** One process, SQLite, files on disk. No cloud account, no Docker, no Redis.
+**Under the hood:** a DAG scheduler runs the checks concurrently under rate limits. It uses a topological sort, a critical-path DP and HLFET list scheduling (within `(2 − 1/k)` of optimal), and it caches repeat calls. See [Scheduling policies and benchmarks](#scheduling-policies-and-benchmarks).
 
-> FlowForge started as a Design and Analysis of Algorithms course project. That version is frozen on the [`DAA`](../../tree/DAA) branch. `main` is the product.
+> FlowForge started as a Design and Analysis of Algorithms course project. That version is commit [`233a681`](../../tree/233a681c3e17fa4081c883193f8456a53a4c049c) in `main`'s history.
 
 ## Quick start
 
@@ -65,7 +71,7 @@ npx flowforge-map --example      # try it: a sample app's maps in your browser,
 npx flowforge-map --repo .       # map the folder you're in
 ```
 
-That's all: no Python, no virtual env. The first run downloads FlowForge's ready-made program for your computer (about 60 MB, checked against the release's checksums) into `~/.flowforge/bin`; after that it starts at once, even offline. Works on Windows, macOS (Apple and Intel) and Linux x64 with Node 18+. Your data lives in `~/.flowforge`.
+That's all: no Python, no virtual env. The first run downloads FlowForge's ready-made program for your computer (about 60 MB, checked against the release's checksums) into `~/.flowforge/bin`; after that it starts at once, even offline. Works on Windows, macOS (Apple chips) and Linux x64 with Node 18+. Your data lives in `~/.flowforge`.
 
 | You have | Run | |
 |---|---|---|
@@ -74,7 +80,7 @@ That's all: no Python, no virtual env. The first run downloads FlowForge's ready
 | Python people | `uvx flowforge-map` or `pipx install flowforge-map` | Python 3.12+; no virtual env to manage |
 | No terminal | the desktop app (Releases) | download and open; **Settings → Terminal** adds the `flowforge` command too (Linux .rpm/.deb have it already) |
 
-Every way gives the same `flowforge` command: `npx flowforge-map status`, `npx flowforge-map key add STRIPE_KEY`, and so on. Linux ARM and Windows ARM have no ready-made build yet, so `npx` uses `uvx` there.
+Every way gives the same `flowforge` command: `npx flowforge-map status`, `npx flowforge-map key add STRIPE_KEY`, and so on. Intel Macs, Linux ARM and Windows ARM have no ready-made build yet, so `npx` uses `uvx` there.
 
 The first time, a short welcome walks you through three steps, each one skippable: your app's folder (or the example), pairing your coding agent once, and a lock for your keys. **⚙ Settings** at the bottom of the rail keeps what applies to every project: your agent, the theme and map style, the Vault's lock, and your data (each project's size, the MCP servers it may start, its check history, and the version, with **Check for updates**, which asks pypi.org only when you press it).
 
@@ -99,9 +105,11 @@ The same dashboard in its own window, with Python inside: nothing else to instal
 | Your computer | Download |
 |---|---|
 | Windows | `FlowForge_x.y.z_x64-setup.exe` or `.msi` |
-| Mac (Apple Silicon or Intel) | `FlowForge_x.y.z_aarch64.dmg` or `_x64.dmg` |
+| Mac (Apple chip) | `FlowForge_x.y.z_aarch64.dmg` |
 | Linux | `.AppImage`, `.deb` or `.rpm` |
 
+Intel Macs have no desktop build yet: use `npx flowforge-map` (it runs FlowForge through `uv` there) or `uvx flowforge-map`.
+
 The builds aren't signed yet (signing costs money every year), so the first launch asks once:
 - **Mac:** right-click FlowForge in Applications → **Open** → **Open**.
 - **Windows:** on "Windows protected your PC", click **More info** → **Run anyway**.
@@ -147,7 +155,6 @@ Switch the map to **Flow**. FlowForge reads your Python (by its syntax tree), Da
 - **Faster** compares "as written" (the slowest action, one call after another) with "could be", and lists the calls that don't need each other's results. **Show the change** writes out the `asyncio.gather`, Dart's `(a, b).wait` or `Promise.all` (now → could be, ready to copy) when it's safe; **Copy prompt for your coding agent** hands the rest to Claude Code, Codex or any agent. FlowForge never edits your code.
 - **Watch it run** plays the could-be schedule; pointing at a block lights up its path. Five map styles: Studio, Boxed, Blueprint, Metro, Soft.
 
-
 ### Many projects
 
 The home page lists every app you've mapped, with its dependencies, what needs fixing and missing keys. **+ New project** takes your app's folder, scans it and shows its map. The project tile at the top of the rail switches between the projects you have open, and each one comes back where you left it. **×** closes a project from that list without deleting it. Each project keeps its own map, checks, issues and keys; `flowforge --repo PATH` opens (or adds) that folder's project.
@@ -160,10 +167,21 @@ FlowForge is also an **MCP server**, so Claude Code, Codex or Antigravity can as
 claude mcp add flowforge -- uvx flowforge-map mcp
 ```
 
-Pair your agent once and it sees every project: `flowforge mcp` with no folder answers about the project your agent is working in, or any other by name (`list_projects` shows them all). Your agent gets eleven tools: `list_projects`, `get_map`, `get_flow`, `get_advice`, `check_health`, `get_security_findings`, `get_keys`, `get_fix_requests`, `request_key`, `wait_for_keys` and `what_changed`. All read only, except `request_key`, which only asks you for a key by name. Every answer is masked (key values never appear), the agent can't make FlowForge change your code, and a check starts an MCP server only after you said yes to it on the Checks page. FlowForge needs no AI of its own for any of this.
+Pair your agent once and it sees every project: `flowforge mcp` with no folder answers about the project your agent is working in, or any other by name (`list_projects` shows them all). Your agent gets fourteen tools:
+
+| Kind | Tools |
+|---|---|
+| Read only | `list_projects`, `get_map`, `get_flow`, `get_advice`, `get_security_findings`, `get_keys`, `wait_for_keys`, `app_output`, `get_fix_requests`, `what_changed` |
+| Checks | `check_health`: makes requests, and starts an MCP server only after you said yes to it |
+| Asks you | `request_key`: asks for a key by name |
+| Runs your app | `run_app`, `stop_app`: start and stop your app with its keys filled in, only after you allow that exact command once (D43) |
+
+Every answer is masked (key values never appear), and the agent can't make FlowForge change your code. FlowForge needs no AI of its own for any of this.
 
 ### Fix what's unsafe, with one click
 
+![Issues: a key in the code, an unpinned MCP server, plain http](docs/images/issues.png)
+
 The **Issues** page lists what the scan found unsafe, and every issue has one button:
 
 | Issue | Button | What happens |
@@ -175,6 +193,8 @@ Fix needs a git repo and the file committed. FlowForge works out the change itse
 
 ### Keys your coding agent never sees
 
+![Keys: paste once, Add to code, the agent sees a mask](docs/images/keys.png)
+
 **Add to code.** The **Keys** page lists each place your code needs a key, with its `file:line`. Paste the key and press **Add to code**:
 
 ```

{flowforge_map-0.4.0 → flowforge_map-0.4.2}/README.md

@@ -1,23 +1,29 @@
 # FlowForge
 
-**An LLMOps tool for apps that already use AI: a map of how your app's LLM, MCP and API calls fit together, and a scheduler that runs them.**
+**See everything your AI app depends on: whether it's reachable, whether it's safe, and what's slowing it down.**
 
-You connect the apps your project uses (LLMs, MCP servers, HTTP APIs, local commands). The **Planner** reads your repo and runs the app in test mode, then draws the flow on the home page: the calls, the decisions, what runs together, the retries and fallbacks, and a gate in front of anything that moves money or sends a message. Only apps your code actually calls go on the map, and every block cites its evidence (a `file:line` or a traced call). You read the map, edit it if you want (your edits never touch your code), and re-check it when the code changes.
+```bash
+npx flowforge-map --example      # a sample app's map in your browser: no keys, nothing sent
+```
 
-Underneath, FlowForge runs workflows as a DAG: it orders the steps, runs independent ones together under rate limits, caches repeat calls, and (on the roadmap) holds the secrets and pauses risky steps for a human to approve.
+![The dependency map: every LLM, MCP server and API the app calls, with live health](docs/images/map.png)
 
-What makes it different: **it knows which chain of steps is the bottleneck and schedules around it.**
+| | |
+|---|---|
+| 🗺 **Map** | Every LLM, MCP server, HTTP API and local program your code calls, each with the `file:line` it came from |
+| 💚 **Check now** | Green, amber or red for each one, with its latency. When something is down, it tells you why |
+| ⚡ **Faster** | Reads the order your code makes its calls and shows which ones could run together, with the time you'd save |
+| 🛡 **Issues** | Keys written in code, plain `http://`, MCP servers that aren't pinned. Fix one on a new branch, or send it to your agent |
+| 🔑 **Keys** | Paste a key once. **Add to code** writes it to a git-ignored file your app reads; FlowForge only ever hands your agent a mask |
+| 🤖 **Your agent** | One MCP entry gives Claude Code, Codex or Antigravity the map, the advice and the issues |
 
-- orders steps with **topological sort** (Kahn's), and reports the exact loop if there is a cycle
-- finds the bottleneck chain with a **longest-path DP** (critical path), predicted before the run and measured after it
-- runs independent steps concurrently under limited resources (`k` slots + per-provider rate limits) using **critical-path list scheduling** (HLFET), which is within `(2 − 1/k)` of optimal (Graham's bound)
-- makes duplicate calls only once through **memoization** (single-flight in-run cache + a safe persistent cache)
+![Flow: 16.5 s as written, 11.6 s if four calls start together](docs/images/flow.png)
 
-**Free by default.** The default install, the tests and CI need no paid service: LLM steps use NVIDIA NIM's free tier, and local models (Ollama) are planned. Paid providers will work if you bring your own key, but are never needed.
+**Free and local.** MIT, no account, no paid service. FlowForge keeps its data on your machine, and the scan is plain code that sends nothing to any LLM.
 
-**Local first.** One process, SQLite, files on disk. No cloud account, no Docker, no Redis.
+**Under the hood:** a DAG scheduler runs the checks concurrently under rate limits. It uses a topological sort, a critical-path DP and HLFET list scheduling (within `(2 − 1/k)` of optimal), and it caches repeat calls. See [Scheduling policies and benchmarks](#scheduling-policies-and-benchmarks).
 
-> FlowForge started as a Design and Analysis of Algorithms course project. That version is frozen on the [`DAA`](../../tree/DAA) branch. `main` is the product.
+> FlowForge started as a Design and Analysis of Algorithms course project. That version is commit [`233a681`](../../tree/233a681c3e17fa4081c883193f8456a53a4c049c) in `main`'s history.
 
 ## Quick start
 
@@ -28,7 +34,7 @@ npx flowforge-map --example      # try it: a sample app's maps in your browser,
 npx flowforge-map --repo .       # map the folder you're in
 ```
 
-That's all: no Python, no virtual env. The first run downloads FlowForge's ready-made program for your computer (about 60 MB, checked against the release's checksums) into `~/.flowforge/bin`; after that it starts at once, even offline. Works on Windows, macOS (Apple and Intel) and Linux x64 with Node 18+. Your data lives in `~/.flowforge`.
+That's all: no Python, no virtual env. The first run downloads FlowForge's ready-made program for your computer (about 60 MB, checked against the release's checksums) into `~/.flowforge/bin`; after that it starts at once, even offline. Works on Windows, macOS (Apple chips) and Linux x64 with Node 18+. Your data lives in `~/.flowforge`.
 
 | You have | Run | |
 |---|---|---|
@@ -37,7 +43,7 @@ That's all: no Python, no virtual env. The first run downloads FlowForge's ready
 | Python people | `uvx flowforge-map` or `pipx install flowforge-map` | Python 3.12+; no virtual env to manage |
 | No terminal | the desktop app (Releases) | download and open; **Settings → Terminal** adds the `flowforge` command too (Linux .rpm/.deb have it already) |
 
-Every way gives the same `flowforge` command: `npx flowforge-map status`, `npx flowforge-map key add STRIPE_KEY`, and so on. Linux ARM and Windows ARM have no ready-made build yet, so `npx` uses `uvx` there.
+Every way gives the same `flowforge` command: `npx flowforge-map status`, `npx flowforge-map key add STRIPE_KEY`, and so on. Intel Macs, Linux ARM and Windows ARM have no ready-made build yet, so `npx` uses `uvx` there.
 
 The first time, a short welcome walks you through three steps, each one skippable: your app's folder (or the example), pairing your coding agent once, and a lock for your keys. **⚙ Settings** at the bottom of the rail keeps what applies to every project: your agent, the theme and map style, the Vault's lock, and your data (each project's size, the MCP servers it may start, its check history, and the version, with **Check for updates**, which asks pypi.org only when you press it).
 
@@ -62,9 +68,11 @@ The same dashboard in its own window, with Python inside: nothing else to instal
 | Your computer | Download |
 |---|---|
 | Windows | `FlowForge_x.y.z_x64-setup.exe` or `.msi` |
-| Mac (Apple Silicon or Intel) | `FlowForge_x.y.z_aarch64.dmg` or `_x64.dmg` |
+| Mac (Apple chip) | `FlowForge_x.y.z_aarch64.dmg` |
 | Linux | `.AppImage`, `.deb` or `.rpm` |
 
+Intel Macs have no desktop build yet: use `npx flowforge-map` (it runs FlowForge through `uv` there) or `uvx flowforge-map`.
+
 The builds aren't signed yet (signing costs money every year), so the first launch asks once:
 - **Mac:** right-click FlowForge in Applications → **Open** → **Open**.
 - **Windows:** on "Windows protected your PC", click **More info** → **Run anyway**.
@@ -110,7 +118,6 @@ Switch the map to **Flow**. FlowForge reads your Python (by its syntax tree), Da
 - **Faster** compares "as written" (the slowest action, one call after another) with "could be", and lists the calls that don't need each other's results. **Show the change** writes out the `asyncio.gather`, Dart's `(a, b).wait` or `Promise.all` (now → could be, ready to copy) when it's safe; **Copy prompt for your coding agent** hands the rest to Claude Code, Codex or any agent. FlowForge never edits your code.
 - **Watch it run** plays the could-be schedule; pointing at a block lights up its path. Five map styles: Studio, Boxed, Blueprint, Metro, Soft.
 
-
 ### Many projects
 
 The home page lists every app you've mapped, with its dependencies, what needs fixing and missing keys. **+ New project** takes your app's folder, scans it and shows its map. The project tile at the top of the rail switches between the projects you have open, and each one comes back where you left it. **×** closes a project from that list without deleting it. Each project keeps its own map, checks, issues and keys; `flowforge --repo PATH` opens (or adds) that folder's project.
@@ -123,10 +130,21 @@ FlowForge is also an **MCP server**, so Claude Code, Codex or Antigravity can as
 claude mcp add flowforge -- uvx flowforge-map mcp
 ```
 
-Pair your agent once and it sees every project: `flowforge mcp` with no folder answers about the project your agent is working in, or any other by name (`list_projects` shows them all). Your agent gets eleven tools: `list_projects`, `get_map`, `get_flow`, `get_advice`, `check_health`, `get_security_findings`, `get_keys`, `get_fix_requests`, `request_key`, `wait_for_keys` and `what_changed`. All read only, except `request_key`, which only asks you for a key by name. Every answer is masked (key values never appear), the agent can't make FlowForge change your code, and a check starts an MCP server only after you said yes to it on the Checks page. FlowForge needs no AI of its own for any of this.
+Pair your agent once and it sees every project: `flowforge mcp` with no folder answers about the project your agent is working in, or any other by name (`list_projects` shows them all). Your agent gets fourteen tools:
+
+| Kind | Tools |
+|---|---|
+| Read only | `list_projects`, `get_map`, `get_flow`, `get_advice`, `get_security_findings`, `get_keys`, `wait_for_keys`, `app_output`, `get_fix_requests`, `what_changed` |
+| Checks | `check_health`: makes requests, and starts an MCP server only after you said yes to it |
+| Asks you | `request_key`: asks for a key by name |
+| Runs your app | `run_app`, `stop_app`: start and stop your app with its keys filled in, only after you allow that exact command once (D43) |
+
+Every answer is masked (key values never appear), and the agent can't make FlowForge change your code. FlowForge needs no AI of its own for any of this.
 
 ### Fix what's unsafe, with one click
 
+![Issues: a key in the code, an unpinned MCP server, plain http](docs/images/issues.png)
+
 The **Issues** page lists what the scan found unsafe, and every issue has one button:
 
 | Issue | Button | What happens |
@@ -138,6 +156,8 @@ Fix needs a git repo and the file committed. FlowForge works out the change itse
 
 ### Keys your coding agent never sees
 
+![Keys: paste once, Add to code, the agent sees a mask](docs/images/keys.png)
+
 **Add to code.** The **Keys** page lists each place your code needs a key, with its `file:line`. Paste the key and press **Add to code**:
 
 ```

{flowforge_map-0.4.0 → flowforge_map-0.4.2}/backend/flowforge/agent/server.py

@@ -157,7 +157,8 @@ def headline(tool: str, data: dict[str, Any]) -> str | None:
         return _plural(len(data["dependencies"]), "dependency", "dependencies")
     if tool == "check_health":
         counts = data["summary"]
-        parts = [f"{counts[s]} {s}" for s in ("up", "warn", "down", "skipped") if counts.get(s)]
+        words = {"up": "reachable", "warn": "need a look", "down": "down", "skipped": "not checked"}   # D52
+        parts = [f"{counts[s]} {w}" for s, w in words.items() if counts.get(s)]
         return " · ".join(parts) or "Nothing to check"
     if tool in ("get_flow", "get_advice") and not data["available"]:
         return "No flow: no Python calls found"

{flowforge_map-0.4.0 → flowforge_map-0.4.2}/backend/flowforge/api/keys.py

@@ -185,6 +185,18 @@ def _writable(s: AppState) -> Path:
     return repo
 
 
+@router.get("/keys/asked")
+def keys_asked() -> dict[str, list[str]]:
+    """The names your agent asked for and you haven't saved yet (D38): cheap enough for the rail's badge to poll,
+    since it never reads the code. Names only."""
+    s = app_state()
+    repo = repo_path(s)
+    if repo is None or not repo.is_dir():
+        return {"names": []}
+    saved = set(KeyStore(repo).names())
+    return {"names": [r["name"] for r in key_requests(s.storage, repo) if r["name"] not in saved]}
+
+
 @router.get("/keys")
 def keys() -> dict[str, Any]:
     s = app_state()

{flowforge_map-0.4.0 → flowforge_map-0.4.2}/backend/flowforge/checks/probes.py

@@ -205,6 +205,13 @@ def _warnings(url: str, answer: _Answer) -> list[str]:
     return out
 
 
+def _reachable(code: int) -> str:
+    """What one answer proves (D52): the server is there. Not that a key works, nor that your call does."""
+    if code in (401, 403):
+        return f"Reachable, needs a key ({code})"
+    return "Reachable" if code < 300 else f"Reachable, answered {code}"   # a redirect isn't followed: say so
+
+
 async def api(t: CheckTarget, http: httpx.AsyncClient) -> CheckResult:
     if not t.target:
         return _result(t, "skipped", "Not checked: no address in the code")
@@ -215,7 +222,11 @@ async def api(t: CheckTarget, http: httpx.AsyncClient) -> CheckResult:
     detail = {"http_status": answer.code}
     if answer.code >= 500:
         return _result(t, "down", f"Answered {answer.code}", latency_ms=answer.ms, detail=detail)
-    up = f"Up, needs a key ({answer.code})" if answer.code in (401, 403) else "Up"
+    if answer.code == 429:
+        return _result(t, "warn", "Reachable, but rate-limiting this computer (429)", latency_ms=answer.ms,
+                       detail=detail, fix="Check again later. If it keeps happening, your app may be hitting the "
+                                          "same limit.")
+    up = _reachable(answer.code)
     if warnings := _warnings(url, answer):
         return _result(t, "warn", f"{up}, but {'; '.join(warnings)}", latency_ms=answer.ms, detail=detail)
     return _result(t, "up", up, latency_ms=answer.ms, detail=detail)
@@ -252,8 +263,12 @@ async def llm(t: CheckTarget, http: httpx.AsyncClient) -> CheckResult:
     detail = {"http_status": answer.code}
     if answer.code >= 500:
         return _result(t, "down", f"Answered {answer.code}", latency_ms=answer.ms, detail=detail)
+    if answer.code == 429:
+        return _result(t, "warn", "Reachable, but rate-limiting this computer (429)", latency_ms=answer.ms,
+                       detail=detail, fix="Check again later. If it keeps happening, your app may be hitting the "
+                                          "same limit.")
     if answer.code in (401, 403):
-        return _result(t, "up", f"Up, needs a key ({answer.code}) to list its models", latency_ms=answer.ms,
+        return _result(t, "up", f"Reachable, needs a key ({answer.code}) to list its models", latency_ms=answer.ms,
                        detail=detail)
     if t.model and answer.body is not None:
         listed = t.model.removesuffix(":latest") in _model_names(answer.body)
@@ -261,8 +276,8 @@ async def llm(t: CheckTarget, http: httpx.AsyncClient) -> CheckResult:
         if not listed:
             fix = f"Run `ollama pull {t.model}`." if t.catalog == "ollama" else None
             what = "isn't pulled" if t.catalog == "ollama" else "isn't in its model list"
-            return _result(t, "warn", f"Up, but {t.model} {what}", latency_ms=answer.ms, detail=detail, fix=fix)
-    up = f"Up, {t.model} is ready" if t.model and detail.get("model_listed") else "Up"
+            return _result(t, "warn", f"Reachable, but {t.model} {what}", latency_ms=answer.ms, detail=detail, fix=fix)
+    up = f"Reachable, {t.model} is ready" if t.model and detail.get("model_listed") else _reachable(answer.code)
     if warnings := _warnings(url, answer):
         return _result(t, "warn", f"{up}, but {'; '.join(warnings)}", latency_ms=answer.ms, detail=detail)
     return _result(t, "up", up, latency_ms=answer.ms, detail=detail)
@@ -329,7 +344,7 @@ async def mcp(t: CheckTarget, root: Path, http: httpx.AsyncClient) -> CheckResul
                 reason += f"\nIts config sets {', '.join(t.env_names)}."
             return _result(t, "down", "Stopped while starting", reason=reason, fix=_env_fix(t))
     ms = (time.perf_counter() - start) * 1000
-    up = f"Up: {len(tools)} tool{'s' if len(tools) != 1 else ''}"
+    up = f"Reachable: {len(tools)} tool{'s' if len(tools) != 1 else ''}"
     detail = {"tools": tools}
     if ms > MCP_SLOW_MS:
         return _result(t, "warn", f"{up}, but slow to start: {took(ms)}", latency_ms=ms, detail=detail)

{flowforge_map-0.4.0 → flowforge_map-0.4.2}/backend/flowforge/cli_ui.py

@@ -73,9 +73,13 @@ def level(value: str) -> Text:
     return Text(value, style=STYLES.get(value, ""))
 
 
+HEALTH_WORDS = {"up": "reachable", "warn": "needs a look"}   # what a check proves (D52)
+
+
 def dot(out: Console, status: str) -> Text:
     """Health keeps its label even without colour (D41)."""
-    return Text(f"{'●' if utf8(out) else '*'} {status}", style=STYLES.get(status, "bright_black"))
+    word = HEALTH_WORDS.get(status, status)
+    return Text(f"{'●' if utf8(out) else '*'} {word}", style=STYLES.get(status, "bright_black"))
 
 
 def table(out: Console, title: str, columns: list[str], rows: list[list[Any]], *, border: bool = True) -> None:

{flowforge_map-0.4.0 → flowforge_map-0.4.2}/backend/flowforge/example_data.py

@@ -176,21 +176,21 @@ def _recorded(id: str, status: Status, latency_ms: float | None, summary: str, *
 
 # Recorded check results for the trip planner (D24): what a real check run gave, so example mode stays offline.
 CHECK_RESULTS: dict[str, CheckResult] = {r.id: r for r in [
-    _recorded("mcp-time", "up", 1900, "Up: 2 tools"),
-    _recorded("mcp-files", "up", 2400, "Up: 14 tools"),
-    _recorded("mcp-fetch", "warn", 6800, "Up: 1 tool, but slow to start: 6.8 s"),
+    _recorded("mcp-time", "up", 1900, "Reachable: 2 tools"),
+    _recorded("mcp-files", "up", 2400, "Reachable: 14 tools"),
+    _recorded("mcp-fetch", "warn", 6800, "Reachable: 1 tool, but slow to start: 6.8 s"),
     _recorded("mcp-currency", "down", None, "Stopped while starting",
               reason="currency server: CURRENCY_API_URL is not set",
               fix="Its code reads CURRENCY_API_URL (mcp_servers/currency.py:9), but its MCP config gives it no env."),
     _recorded("local-packing-list", "up", None, "Found, not run"),
     _recorded("llm-ollama", "down", None, "Nothing answers at localhost:11434",
               reason="[Errno 111] Connection refused", fix="Start Ollama (`ollama serve`)."),
-    _recorded("api-osrm", "up", 640, "Up"),
-    _recorded("api-open-meteo", "up", 180, "Up"),
-    _recorded("api-nominatim", "up", 420, "Up"),
-    _recorded("api-ip-api-com", "warn", 210, "Up, but plain http://: not encrypted"),
-    _recorded("api-google-maps", "up", 230, "Up, needs a key (403)"),
-    _recorded("api-wikipedia", "up", 310, "Up"),
+    _recorded("api-osrm", "up", 640, "Reachable"),
+    _recorded("api-open-meteo", "up", 180, "Reachable"),
+    _recorded("api-nominatim", "up", 420, "Reachable"),
+    _recorded("api-ip-api-com", "warn", 210, "Reachable, but plain http://: not encrypted"),
+    _recorded("api-google-maps", "up", 230, "Reachable, needs a key (403)"),
+    _recorded("api-wikipedia", "up", 310, "Reachable"),
 ]}
 
 

{flowforge_map-0.4.0 → flowforge_map-0.4.2}/backend/flowforge/flow/__init__.py

@@ -19,8 +19,10 @@ from flowforge.flow.order import Body, Stmt, flatten, label, preds, reduce
 from flowforge.flow.reach import Hit, Reach, writes
 from flowforge.flowmap.models import Evidence, Flow, FlowEdge, FlowNode, Op
 from flowforge.flowmap.validate import DEFAULT_MS, actions_of
+from flowforge.scan.files import language
 from flowforge.scan.models import Dependency, ScanResult
 from flowforge.scan.scanner import Places, scan_with_places
+from flowforge.security.finders import masked_lines
 from flowforge.security.logfilter import Redactor, redact_code
 
 NO_CODE = "Flow order reads Python, Dart, JavaScript and TypeScript."
@@ -130,7 +132,7 @@ class _Builder:
 
     def entry(self, func: Any, body: Body, lang: Any) -> None:
         self.lang = lang
-        lines = self.sources[func.path].splitlines()
+        lines = masked_lines(self.sources[func.path], language(func.path), _redactor)   # every key masked first
         start = f"start-{func.name.replace('.', '-')}"[:64]
         self.nodes.append(FlowNode(id=start, kind="start", title=f"{func.name}()"[:80],
                                    what=f"An entry point in {func.path}.",

{flowforge_map-0.4.0 → flowforge_map-0.4.2}/backend/flowforge/flow/curly.py

@@ -16,6 +16,7 @@ from flowforge.flow.rewrite import Call
 from flowforge.flowmap.models import Change
 from flowforge.scan import services
 from flowforge.scan.scanner import Places
+from flowforge.security.finders import split_key_in
 from flowforge.security.logfilter import redact_code
 
 LANGUAGES = frozenset({"dart", "javascript", "typescript"})
@@ -852,6 +853,8 @@ def change(calls: list[Call], lang: Lang) -> Change | None:
     first_line = plain[0][0].line
     last_line = lang.end_line(func, plain[-1][0].stmt)
     lines = src.text.splitlines()
+    if split_key_in(src.text, func.language, first_line, last_line):
+        return None   # a key split over lines sits in the block: the prompt only, never its pieces
     indent = re.match(r"\s*", lines[first_line - 1]).group(0)
     semi = ";" if func.language == "dart" or all(p[4] for _, p in plain) else ""
     if func.language == "dart":

{flowforge_map-0.4.0 → flowforge_map-0.4.2}/backend/flowforge/flow/index.py

@@ -58,6 +58,7 @@ class Index:
     def __init__(self, sources: dict[str, str]):
         self.modules: dict[str, Module] = {}
         self.funcs: dict[str, Func] = {}
+        self.changed: dict[str, set[str]] = {}   # func key -> parameters it changes in place (D51)
         for path, text in sources.items():
             try:
                 tree = ast.parse(text)

{flowforge_map-0.4.0 → flowforge_map-0.4.2}/backend/flowforge/flow/order.py

@@ -11,7 +11,7 @@ import ast
 import re
 from dataclasses import dataclass, field
 
-from flowforge.flow.index import Func, Index
+from flowforge.flow.index import Func, Index, Module
 from flowforge.flow.reach import Hit, Reach, gathers
 
 MUTATORS = frozenset({"append", "extend", "update", "add", "insert", "pop", "remove", "clear", "setdefault", "write",
@@ -41,17 +41,82 @@ def _reads(node: ast.AST) -> set[str]:
 
 
 def _writes(node: ast.AST) -> set[str]:
-    out = {n.id for n in ast.walk(node) if isinstance(n, ast.Name) and isinstance(n.ctx, (ast.Store, ast.Del))}
+    bound = {n.id for n in ast.walk(node) if isinstance(n, ast.Name) and isinstance(n.ctx, (ast.Store, ast.Del))}
+    return bound | changes(node)
+
+
+def _base(node: ast.AST) -> str | None:
+    while isinstance(node, (ast.Subscript, ast.Attribute)):
+        node = node.value
+    return node.id if isinstance(node, ast.Name) else None
+
+
+def changes(node: ast.AST) -> set[str]:
+    """Names whose object the code changes in place: `x[k] = …`, `x.a = …`, `x.append(…)` (rebinding `x` isn't)."""
+    out: set[str] = set()
     for n in ast.walk(node):
-        if isinstance(n, (ast.Subscript, ast.Attribute)) and isinstance(n.ctx, ast.Store):
-            base = n.value
-            while isinstance(base, (ast.Subscript, ast.Attribute)):
-                base = base.value
-            if isinstance(base, ast.Name):
-                out.add(base.id)
+        if isinstance(n, (ast.Subscript, ast.Attribute)) and isinstance(n.ctx, (ast.Store, ast.Del)) \
+                and (base := _base(n.value)):
+            out.add(base)
         if isinstance(n, ast.Call) and isinstance(n.func, ast.Attribute) and n.func.attr in MUTATORS \
-                and isinstance(n.func.value, ast.Name):
-            out.add(n.func.value.id)   # facts.append(x) writes facts
+                and (base := _base(n.func.value)):
+            out.add(base)   # facts.append(x) writes facts
+    return out
+
+
+def _params(func: Func) -> list[str]:
+    a = func.node.args
+    return [p.arg for p in (*a.posonlyargs, *a.args, *a.kwonlyargs)]
+
+
+def _is_method(func: Func) -> bool:
+    static = any(isinstance(d, ast.Name) and d.id == "staticmethod" for d in func.node.decorator_list)
+    return "." in func.name and not static
+
+
+def _passed(call: ast.Call, target: Func, changed: set[str]) -> set[str]:
+    """The caller's names that land on `changed` parameters of `target`: by position, by keyword, and the receiver
+    of a method (`cart.add(x)` passes `cart` as `self`)."""
+    params = _params(target)
+    out: set[str] = set()
+    if _is_method(target) and isinstance(call.func, ast.Attribute):
+        if params and params[0] in changed and (base := _base(call.func.value)):
+            out.add(base)
+        params = params[1:]
+    for i, arg in enumerate(call.args):
+        if i < len(params) and params[i] in changed and (base := _base(arg)):
+            out.add(base)
+    for kw in call.keywords:
+        if kw.arg in changed and (base := _base(kw.value)):
+            out.add(base)
+    return out
+
+
+def changed_params(index: Index, key: str, _stack: frozenset[str] = frozenset()) -> set[str]:
+    """The parameters a function in the repo changes in place, itself or through the repo's functions it calls (D51).
+    Library calls are taken not to change their arguments."""
+    if key in index.changed:
+        return index.changed[key]
+    func = index.funcs[key]
+    params = set(_params(func))
+    found = changes(func.node) & params
+    module = index.modules[func.module]
+    cls = func.name.split(".")[0] if "." in func.name else None
+    for n in ast.walk(func.node):
+        if isinstance(n, ast.Call) and (sub := index.resolve(n, module, cls)) and sub not in _stack | {key}:
+            found |= _passed(n, index.funcs[sub], changed_params(index, sub, _stack | {key})) & params
+    if not _stack:
+        index.changed[key] = found   # a result found inside a cycle may be partial: kept only from the top
+    return found
+
+
+def call_writes(node: ast.AST, index: Index, module: Module, cls: str | None) -> set[str]:
+    """Names a statement changes through the repo's own functions it calls: `await load(ctx)` writes `ctx` when `load`
+    fills it (D51)."""
+    out: set[str] = set()
+    for n in ast.walk(node):
+        if isinstance(n, ast.Call) and (key := index.resolve(n, module, cls)):
+            out |= _passed(n, index.funcs[key], changed_params(index, key))
     return out
 
 
@@ -71,7 +136,7 @@ def flatten(func: Func, index: Index, reach: Reach) -> Body:
     def add(node: ast.AST, line: int, ifs: list[tuple[int, str]], loop: bool, *, reads: set[str] | None = None,
             writes: set[str] | None = None, hit_node: ast.AST | None = None, is_if: bool = False) -> Stmt:
         s = Stmt(idx=len(body.stmts), node=node, line=line, reads=_reads(node) if reads is None else reads,
-                 writes=_writes(node) if writes is None else writes,
+                 writes=_writes(node) | call_writes(node, index, module, cls) if writes is None else writes,
                  hits=reach.statement(hit_node if hit_node is not None else node, module, cls) if hit_node is not False
                  else [], ifs=list(ifs), loop=loop, returns=isinstance(node, (ast.Return, ast.Raise)),
                  gathered=gathers(node), is_if=is_if)

{flowforge_map-0.4.0 → flowforge_map-0.4.2}/backend/flowforge/flow/rewrite.py

@@ -12,7 +12,9 @@ import ast
 from dataclasses import dataclass
 from typing import Any
 
+from flowforge.flow.order import changes
 from flowforge.flowmap.models import Change
+from flowforge.security.finders import split_key_in
 from flowforge.security.logfilter import redact_code
 
 
@@ -75,6 +77,20 @@ def _names(node: ast.AST, ctx: type) -> set[str]:
     return {n.id for n in ast.walk(node) if isinstance(n, ast.Name) and isinstance(n.ctx, ctx)}
 
 
+def _handed(node: ast.AST) -> set[str]:
+    """Names handed to any call: a function we can't see into might change them, so a written change won't move a
+    call past it (D51)."""
+    out: set[str] = set()
+    for n in ast.walk(node):
+        if isinstance(n, ast.Call):
+            for arg in [*n.args, *(k.value for k in n.keywords)]:
+                while isinstance(arg, (ast.Subscript, ast.Attribute, ast.Starred)):
+                    arg = arg.value
+                if isinstance(arg, ast.Name):
+                    out.add(arg.id)
+    return out
+
+
 def _quoted(c: Call) -> str:
     return f'"{c.words}" ({c.ref})'
 
@@ -102,16 +118,19 @@ def change(calls: list[Call], source: str, module: ast.Module) -> Change | None:
     targets = set().union(*(_names(c.stmt, ast.Store) for c in plain))
     reads = set().union(*(_names(_awaited(c.stmt)[1], ast.Load) for c in plain))
     for st in body[first: last + 1]:
-        if id(st) not in members and (_names(st, ast.Load) & targets or _names(st, ast.Store) & reads):
-            return None   # code between them uses a result, or changes what a call reads
+        if id(st) not in members and (_names(st, ast.Load) & targets or _names(st, ast.Store) & reads
+                                      or (changes(st) | _handed(st)) & reads):
+            return None   # code between them uses a result, or changes (or may change) what a call reads (D51)
 
     lines = source.splitlines()
+    end = plain[-1].stmt.end_lineno or plain[-1].stmt.lineno
+    if split_key_in(source, "python", plain[0].stmt.lineno, end):
+        return None   # a key split over lines sits in the block: the prompt only, never its pieces
     indent = lines[plain[0].stmt.lineno - 1][: plain[0].stmt.col_offset]
     names = [_awaited(c.stmt)[0] for c in plain]
     lhs = "" if all(n == "_" for n in names) else f"{', '.join(names)} = "
     gather = [f"{indent}{lhs}await asyncio.gather(",
               *(f"{indent}    {ast.unparse(_awaited(c.stmt)[1])}," for c in plain), f"{indent})"]
-    end = plain[-1].stmt.end_lineno or plain[-1].stmt.lineno
     spans = [(c.stmt.lineno, c.stmt.end_lineno or c.stmt.lineno) for c in plain]
     after: list[str] = []
     for n in range(plain[0].stmt.lineno, end + 1):