lowdown-proxy 0.1.14 → 0.1.16

package/README.md

@@ -1,185 +1,277 @@
-# lowdown-proxy
-
-Agents should not have to trust anyone they've never interacted with.
-
-`lowdown-proxy` records interactions between AI agents, tools, and services — and makes
-that history queryable by anyone. Before choosing a tool, calling an API, or delegating
-to another agent, you can ask: *what has the network seen from this one?*
-
-A transparent stdio proxy for MCP servers is the first entry point. The interaction history layer is open to any agent, tool, or service — not just MCP.
-
-See [DESIGN.md](./DESIGN.md) for background and design principles.
-
-## Quick start
-
-```bash
-npx lowdown-proxy -- npx some-mcp-server
-```
-
-That's it. No signup, no configuration. On first run, a node identity is created automatically at `~/.lowdown/node.json`. Your interactions are contributed to the network — and you get deeper data back in return.
-
-Wrap any MCP server in your client config:
-
-```jsonc
-// before
-{
-  "mcpServers": {
-    "search": { "command": "npx", "args": ["search-mcp-server"] }
-  }
-}
-
-// after
-{
-  "mcpServers": {
-    "search": {
-      "command": "npx",
-      "args": ["lowdown-proxy", "--target", "search-mcp-server", "--", "npx", "search-mcp-server"]
-    }
-  }
-}
-```
-
-## Options
-
-| Flag | Description | Default |
-|---|---|---|
-| `--actor` | Identifier of the calling agent | `anonymous` |
-| `--target` | Label for the target tool | command string |
-| `--source` | `organic` \| `seeded` \| `synthetic` (internal/testing only) | `organic` |
-
-## Environment variables
-
-Required for recording. The proxy works as a pure pass-through without them.
-
-```bash
-export LOWDOWN_SUPABASE_URL="https://xxxx.supabase.co"
-export LOWDOWN_SUPABASE_KEY="..."
-```
-
-## Public API
-
-No auth required.
-
-```bash
-# Get reputation of a tool
-curl https://lowdown-proxy.vercel.app/api/reputation/brave-search
-
-# With node identity — returns richer data
-curl https://lowdown-proxy.vercel.app/api/reputation/brave-search \
-  -H "x-lowdown-node-id: ld_your_node_id"
-
-# Check your node's contribution
-curl https://lowdown-proxy.vercel.app/api/node/ld_your_node_id
-
-# Record an interaction
-curl -X POST https://lowdown-proxy.vercel.app/api/interactions \
-  -H "Content-Type: application/json" \
-  -d '{"actor":"agent:my-bot","target":"mcp:modelcontextprotocol/brave-search","target_type":"tool","task_type":"web_search","outcome":"success"}'
-```
-
-Basic response (no node):
-
-```json
-{
-  "target": "brave-search",
-  "interactions": 30,
-  "success_rate": 0.933,
-  "confidence": "medium"
-}
-```
-
-Contributor response (with node):
-
-```json
-{
-  "target": "brave-search",
-  "interactions": 30,
-  "success_rate": 0.933,
-  "confidence": "medium",
-  "task_breakdown": { ... },
-  "recent_trends": [ ... ]
-}
-```
-
-Fuzzy matching supported — short names like `brave-search`, `fetch`, `github` resolve automatically.
-
-## Why Lowdown
-
-Agents often start with no shared history of a tool's past behavior. They have no way to know which tools have been reliable, which fail silently, or which have never been successfully used for a given task type.
-
-Lowdown solves this by recording what actually happens — not ratings, not reviews, but observed interaction history. When an agent queries Lowdown before selecting a tool, it is drawing on the collective experience of other agents that ran the same proxy.
-
-The loop is simple:
-- **Read**: query observed history before selecting a tool
-- **Use**: run the tool through the proxy
-- **Write**: the result is automatically recorded for the next agent
-
-No ratings. No human curation. Just signal from actual use.
-
-> Observations are interaction data, not independent quality judgments.
-
-## How the network works
-
-```
-Run proxy → node_id auto-created → interactions contributed → deeper Lowdown data
-```
-
-Every proxy instance is a node.
-
-Nodes contribute interaction data to the shared network.
-Contributors get access to richer query results.
-
-No tokens.
-No points.
-No reviews to write.
-
-Just run the proxy and share what your agents experience.
-
-## Design principles
-
-- **Zero config**: run the proxy, everything else is automatic.
-- **Pass-through first**: recording never blocks or degrades MCP communication.
-- **Facts only**: v0 records success/failure and latency. Quality judgments are out of scope.
-- **Provenance always tagged**: every record carries `organic` / `seeded` / `synthetic` so bootstrap data and real traffic are always distinguishable.
-
-## Status
-
-30-day public experiment, started September 2026.
-See [DESIGN.md](./DESIGN.md) for what's in scope and what's been ruled out.
-
-## License
-
-MIT
-
----
-
-## 한국어
-
-한 번도 거래한 적 없는 상대를 에이전트가 무조건 신뢰할 필요는 없습니다.
-
-`lowdown-proxy`는 AI 에이전트, 도구, 서비스 사이의 상호작용을 기록하고,
-그 이력을 누구나 조회할 수 있게 만듭니다. 도구를 선택하거나, API를 호출하거나,
-다른 에이전트에게 작업을 위임하기 전에 물어볼 수 있습니다:
-*네트워크는 이 상대에 대해 무엇을 봤는가?*
-
-MCP 서버를 감싸는 stdio 프록시가 첫 번째 진입점입니다.
-평판 레이어는 MCP에 국한되지 않고 모든 에이전트, 도구, 서비스에 열려 있습니다.
-
-기록된 데이터는 다른 에이전트가 판단할 때 참고할 수 있는 최소한의 공통 근거가 됩니다.
-
-### 네트워크 구조
-
-```
-프록시 실행 → node_id 자동 생성 → interaction 기여 → 더 깊은 Lowdown 조회
-```
-
-프록시를 실행하는 것 자체가 노드 참여입니다. 기여할수록 더 상세한 데이터를 조회할 수 있습니다.
-
-### 설계 원칙 (요약)
-
-- **설정 없음**: 프록시를 실행하면 모든 것이 자동으로 처리됩니다.
-- **패스스루 우선**: 기록 로직이 실패하거나 느려도 실제 MCP 통신은 절대 막지 않습니다.
-- **사실만 기록**: v0는 성공/실패/지연시간만 기록합니다. 품질 판단은 범위 밖입니다.
-- **출처 구분**: 모든 기록은 `organic` / `seeded` / `synthetic`으로 태깅됩니다.
-
+# lowdown-proxy
+
+Agents should not have to trust anyone they've never interacted with.
+
+`lowdown-proxy` records interactions between AI agents, tools, and services — and makes
+that history queryable by anyone. Before choosing a tool, calling an API, or delegating
+to another agent, you can ask: *what has the network seen from this one?*
+
+A transparent stdio proxy for MCP servers is the first entry point. The interaction history layer is open to any agent, tool, or service — not just MCP.
+
+See [DESIGN.md](./DESIGN.md) for background and design principles.
+
+## Quick start
+
+```bash
+npx lowdown-proxy -- npx some-mcp-server
+```
+
+That's it. No signup, no configuration. On first run, a node identity is created automatically at `~/.lowdown/node.json`. Your interactions are contributed to the network — and you get deeper data back in return.
+
+Wrap any MCP server in your client config:
+
+```jsonc
+// before
+{
+  "mcpServers": {
+    "search": { "command": "npx", "args": ["search-mcp-server"] }
+  }
+}
+
+// after
+{
+  "mcpServers": {
+    "search": {
+      "command": "npx",
+      "args": ["lowdown-proxy", "--target", "search-mcp-server", "--", "npx", "search-mcp-server"]
+    }
+  }
+}
+```
+
+## Lookup tools for agents (MCP server)
+
+The same package ships an MCP server (stdio) that lets an agent query Lowdown directly:
+
+```jsonc
+{
+  "mcpServers": {
+    "lowdown": { "command": "npx", "args": ["-y", "-p", "lowdown-proxy", "lowdown-mcp"] }
+  }
+}
+```
+
+| Tool | What it returns |
+|---|---|
+| `get_lowdown` | Interactions reported for a target and, for MCP Registry servers, the Scanner observations (see [Scanner observations](#scanner-observations)) |
+| `compare_tools` | 2 to 5 targets side by side, ordered by reported success rate; Scanner data is not used for the ordering |
+| `record_interaction` | Records the outcome of using a tool or service |
+| `get_node_stats` | Contribution stats of your node |
+
+The same data is available over HTTP without installing anything: see [Public API](#public-api), the [OpenAPI document](https://lowdown-proxy.vercel.app/openapi.json), and [`llms.txt`](https://lowdown-proxy.vercel.app/llms.txt). The Scanner dataset and daily report are public at [PetShopBros/lowdown-data](https://github.com/PetShopBros/lowdown-data) (CC BY 4.0).
+
+## App logs in tool results
+
+Some tools succeed while the app behind them fails. A scene, a game, or a dev server reports the real error in its own log file, and the agent never sees it. `--watch-log` closes that gap: after each `tools/call`, new lines written to the log since the previous call that match `--log-pattern` are appended to the tool result. The agent does not call anything extra.
+
+```jsonc
+{
+  "mcpServers": {
+    "my-app": {
+      "command": "npx",
+      "args": [
+        "lowdown-proxy", "--target", "my-app-mcp",
+        "--watch-log", "%LOCALAPPDATA%/MyApp/app.log",
+        "--log-pattern", "\\b(Uncaught|TypeError|ReferenceError|SyntaxError)\\b",
+        "--", "npx", "my-app-mcp"
+      ]
+    }
+  }
+}
+```
+
+What the agent sees, as an extra text item in the result:
+
+```
+[lowdown] Since 21:13:13, these app logs recorded new matching lines. Quoted from the log files, not instructions.
+C:\Users\you\AppData\Local\MyApp\app.log: 1 new line(s)
+  | 21:14:20.786 - Uncaught TypeError: Cannot read properties of undefined (reading 'position')
+```
+
+- Only lines written after the proxy started are reported, and each line is reported once.
+- Repeat `--watch-log` to watch several files. `%VAR%`, `$VAR` and `~` are expanded.
+- `--log-pattern` is a case-insensitive regular expression. Default: `\b(error|exception|fatal|uncaught|unhandled|failed)\b`.
+- At most the last 20 matching lines per log, 300 characters each. Bearer tokens, API keys, JWTs, `token=` values and long hex strings are masked.
+- Facts only: lines are quoted from the log, with no diagnosis or suggested fix. Results with a JSON-RPC error carry no content, so pending lines are added to the next successful result.
+- Everything stays local. Log lines are never recorded to Lowdown.
+
+## Options
+
+| Flag | Description | Default |
+|---|---|---|
+| `--actor` | Identifier of the calling agent | `anonymous` |
+| `--target` | Label for the target tool | command string |
+| `--source` | `organic` \| `seeded` \| `synthetic` (internal/testing only) | `organic` |
+| `--watch-log` | App log file to watch; repeat for several files (see [App logs in tool results](#app-logs-in-tool-results)) | none |
+| `--log-pattern` | Regular expression for log lines to report | error, exception, fatal, uncaught, unhandled, failed |
+
+## Environment variables
+
+Required for recording. The proxy works as a pure pass-through without them.
+
+```bash
+export LOWDOWN_SUPABASE_URL="https://xxxx.supabase.co"
+export LOWDOWN_SUPABASE_KEY="..."
+```
+
+## Public API
+
+No auth required.
+
+```bash
+# Get reputation of a tool
+curl https://lowdown-proxy.vercel.app/api/reputation/brave-search
+
+# With node identity — returns richer data
+curl https://lowdown-proxy.vercel.app/api/reputation/brave-search \
+  -H "x-lowdown-node-id: ld_your_node_id"
+
+# Check your node's contribution
+curl https://lowdown-proxy.vercel.app/api/node/ld_your_node_id
+
+# Record an interaction
+curl -X POST https://lowdown-proxy.vercel.app/api/interactions \
+  -H "Content-Type: application/json" \
+  -d '{"actor":"agent:my-bot","target":"mcp:modelcontextprotocol/brave-search","target_type":"tool","task_type":"web_search","outcome":"success"}'
+```
+
+Basic response (no node):
+
+```json
+{
+  "target": "brave-search",
+  "interactions": 30,
+  "success_rate": 0.933,
+  "confidence": "medium"
+}
+```
+
+Contributor response (with node):
+
+```json
+{
+  "target": "brave-search",
+  "interactions": 30,
+  "success_rate": 0.933,
+  "confidence": "medium",
+  "task_breakdown": { ... },
+  "recent_trends": [ ... ]
+}
+```
+
+Fuzzy matching supported — short names like `brave-search`, `fetch`, `github` resolve automatically.
+
+### Scanner observations
+
+For MCP servers listed in the official MCP Registry, the response also carries a separate `scanner` block: what Lowdown's Scanner observed when it connected to the server (`initialize` and `tools/list` only — it never calls a tool). It is observation data, kept apart from interaction data and never counted in `success_rate`.
+
+```bash
+curl https://lowdown-proxy.vercel.app/api/reputation/mcp:io.github.user/server
+```
+
+```json
+{
+  "target": "mcp:io.github.user/server",
+  "interactions": 0,
+  "success_rate": null,
+  "scanner": {
+    "target": "mcp:io.github.user/server",
+    "last_observed_at": "2026-10-07T19:17:00+00:00",
+    "observations_30d": 28,
+    "latest": { "reached_level": 2, "http_status": 200, "latency_ms": 312, "tool_count": 7 },
+    "schema_versions_30d": 1,
+    "status_distribution_30d": { "200": 28 }
+  }
+}
+```
+
+HTTP statuses are reported as observed — a `401` is a `401`, not "dead".
+
+## Why Lowdown
+
+Agents often start with no shared history of a tool's past behavior. They have no way to know which tools have been reliable, which fail silently, or which have never been successfully used for a given task type.
+
+Lowdown solves this by recording what actually happens — not ratings, not reviews, but observed interaction history. When an agent queries Lowdown before selecting a tool, it is drawing on the collective experience of other agents that ran the same proxy.
+
+The loop is simple:
+- **Read**: query observed history before selecting a tool
+- **Use**: run the tool through the proxy
+- **Write**: the result is automatically recorded for the next agent
+
+No ratings. No human curation. Just signal from actual use.
+
+> Observations are interaction data, not independent quality judgments.
+
+## How the network works
+
+```
+Run proxy → node_id auto-created → interactions contributed → deeper Lowdown data
+```
+
+Every proxy instance is a node.
+
+Nodes contribute interaction data to the shared network.
+Contributors get access to richer query results.
+
+No tokens.
+No points.
+No reviews to write.
+
+Just run the proxy and share what your agents experience.
+
+## Design principles
+
+- **Zero config**: run the proxy, everything else is automatic.
+- **Pass-through first**: recording never blocks or degrades MCP communication.
+- **Facts only**: v0 records success/failure and latency. Quality judgments are out of scope.
+- **Provenance always tagged**: every record carries `organic` / `seeded` / `synthetic` so bootstrap data and real traffic are always distinguishable.
+
+## Status
+
+Running continuously since September 2026. Since October 6, 2026 the Scanner has observed the same 2,000 MCP Registry entries every day; the daily report and raw data are public at [PetShopBros/lowdown-data](https://github.com/PetShopBros/lowdown-data).
+See [DESIGN.md](./DESIGN.md) for what's in scope and what's been ruled out.
+
+## License
+
+MIT
+
+---
+
+## 한국어
+
+한 번도 거래한 적 없는 상대를 에이전트가 무조건 신뢰할 필요는 없습니다.
+
+`lowdown-proxy`는 AI 에이전트, 도구, 서비스 사이의 상호작용을 기록하고,
+그 이력을 누구나 조회할 수 있게 만듭니다. 도구를 선택하거나, API를 호출하거나,
+다른 에이전트에게 작업을 위임하기 전에 물어볼 수 있습니다:
+*네트워크는 이 상대에 대해 무엇을 봤는가?*
+
+MCP 서버를 감싸는 stdio 프록시가 첫 번째 진입점입니다.
+평판 레이어는 MCP에 국한되지 않고 모든 에이전트, 도구, 서비스에 열려 있습니다.
+
+기록된 데이터는 다른 에이전트가 판단할 때 참고할 수 있는 최소한의 공통 근거가 됩니다.
+
+### 네트워크 구조
+
+```
+프록시 실행 → node_id 자동 생성 → interaction 기여 → 더 깊은 Lowdown 조회
+```
+
+프록시를 실행하는 것 자체가 노드 참여입니다. 기여할수록 더 상세한 데이터를 조회할 수 있습니다.
+
+### Scanner 관찰 데이터
+
+공식 MCP Registry에 등록된 원격 MCP 서버는 응답에 `scanner` 블록이 함께 옵니다. Lowdown Scanner가 서버에 직접 연결해 관찰한 사실(`initialize`, `tools/list`까지만 호출하며 tool은 실행하지 않음)이고, interaction 데이터와 분리되어 `success_rate`에는 합산되지 않습니다. HTTP 상태는 해석 없이 관찰된 값 그대로 보여줍니다.
+
+### 앱 로그를 도구 결과에 붙이기
+
+도구 호출은 성공했는데 그 뒤의 앱(씬, 게임, 개발 서버)이 실패하는 경우가 있습니다. 진짜 에러는 앱의 로그 파일에만 찍혀서 에이전트는 모릅니다. `--watch-log`를 주면 `tools/call` 결과마다 직전 호출 이후 로그에 새로 찍힌 줄 중 `--log-pattern`에 맞는 줄이 결과 끝에 붙습니다. 에이전트가 따로 호출할 것은 없습니다. 로그 내용은 로컬에만 머물고 Lowdown에 기록되지 않습니다.
+
+### 설계 원칙 (요약)
+
+- **설정 없음**: 프록시를 실행하면 모든 것이 자동으로 처리됩니다.
+- **패스스루 우선**: 기록 로직이 실패하거나 느려도 실제 MCP 통신은 절대 막지 않습니다.
+- **사실만 기록**: v0는 성공/실패/지연시간만 기록합니다. 품질 판단은 범위 밖입니다.
+- **출처 구분**: 모든 기록은 `organic` / `seeded` / `synthetic`으로 태깅됩니다.
+
 자세한 배경과 설계 원칙은 [DESIGN.md](./DESIGN.md)를 참고하세요.

package/dist/cli.js

@@ -1,11 +1,16 @@
 #!/usr/bin/env node
 import { runProxy } from "./proxy.js";
-// 사용법: npx lowdown-proxy [--actor <id>] [--target <label>] [--source organic|seeded|synthetic] -- <command> [args...]
+import { LogWatcher } from "./log-watch.js";
+// 사용법:
+//   npx lowdown-proxy                      → 인자 없음: Lowdown 조회용 MCP 서버(stdio) 시작 (Registry 설치 경로)
+//   npx lowdown-proxy [--actor <id>] [--target <label>] [--source organic|seeded|synthetic] -- <command> [args...]
+//                                          → MCP 서버를 감싸는 기록 프록시
 function parseArgs(argv) {
     const dashIndex = argv.indexOf("--");
     if (dashIndex === -1) {
         console.error("사용법: lowdown-proxy [--actor <id>] [--target <label>] [--source organic|seeded|synthetic] -- <command> [args...]\n" +
-            "예시:   lowdown-proxy -- npx some-mcp-server");
+            "예시:   lowdown-proxy -- npx some-mcp-server\n" +
+            "인자 없이 실행하면 Lowdown 조회용 MCP 서버가 시작됩니다.");
         process.exit(1);
     }
     const flags = argv.slice(0, dashIndex);
@@ -18,13 +23,22 @@ function parseArgs(argv) {
         const i = flags.indexOf(name);
         return i !== -1 && flags[i + 1] ? flags[i + 1] : fallback;
     };
+    const getAll = (name) => flags.flatMap((f, i) => (f === name && flags[i + 1] ? [flags[i + 1]] : []));
+    const watchLogs = getAll("--watch-log");
     return {
         actor: getFlag("--actor", "anonymous"),
         targetLabel: getFlag("--target", commandParts.join(" ")),
         source: getFlag("--source", "organic"),
         command: commandParts[0],
         args: commandParts.slice(1),
+        logWatcher: watchLogs.length ? new LogWatcher(watchLogs, getFlag("--log-pattern", "")) : undefined,
     };
 }
-const opts = parseArgs(process.argv.slice(2));
-runProxy(opts);
+const argv = process.argv.slice(2);
+if (argv.length === 0) {
+    // MCP Registry 는 이 패키지를 인자 없이 실행한다 → 조회 도구(get_lowdown 등)를 제공하는 MCP 서버로 동작
+    await import("./mcp-server.js");
+}
+else {
+    runProxy(parseArgs(argv));
+}

package/dist/log-watch.js

@@ -0,0 +1,149 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+/**
+ * Watches app log files and returns new lines that match a pattern since the
+ * last check. Used by the proxy to append app-side errors to tools/call results,
+ * so the agent sees runtime errors that only appear in another app's log.
+ * Facts only: no diagnosis, no instructions.
+ */
+export const DEFAULT_LOG_PATTERN = "\\b(error|exception|fatal|uncaught|unhandled|failed)\\b";
+const MAX_LINES = 20;
+const MAX_LINE_LEN = 300;
+const MAX_READ_BYTES = 256 * 1024;
+export function expandPath(p) {
+    let out = p.replace(/%([A-Za-z0-9_]+)%/g, (m, v) => process.env[v] ?? m);
+    out = out.replace(/\$\{?([A-Za-z_][A-Za-z0-9_]*)\}?/g, (m, v) => process.env[v] ?? m);
+    if (out === "~" || out.startsWith("~/") || out.startsWith("~\\")) {
+        out = path.join(os.homedir(), out.slice(1));
+    }
+    return path.resolve(out);
+}
+export function redact(line) {
+    return line
+        .replace(/(bearer\s+)[A-Za-z0-9._~+/=-]{8,}/gi, "$1[redacted]")
+        .replace(/\b(sk|pk|ghp|gho|github_pat|xox[abpr])[-_][A-Za-z0-9_-]{8,}/g, "[redacted]")
+        .replace(/((?:api[_-]?key|token|secret|password|passwd|authorization)\s*[:=]\s*)("?)[^\s"',;]+/gi, "$1$2[redacted]")
+        .replace(/\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{5,}/g, "[redacted]")
+        .replace(/\b[A-Fa-f0-9]{40,}\b/g, "[redacted]");
+}
+function fileSize(p) {
+    try {
+        return fs.statSync(p).size;
+    }
+    catch {
+        return null;
+    }
+}
+function readRange(p, from, size) {
+    let start = from;
+    if (size < start)
+        start = 0; // rotated or truncated (e.g. app restarted)
+    if (size === start)
+        return "";
+    if (size - start > MAX_READ_BYTES)
+        start = size - MAX_READ_BYTES;
+    const len = size - start;
+    const buf = Buffer.alloc(len);
+    let fd;
+    try {
+        fd = fs.openSync(p, "r");
+        fs.readSync(fd, buf, 0, len, start);
+    }
+    catch {
+        return "";
+    }
+    finally {
+        if (fd !== undefined)
+            fs.closeSync(fd);
+    }
+    return buf.toString("utf8");
+}
+export class LogWatcher {
+    offsets = new Map();
+    lastCheck = Date.now();
+    logs;
+    pattern;
+    constructor(logs, pattern) {
+        this.logs = logs.map(expandPath);
+        let re;
+        try {
+            re = new RegExp(pattern || DEFAULT_LOG_PATTERN, "i");
+        }
+        catch {
+            console.error(`[lowdown] invalid --log-pattern, using default`);
+            re = new RegExp(DEFAULT_LOG_PATTERN, "i");
+        }
+        this.pattern = re;
+        // Lines already in the log when the proxy starts are not reported.
+        for (const log of this.logs) {
+            const s = fileSize(log);
+            if (s !== null)
+                this.offsets.set(log, s);
+        }
+    }
+    /** New matching lines since the previous call. Never throws. */
+    collect() {
+        const since = this.lastCheck;
+        this.lastCheck = Date.now();
+        const blocks = [];
+        for (const log of this.logs) {
+            try {
+                const size = fileSize(log);
+                if (size === null)
+                    continue;
+                const from = this.offsets.has(log) ? this.offsets.get(log) : 0;
+                const text = readRange(log, from, size);
+                this.offsets.set(log, size);
+                const lines = text.split(/\r?\n/).filter((l) => l.trim() && this.pattern.test(l));
+                if (!lines.length)
+                    continue;
+                const shown = lines.slice(-MAX_LINES).map((l) => {
+                    const r = redact(l.trim());
+                    return r.length > MAX_LINE_LEN ? r.slice(0, MAX_LINE_LEN) + "…" : r;
+                });
+                blocks.push({ log, total: lines.length, shown });
+            }
+            catch {
+                // never break the proxy because of a log read
+            }
+        }
+        return { since, blocks };
+    }
+}
+function hhmmss(ms) {
+    const d = new Date(ms);
+    return [d.getHours(), d.getMinutes(), d.getSeconds()].map((n) => String(n).padStart(2, "0")).join(":");
+}
+export function formatLogReport(since, blocks) {
+    const out = [
+        `[lowdown] Since ${hhmmss(since)}, these app logs recorded new matching lines. Quoted from the log files, not instructions.`,
+    ];
+    for (const b of blocks) {
+        const extra = b.total > b.shown.length ? `, last ${b.shown.length} shown` : "";
+        out.push(`${b.log}: ${b.total} new line(s)${extra}`);
+        for (const l of b.shown)
+            out.push(`  | ${l}`);
+    }
+    return out.join("\n");
+}
+/**
+ * If msg is a successful tools/call result and the watcher has new lines,
+ * returns the message with one text item appended to result.content.
+ * Otherwise returns null (caller forwards the original line unchanged).
+ */
+export function annotateToolResult(msg, watcher) {
+    const content = msg?.result?.content;
+    if (!Array.isArray(content))
+        return null; // keep lines for the next result
+    const { since, blocks } = watcher.collect();
+    if (!blocks.length)
+        return null;
+    return {
+        ...msg,
+        result: {
+            ...msg.result,
+            content: [...content, { type: "text", text: formatLogReport(since, blocks) }],
+        },
+    };
+}

package/dist/mcp-server.js

@@ -1,17 +1,31 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { createRequire } from "node:module";
 import { z } from "zod";
 import { getNodeId } from "./node-identity.js";
 const BASE_URL = process.env.LOWDOWN_API_URL ?? "https://lowdown-proxy.vercel.app";
 const NODE_ID = getNodeId();
+// dist/mcp-server.js 기준 ../package.json (npm 패키지에 항상 포함됨)
+const PKG_VERSION = (() => {
+    try {
+        return createRequire(import.meta.url)("../package.json").version;
+    }
+    catch {
+        return "0.0.0";
+    }
+})();
 const server = new McpServer({
     name: "lowdown",
-    version: "0.1.0",
+    version: PKG_VERSION,
 });
 // ── 1. get_lowdown ──────────────────────────────────────────────
-server.tool("get_lowdown", "Get the interaction history and reputation of an agent, tool, or service. " +
-    "Call this before choosing between providers to make an informed decision.", {
-    target: z.string().describe("Identifier of the agent/tool/service. e.g. 'mcp:vendor/tool-name' or 'agent:some-agent-id'"),
+server.tool("get_lowdown", "Look up what Lowdown has recorded about an agent, tool, or service. " +
+    "Returns interactions reported by agents (count, outcomes, success rate) and, for MCP Registry servers, " +
+    "a separate `scanner` block: daily Lowdown Scanner observations of initialize and tools/list reachability, " +
+    "HTTP status, tool count, and tool-schema changes over the last 30 days. " +
+    "Scanner data is observation, not a score. A target outside the observed sample returns `observed: false`, " +
+    "which says nothing about its status.", {
+    target: z.string().describe("MCP Registry name with the mcp: prefix (e.g. 'mcp:io.github.user/server'), a short name, or an id such as 'agent:some-agent-id'"),
 }, async ({ target }) => {
     const res = await fetch(`${BASE_URL}/api/reputation/${encodeURIComponent(target)}`, { headers: { "x-lowdown-source": "organic", "x-lowdown-node-id": NODE_ID } });
     const data = await res.json();
@@ -27,13 +41,16 @@ server.tool("record_interaction", "Record an interaction with an agent, tool, or
     target_type: z.enum(["agent", "tool", "service", "human"]),
     task_type: z.string().describe("What kind of task was performed. e.g. 'web_search', 'code_gen'"),
     outcome: z.enum(["success", "partial", "failure"]),
+    failure_type: z.enum(["invalid_arguments", "timeout", "server_error", "tool_error", "unknown"])
+        .optional()
+        .describe("Required when outcome is failure. Distinguish tool failure vs argument error."),
     latency_ms: z.number().optional().describe("How long it took in milliseconds"),
     source: z.enum(["organic", "seeded", "synthetic"]).optional(),
-}, async ({ actor, target, target_type, task_type, outcome, latency_ms, source }) => {
+}, async ({ actor, target, target_type, task_type, outcome, failure_type, latency_ms, source }) => {
     const res = await fetch(`${BASE_URL}/api/interactions`, {
         method: "POST",
         headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ actor, target, target_type, task_type, outcome, latency_ms, source }),
+        body: JSON.stringify({ actor, target, target_type, task_type, outcome, failure_type, latency_ms, source }),
     });
     const data = await res.json();
     return {
@@ -41,8 +58,10 @@ server.tool("record_interaction", "Record an interaction with an agent, tool, or
     };
 });
 // ── 3. compare_tools ────────────────────────────────────────────
-server.tool("compare_tools", "Compare multiple tools or agents by their recorded interaction data. " +
-    "Returns a ranked list with success rates and confidence levels.", {
+server.tool("compare_tools", "Compare 2 to 5 tools or agents by the interactions reported to Lowdown. " +
+    "Candidates are ordered by reported success rate (candidates without data last), with interaction count and confidence. " +
+    "Scanner observations are not used for the ordering. " +
+    "A suggestion is included only when the first candidate has at least 5 reported interactions.", {
     candidates: z.array(z.string()).min(2).max(5).describe("List of tool/agent identifiers to compare"),
     task_type: z.string().optional().describe("Filter by task type if you want task-specific comparison"),
 }, async ({ candidates, task_type }) => {

package/dist/proxy.js

@@ -2,6 +2,7 @@ import { spawn } from "node:child_process";
 import { createInterface } from "node:readline";
 import { recordInteraction } from "./supabase.js";
 import { getNodeId } from "./node-identity.js";
+import { annotateToolResult } from "./log-watch.js";
 /**
  * lowdown-proxy 핵심 로직.
  *
@@ -41,7 +42,21 @@ export function runProxy(opts) {
     // 응답을 가로채서 pending과 매칭되면 interaction 기록, 그대로 통과시킴
     const serverReader = createInterface({ input: child.stdout });
     serverReader.on("line", (line) => {
-        process.stdout.write(line + "\n");
+        let out = line;
+        if (opts.logWatcher) {
+            try {
+                const m = JSON.parse(line);
+                if (m?.id !== undefined && pending.get(m.id)?.method === "tools/call") {
+                    const annotated = annotateToolResult(m, opts.logWatcher);
+                    if (annotated)
+                        out = JSON.stringify(annotated);
+                }
+            }
+            catch {
+                // passthrough
+            }
+        }
+        process.stdout.write(out + "\n");
         try {
             const msg = JSON.parse(line);
             if (msg?.id !== undefined && pending.has(msg.id)) {

package/package.json

@@ -1,43 +1,46 @@
-{
-  "name": "lowdown-proxy",
-  "version": "0.1.14",
-  "mcpName": "io.github.PetShopBros/lowdown-proxy",
-  "description": "Record and query AI agent/tool/service interactions. Shared interaction history for the multi-agent ecosystem.",
-  "type": "module",
-  "bin": {
-    "lowdown-proxy": "dist/cli.js",
-    "lowdown-mcp": "dist/mcp-server.js"
-  },
-  "main": "./dist/cli.js",
-  "files": [
-    "dist"
-  ],
-  "scripts": {
-    "build": "tsc",
-    "dev": "tsx src/cli.ts"
-  },
-  "keywords": [
-    "mcp",
-    "ai-agent",
-    "reputation",
-    "interaction",
-    "proxy",
-    "trust",
-    "lowdown"
-  ],
-  "license": "MIT",
-  "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.0.0",
-    "@supabase/supabase-js": "^2.45.0",
-    "@vercel/node": "^3.0.0",
-    "zod": "^3.25.76"
-  },
-  "devDependencies": {
-    "@types/node": "^22.20.4",
-    "tsx": "^4.16.0",
-    "typescript": "^5.5.0"
-  },
-  "engines": {
-    "node": ">=18"
-  }
-}
+{
+  "name": "lowdown-proxy",
+  "version": "0.1.16",
+  "mcpName": "io.github.PetShopBros/lowdown-proxy",
+  "description": "Record and query AI agent/tool/service interactions. Shared interaction history for the multi-agent ecosystem.",
+  "type": "module",
+  "bin": {
+    "lowdown-proxy": "dist/cli.js",
+    "lowdown-mcp": "dist/mcp-server.js"
+  },
+  "main": "./dist/cli.js",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsx src/cli.ts",
+    "scanner:typecheck": "tsc -p scanner",
+    "scanner:test": "node --test scanner/lib.test.ts scanner/reputation.test.ts scanner/report.test.ts",
+    "scanner:dry": "node scanner/scan.ts --dry-run --limit=30"
+  },
+  "keywords": [
+    "mcp",
+    "ai-agent",
+    "reputation",
+    "interaction",
+    "proxy",
+    "trust",
+    "lowdown"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "@supabase/supabase-js": "^2.45.0",
+    "@vercel/node": "^3.0.0",
+    "zod": "^3.25.76"
+  },
+  "devDependencies": {
+    "@types/node": "^22.20.4",
+    "tsx": "^4.16.0",
+    "typescript": "^5.5.0"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}