stacktrace-cli 0.2.1__tar.gz → 0.2.2__tar.gz

{stacktrace_cli-0.2.1 → stacktrace_cli-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: stacktrace-cli
-Version: 0.2.1
+Version: 0.2.2
 Summary: CLI for Stacktrace — Detection and Response platform for AI Agents.
 Project-URL: Homepage, https://stacktrace.ai
 Author-email: "Stacktrace AI, Inc" <founders@stacktrace.ai>

stacktrace_cli-0.2.2/docs/adrs/0028-the-console-shows-what-it-placed.md

@@ -0,0 +1,108 @@
+---
+id: 0028
+title: The console shows what it placed, and states no coverage
+status: accepted
+date: 2026-09-08
+supersedes: null
+superseded-by: null
+amends: null
+amended-by: null
+---
+
+## Context
+
+A reader opened `stacktrace monitor` on their own machine and asked why the
+busiest row on the page was red. The row was the grouped built-in row for one
+project — 4,467 calls over five days — and it carried `⚠ 16 refusals`. All 16
+were `user-rejected` in the transcript, and their recorded reasons were the
+Bash gate rather than a person: 29 `contains multiple operations`, 28 `requires
+approval`, 6 `changes directory before running git`, 3 `brace with quote
+character (expansion obfuscation)`, 2 `parser aborted`, 1 `contains
+for_statement` across the project's 70 denials. Nothing reached a tool.
+
+`sessions/outcome.py` already states the rule: *a denied call reached nothing,
+so it is evidence of nothing* — written after six sites had each grown their own
+`status == "rejected"` test. The page took that rule for its counters and then
+painted the row red anyway, which reports the permission prompt as the
+incident. ADR-0025 left this open deliberately: its Consequences name "a second
+counter every activity read surface must decide whether to show".
+
+The same page led with `⚠ unresolved` rows, an `Unresolved` row in the overview
+table, a legend line, and a `6,867/7,055 placed` header fraction. `unresolved`
+is a fact about the *record*, with four causes the reader cannot distinguish and
+none of which they can act on: absent from the composition, no composition for
+that agent kind, an ambiguous match, or a matched component whose type the
+category map does not know. The row names no component — `classify_call`
+returns no name for it by design (ADR-0027 admits a name at one position, and an
+activity row is not one) — so what reached the reader was "something happened
+and nothing here claims it", set in the page's warning colour.
+
+The rule that would have made such a call actionable, `unsanctioned-mcp-tool-use`,
+was withdrawn by ADR-0015. So no live rule is about an unplaceable call, and the
+page was warning about something it could not then explain.
+
+## Decision
+
+The console renders only activity it could place, and states no coverage
+figure. Rows whose category is `unresolved` are dropped at the page boundary;
+the `N/M placed` fraction and its `placing…` placeholder are gone from the
+header, which now counts sessions and the actions it actually shows; a refusal
+is counted in a row's `×N` and carries no badge and no colour; the
+no-composition banner is gone, leaving the two banners that report a *reader*
+which came back with nothing.
+
+The snapshot contract does not change. `_activity` still emits unresolved rows,
+`summary.coverage` and each session's `coverage` are still computed and still
+sent, `activity_for_upload` and the `denied` counter are untouched, and every
+detector rule reads what it always read. `stacktrace correlate` remains the
+surface where coverage and unplaceability are the subject; ADR-0026's clause
+holds, because a page that shows less has still invented nothing.
+
+## Alternatives considered
+
+- **Filter in `_activity`, server-side** — rejected. The snapshot is also the
+  `/api/state` contract and the thing `tests/monitor/test_render.py` holds; a
+  page decision that narrows the record makes the two disagree, and the next
+  surface built on the snapshot would inherit a filter it never asked for.
+- **Keep the rows, drop only the warning framing** — rejected by the person the
+  page is for. Neutral wording does not give the row a subject: with no
+  component name there is nothing for a reader to look up, so a quiet row is
+  the same non-answer in a calmer colour.
+- **Keep the coverage fraction** — rejected. The gap between numerator and
+  denominator *is* the count of rows the page no longer shows, so the header
+  restated by arithmetic exactly what the feed had stopped saying.
+- **Keep the red on refusals alone** — rejected. It is the page asserting the
+  opposite of `outcome.py`'s rule about the same call, and the measured reasons
+  above are a guardrail working, not an endpoint under attack.
+- **Reword the no-composition banner rather than remove it** — rejected after
+  trying it. "No Agent BOM found, so its components are not identified" is the
+  same claim one step back, and it sends a reader looking for rows that are no
+  longer there.
+
+## Consequences
+
+The page stops answering one question it used to answer badly: how much of the
+window it could not attribute. A reader who wants that runs `stacktrace
+correlate`, where the figure is the subject and the four causes are named
+separately; the fleet still receives it, because the upload path is untouched.
+
+The costs are real and worth naming. An agent kind with no Agent BOM now shows
+fewer categories in the overview table and says nothing about why — the built-in
+preview rows still appear, so the page does not go blank, but the absence is
+silent. A responder cannot see from the console that an MCP call went to a
+server no scan can find. And a denied-heavy endpoint — ADR-0025's own example of
+a fact visible on no surface — is still visible on none.
+
+**Watch for:** a second page-side filter added the same way, without an ADR,
+because this one made it look routine; and the header regaining any derived
+ratio, which is the shape this decision removed.
+
+## When to revisit
+
+If ADR-0015's `unsanctioned-mcp-tool-use` returns, revisit immediately: its
+evidence is exactly the rows this decision hides, and a finding whose subject
+cannot be seen on the page it is reported on is worse than either state alone.
+Also if the console gains an affordance for *why something is missing* — a
+per-kind detail view, say — which is where the coverage figure and the four
+causes belong, or if a remote surface starts reading the local snapshot and
+assuming the page's filtering rather than the record's contents.

{stacktrace_cli-0.2.1 → stacktrace_cli-0.2.2}/docs/adrs/INDEX.md

@@ -60,3 +60,4 @@ supersedes anything yet.
 - [0026](0026-the-console-becomes-a-product-surface.md) — **The console becomes a product surface, served by the engine.** Supersedes ADR-0008 on its own stated condition: the engine came first, 0.1.0 shipped, and the data is only useful if a person can follow it. `stacktrace monitor` serves a loopback page from in-process calls, so the wheel now carries a `site/` asset — the cost 0008 refused, accepted here explicitly. What survives from 0008 is the clause that matters: the console renders and never computes, so a finding on the page is one `detect` would print. Read before adding anything to the console that the detector does not produce.
 - [0025](0025-a-denied-call-is-activity-never-an-invocation.md) — **A denied call is activity, and never an invocation.** ADR-0017 makes a declined repeat a stall while `outcome.py` keeps a denied call out of every count, so a denied-only session produced a finding with no activity and the Cloud rejected the whole run; a separate `denied` counter resolves it without either rule bending, and coverage keeps summing `invocations` alone. Read before changing what `activity[]` counts, or before folding `denied` into a coverage-like ratio.
 - [0027](0027-a-finding-may-name-what-it-could-not-place.md) — **A finding may name the component it could not place.** Narrows ADR-0006 constraint 3 for one field: an unplaced subject carries the name the session addressed it by, never as an identity. Read before removing a name from a finding on trust-boundary grounds, or before widening this to a second field.
+- [0028](0028-the-console-shows-what-it-placed.md) — **The console shows what it placed, and states no coverage.** Unplaceable rows, the `N/M placed` header fraction and the red on refusals are gone from `stacktrace monitor`: an unplaced row names no component, and `outcome.py`'s rule about a denied call makes reddening one the page contradicting its own counters. The snapshot contract, the upload and every rule are unchanged. Read before adding a page-side filter, before restoring a coverage ratio to the console, or if `unsanctioned-mcp-tool-use` returns.

stacktrace_cli-0.2.2/docs/releases/v0.2.2.md

@@ -0,0 +1,76 @@
+# 0.2.2 — what the console shows
+
+`stacktrace monitor` shipped in 0.2.0 with two kinds of warning on it, and this
+release removes both. Neither pointed at something a reader could act on: one
+marked a call the correlator could not attribute, which names no component by
+design, and the other marked a call a permission prompt had already blocked.
+The engine is untouched — no rule, payload field, command or output shape
+moves — and the whole delta is what one page renders.
+
+## Highlights
+
+- **A blocked call is no longer an alarm.** A refusal is counted in its row's
+  `×N` and says nothing more: no `⚠ N refusals` badge, no red row. On the
+  machine that prompted this, 16 declined `Bash` calls out of 4,467 turned the
+  busiest row on the page red — and all 16 were the Bash gate refusing a
+  compound command, a `cd` before `git`, or an obfuscated brace. Nothing
+  reached a tool. `sessions/outcome.py` has held since 0.1.0 that a denied call
+  reached nothing, so it is evidence of nothing; the page took that rule for
+  its counters and then reddened the row anyway, which reports the permission
+  prompt as the incident. ADR-0025 left this to each surface deliberately, and
+  the console now answers it.
+
+- **The console shows only activity it could place.** The `⚠ unresolved` rows,
+  the `Unresolved` row in the overview table and the legend line describing
+  them are gone. An unplaced row carries no component name — that is a design
+  constraint, not an omission (ADR-0027 admits a name at one position, and an
+  activity row is not one) — so what reached the reader was "something happened
+  and nothing here claims it", with four causes behind it they could not
+  distinguish and none they could act on. The rule that would have made such a
+  call actionable was withdrawn by ADR-0015, so nothing on the page could
+  explain the warning it was showing.
+
+- **The header states no coverage figure.** `6,867/7,055 placed` and the
+  `placing…` placeholder it used while correlation ran are both gone: the gap
+  between those two numbers *is* the count of rows the page withholds, so the
+  header restated by arithmetic exactly what the rows had stopped saying. It
+  now reports sessions and the actions it actually shows — previously it read
+  `summary.actions`, the total over every call in the window, and so claimed
+  more actions than the feed below it could account for.
+
+- **A legend line that described nothing.** `✓ resolved to something you
+  installed` is removed. The page has never drawn that checkmark: the glyph
+  appeared in the legend and in no row, summary or card.
+
+- **The decision is recorded rather than implied.** ADR-0028 states it, lists
+  the five alternatives and is explicit about the costs — an agent kind with no
+  Agent BOM is now silent on the page, and ADR-0025's denied-heavy endpoint is
+  still visible on no surface. `docs/specs/monitor.md` said the opposite in four
+  places and now describes what ships.
+
+## Install
+
+`uv tool install stacktrace-cli==0.2.2` or `pip install stacktrace-cli==0.2.2`.
+
+## Compatibility
+
+Nothing to do, and nothing outside the console changes. `stacktrace detect`,
+`stacktrace correlate` and `stacktrace sync detect` produce byte-identical
+output to 0.2.1, the upload payload is unchanged, and every detector rule reads
+what it always read. No finding is suppressed — ADR-0026's clause that the
+console renders and never judges still holds, and a page that shows fewer
+activity rows invents nothing.
+
+The `/api/state` document is also unchanged: it still carries the unplaced
+activity rows and both coverage figures. The filter is applied in the page, so
+anything reading that endpoint sees the same record 0.2.1 served.
+
+Two things you will notice if you relied on them. Coverage is no longer on the
+console — run `stacktrace correlate`, where it is the subject and the four
+causes of an unplaced call are named separately. And an agent kind with no
+Agent BOM no longer raises a banner: its built-in rows still appear, so the
+page does not go blank, but the absence is reported by `correlate` rather than
+on screen.
+
+Still pre-alpha, with no back-compat hedging: interfaces can change between
+releases without a deprecation window.

{stacktrace_cli-0.2.1 → stacktrace_cli-0.2.2}/docs/specs/monitor.md

@@ -141,8 +141,11 @@ An unplaced stage is honest in two specific ways, and both are load-bearing:
   property over the whole built-in vocabulary, not just the names a fixture
   uses.
 - **Coverage is `None`, not `0/0`.** Correlation computes coverage, so an
-  unplaced stage does not have it. `0/0` would read as *nothing placed* rather
-  than *not counted yet*; the header says `placing…` until it knows.
+  unplaced stage does not have it, and the snapshot says so rather than
+  claiming a figure. The page no longer renders one either way (ADR-0028): the
+  header counts sessions and the actions it shows, and the fraction — whose gap
+  was the count of rows the page withholds — is gone, along with the `placing…`
+  placeholder that stood in for it.
 
 Batches are then judged **newest first**, because someone watching a machine
 cares about what just happened and should not scroll for it. The last stage
@@ -185,10 +188,18 @@ name".** Routine built-ins — Bash, Read, Edit — are the constant background
 every session: 5,795 of one three-day window's 7,065 calls. They collapse **per
 project** into one counted row for the agent, which is what makes `Claude Code ·
 working — files, commands & searches · ×1,719` a line a person reads instead of
-1,719 lines they do not. Skills, MCP servers, sub-agents, commands and anything
-unresolved are rare and consequential, so each **call** keeps its own row, keyed
-by span and never coalesced: two runs of one skill are two things that happened.
-A three-day window is ~66 rows.
+1,719 lines they do not. Skills, MCP servers, sub-agents and commands
+are rare and consequential, so each **call** keeps its own row, keyed by span
+and never coalesced: two runs of one skill are two things that happened. A
+three-day window is ~66 rows.
+
+**A call correlation could not place gets no row at all** (ADR-0028). It names
+no component — `classify_call` returns no name for one by design — so the row
+could only say that something happened and nothing here claims it, which is not
+a thing a reader can act on, and the rule that would have made it actionable
+was withdrawn by ADR-0015. The rows are dropped at the page boundary and
+nowhere else: `_activity` still emits them, and `stacktrace correlate` still
+reports them with each of the four causes named.
 
 **The summary's "Most used" column names the top three, and says what it left
 out.** A truncated list beside a total reads as a breakdown, and then the
@@ -207,8 +218,13 @@ exactly the terms the component name is: an ambiguous match names no alias,
 because printing the first candidate's configured name over the second's is the
 narrowing correlation refuses to do.
 
-A refusal rides the row it belongs to (`⚠ 90 refusals`) rather than taking one
-of its own, because `Bash ×3 denied` beside `Bash ×38` was half the noise.
+A refusal is counted in the row's `×N` and says nothing more (ADR-0028). It
+took neither a row of its own — `Bash ×3 denied` beside `Bash ×38` was half the
+noise — nor a badge and a colour, which is the page asserting the opposite of
+`outcome.py`'s rule about the same call: a denied call reached nothing, so it is
+evidence of nothing. On the machine that prompted this, 16 declined `Bash` calls
+out of 4,467 turned the busiest row on the page red, and all 16 were the Bash
+gate refusing a compound command.
 
 **Every panel is additive.** A stage re-sends every session and every finding
 the stages before it carried, so a render that replaced the columns threw away
@@ -399,7 +415,7 @@ only on click, so the ceiling is visible before it is hit.
 | No sessions on this machine | An empty page that **says so**. A blank column reads as a broken renderer |
 | A reader failed before correlation (`collection_failures`) | Rendered as a banner. A run that never got to look must not read as a clean one |
 | A session with no agent kind | Counted and named as unplaceable, never rendered under an invented kind |
-| A session with no composition | Rendered with every call unresolved and coverage low — not hidden |
+| A session with no composition | Its calls are read, and the page shows what it can place them to. Since ADR-0028 there is no banner and no coverage figure: the built-in preview rows still appear, and the absence itself is reported by `stacktrace correlate` rather than by the console |
 | The port is taken | Refuse with the port named, rather than silently choosing another and printing a URL the user did not expect |
 
 ## Files

{stacktrace_cli-0.2.1 → stacktrace_cli-0.2.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "stacktrace-cli"
-version = "0.2.1"
+version = "0.2.2"
 description = "CLI for Stacktrace — Detection and Response platform for AI Agents."
 readme = "README.md"
 requires-python = ">=3.11"

{stacktrace_cli-0.2.1 → stacktrace_cli-0.2.2}/src/stacktrace_cli/__init__.py

@@ -1,3 +1,3 @@
 """The `stacktrace` command-line interface — detection and response for AI agents."""
 
-__version__ = "0.2.1"
+__version__ = "0.2.2"

{stacktrace_cli-0.2.1 → stacktrace_cli-0.2.2}/src/stacktrace_cli/monitor/render.py

@@ -176,6 +176,12 @@ def _banners(analysis: Analysis) -> list[str]:
     A blank column and a clean run render identically, which is the one
     confusion this page refuses: a reader who cannot tell "nothing happened"
     from "nothing could be read" has been told nothing.
+
+    Both banners are about a *reader* that came back with nothing. A kind with
+    no composition is not one of those and no longer appears: the calls it
+    accounts for are read, and the page shows what it can place them to.
+    `view.without_composition` is still reported by `stacktrace correlate`,
+    where the record rather than the console is the subject.
     """
     banners: list[str] = []
     for failure in analysis.run.collection_failures:
@@ -183,8 +189,6 @@ def _banners(analysis: Analysis) -> list[str]:
     anonymous = len(analysis.view.kind_anonymous)
     if anonymous:
         banners.append(f"{anonymous} session(s) skipped: no agent kind to attribute them to")
-    for kind in analysis.view.without_composition:
-        banners.append(f"{kind}: no composition, so every call reads as unresolved")
     return banners
 
 

{stacktrace_cli-0.2.1 → stacktrace_cli-0.2.2}/src/stacktrace_cli/monitor/site/app.js

@@ -145,16 +145,20 @@ function renderBanners(banners) {
 
 function renderCounts(state) {
   const summary = state.summary || {};
-  /* Coverage is a fraction, never a bare percentage: 1 of 1 and 400 of 400 are
-   * both "100%" and say very different things about how much this page knows.
-   * And it is `null` until correlation has run, which is the first second or
-   * so — said as "placing…" rather than shown as 0/0, which would read as
-   * "nothing placed" instead of "not counted yet". */
-  const coverage = summary.coverage;
+  /* Sessions and actions, and no coverage fraction. `6,867/7,055 placed` is
+   * the count of what this page leaves off, stated: the gap between the two
+   * numbers is exactly the unplaceable rows, so the header reinstated by
+   * arithmetic what the rows below had stopped saying. The snapshot still
+   * carries it — `stacktrace correlate` is where coverage is the subject.
+   *
+   * Actions are counted off the rows this page keeps rather than read from
+   * `summary.actions`, which is the server's total over every call in the
+   * window. Read straight through, the header claimed more actions than the
+   * feed below it could account for. */
+  const actions = eventsFrom(state.sessions || []).length;
   text(el("live-counts"),
     " — " + plural(summary.sessions || 0, "session") +
-    " · " + plural(summary.actions || 0, "action") +
-    " · " + (coverage ? coverage.resolved + "/" + coverage.total + " placed" : "placing…"));
+    " · " + plural(actions, "action"));
 }
 
 /* --- the demo's vocabulary ----------------------------------------------- */
@@ -209,7 +213,6 @@ const RULE_PLAIN = {
   "stacktrace-credential-egress": "A password or token was sent to an outside service.",
   "stacktrace-capability-crossing": "Private data was read, then sent outside.",
   "stacktrace-intent-drift": "It acted on something nobody asked about.",
-  "stacktrace-unsanctioned-mcp-tool-use": "A tool ran that isn't in your installed set.",
   "stacktrace-guardrail-modification": "A session changed the agent's own rules or settings.",
   "stacktrace-injection-marker": "Injected-instruction markers were found in what the agent read.",
   "stacktrace-destructive-action": "A destructive action was taken (deleting or overwriting).",
@@ -227,20 +230,32 @@ const KIND_TAG = {
   subagent: ["sub-agent", "kt-sub"],
   mcp: ["mcp", "kt-conn"],
   command: ["command", "kt-cmd"],
-  unresolved: ["⚠ unresolved", "kt-warn"],
 };
 
 /* Plural, because every one of these labels a count. */
 const KIND_LABEL = {
   mcp: "MCP servers", skill: "Skills", command: "Commands",
-  subagent: "Sub-agents", tool: "Built-in tools", unresolved: "Unresolved",
+  subagent: "Sub-agents", tool: "Built-in tools",
 };
 
 /* Most consequential first, rather than by count: sorted by count the
  * built-ins win every window and push the MCP servers — the only category
  * describing a call that left the machine — under a number three orders of
  * magnitude larger. */
-const KIND_ORDER = ["mcp", "skill", "command", "subagent", "tool", "unresolved"];
+const KIND_ORDER = ["mcp", "skill", "command", "subagent", "tool"];
+
+/* The category the correlator gives a call it could not place. Every surface
+ * on this page drops these rows: an unplaceable call names no component, so
+ * the row could only say that something happened and nothing here claims it,
+ * which is not a thing a reader can act on. The count is still computed
+ * server-side and still reaches the detector — this is a decision about the
+ * page, not about the record. */
+const UNPLACEABLE = "unresolved";
+
+/* Whether the snapshot row is one of those. */
+function unplaceable(row) {
+  return row.category === UNPLACEABLE;
+}
 const TOP_PER_KIND = 3;
 
 const SEVERITY_WORD = { critical: "Serious", high: "High", medium: "Medium", low: "Low" };
@@ -294,10 +309,13 @@ function evParts(e) {
       provenance: "a link to an outside service",
     };
   }
+  /* A category this build has never heard of. Named as itself rather than
+   * described: anything else this function said about it would be invented,
+   * and the one category it used to describe no longer reaches the page. */
   return {
     name: e.name,
-    action: "used a tool nothing here claims",
-    provenance: "no component on this machine declares it",
+    action: "used " + (e.tool || "a tool"),
+    provenance: e.kind ? "category " + e.kind : "",
   };
 }
 
@@ -321,6 +339,7 @@ function eventsFrom(sessions) {
     const activity = session.activity || [];
     for (let index = 0; index < activity.length; index += 1) {
       const row = activity[index];
+      if (unplaceable(row)) continue;
       events.push({
         id: row.span,
         kind: row.category,
@@ -336,11 +355,6 @@ function eventsFrom(sessions) {
          * the skills a reader had just run sat under MCP calls from half a day
          * earlier. Named for what it is, because it is not the start. */
         at: session.last_active || session.started_at,
-        /* Both worth a reader's attention; only the first is a claim about
-         * attribution. Correlation keeps a refused call's resolution, so the
-         * row beside the label names the component it would have reached. */
-        unplaced: row.category === "unresolved",
-        refused: row.status === "denied",
         order: index,
       });
     }
@@ -356,7 +370,8 @@ function compositionOf(sessions) {
   const seen = new Set();
   for (const session of sessions) {
     for (const row of session.activity || []) {
-      const type = row.component_type || (row.category === "unresolved" ? null : row.category);
+      if (unplaceable(row)) continue;
+      const type = row.component_type || row.category;
       const key = type + "\n" + (row.component_identity || row.component_name || row.tool_name);
       if (!type || seen.has(key)) continue;
       seen.add(key);
@@ -372,6 +387,7 @@ function activitySummaryOf(sessions) {
   const named = {};
   for (const session of sessions) {
     for (const row of session.activity || []) {
+      if (unplaceable(row)) continue;
       byKind[row.category] = (byKind[row.category] || 0) + 1;
       if (!named[row.category]) named[row.category] = new Map();
       const label = entryLabel(row);
@@ -531,9 +547,9 @@ let revealTimer = null;
  * Routine built-ins (Bash, Read, Edit) are the constant background of every
  * session: 5,795 of one window's 7,065 calls. They collapse **per project**
  * into one counting row for the agent. Notable events — skills, MCP servers,
- * sub-agents, commands, and anything unresolved — are rare and important, so
- * each gets its own row, keyed by span and never coalesced: two runs of
- * `superpowers:brainstorming` are two things that happened.
+ * sub-agents and commands — are rare and important, so each gets its own row,
+ * keyed by span and never coalesced: two runs of `superpowers:brainstorming`
+ * are two things that happened.
  *
  * Grouping by tool name instead gave `Bash ×38 / Read ×16 / Bash ×3 / Edit
  * ×20` per session, with every skill and connector buried under it. */
@@ -609,14 +625,6 @@ function countAgain(entry, e) {
       entry.timeEl.textContent = fmtRange(entry.first, entry.last);
     }
   }
-  /* A refusal is worth seeing and was not worth a row of its own: `Bash ×3
-   * denied` beside `Bash ×38` was half the noise. It rides the row instead. */
-  if (e.refused) {
-    entry.refused += 1;
-    entry.node.classList.add("warn");
-    entry.warnEl.hidden = false;
-    entry.warnEl.textContent = "⚠ " + plural(entry.refused, "refusal");
-  }
   /* Animated where it sits, never hoisted. Hoisting the most recently counted
    * row would rank a busy week-old session above a quiet one from this
    * morning: during a backfill, "counted just now" is a fact about the drain
@@ -656,14 +664,19 @@ function place(entry) {
 
 function newRow(e, signature) {
   const parts = evParts(e);
-  const kind = KIND_TAG[e.kind] || KIND_TAG.unresolved;
+  /* A category this build has never heard of takes its own name and the
+   * neutral tag: nothing on this page knows enough about it to warn. */
+  const kind = KIND_TAG[e.kind] || [e.kind || "", "kt-tool"];
   /* The placeholder goes as soon as there is a real row — otherwise it rides
    * the list and counts against the trim. */
   if (!feedOrder.length) activityFeed.innerHTML = "";
 
+  /* No row this feed builds is reddened. The two sources of it were a call
+   * the correlator could not place — which no longer reaches the feed — and a
+   * refusal, which `outcome.py` is explicit is a guardrail working as
+   * intended: painting it red reports the permission prompt as the incident. */
   const node = document.createElement("div");
   node.className = "ev fresh";
-  if (e.unplaced || e.refused) node.classList.add("warn");
 
   const countEl = element("span", "evcount", "");
   countEl.hidden = true;
@@ -674,16 +687,6 @@ function newRow(e, signature) {
   first.appendChild(element("span", "evact", parts.action));
   first.appendChild(countEl);
 
-  const warnEl = element("span", "ev-warn", "");
-  warnEl.hidden = true;
-  if (e.unplaced) {
-    warnEl.hidden = false;
-    warnEl.textContent = "unplaced";
-  } else if (e.refused) {
-    warnEl.hidden = false;
-    warnEl.textContent = e.kind === "tool" ? "⚠ 1 refusal" : "refused";
-  }
-
   const lastEl = element("span", "evlast", "");
   const timeEl = element("span", "ev-time", fmtAgo(e.at));
 
@@ -692,15 +695,14 @@ function newRow(e, signature) {
   second.appendChild(element("span", "ev-prov", parts.provenance));
   second.appendChild(lastEl);
   second.appendChild(timeEl);
-  second.appendChild(warnEl);
 
   node.appendChild(first);
   node.appendChild(second);
 
   const started = Date.parse(e.at);
   const entry = {
-    node: node, countEl: countEl, warnEl: warnEl, lastEl: lastEl, timeEl: timeEl,
-    count: 1, refused: e.refused ? 1 : 0, key: keyOf(e), signature: signature,
+    node: node, countEl: countEl, lastEl: lastEl, timeEl: timeEl,
+    count: 1, key: keyOf(e), signature: signature,
     first: Number.isNaN(started) ? Infinity : started,
     last: Number.isNaN(started) ? -Infinity : started,
   };

{stacktrace_cli-0.2.1 → stacktrace_cli-0.2.2}/src/stacktrace_cli/monitor/site/index.html

@@ -74,8 +74,6 @@
 
   <div class="legend" id="live-legend">
     <span><b class="lg-conn">MCP</b> = a link to an outside service</span>
-    <span><b class="lg-ok">&#10003;</b> resolved to something you installed</span>
-    <span><b class="lg-warn">&#9888;</b> unresolved &mdash; nothing on this machine claims it</span>
   </div>
 
   <div class="logs">

{stacktrace_cli-0.2.1 → stacktrace_cli-0.2.2}/tests/monitor/feed_harness.mjs

@@ -290,9 +290,11 @@ const scenarios = {
     };
   },
 
-  /* A refused built-in is a signal, but a row of its own for it was noise. It
-   * is counted with the rest and the row says how many were refused. */
-  refused_built_ins_are_counted_on_the_row_not_split_out() {
+  /* A refusal is the permission prompt working, not an incident: `outcome.py`
+   * refuses to treat a denied call as evidence of anything, and the page must
+   * not treat it as an alarm either. It is counted with the rest of the
+   * project's built-ins, and that is all the row says about it. */
+  a_refusal_is_counted_on_the_row_and_never_marked() {
     const feed = instance();
     feed.renderActivity([session("a", [
       ...repeat(10, {}),
@@ -318,10 +320,11 @@ const scenarios = {
     return { name: row.name, text: row.text, kind: row.kind };
   },
 
-  /* `unplaced` is a claim about attribution, and denial is not one:
-   * correlation keeps a refused call's resolution, so the row names what it
-   * would have reached. */
-  an_unresolved_call_is_labelled_unplaced_and_a_refusal_is_not() {
+  /* A call correlation could not place names no component, so there is nothing
+   * on the row for a reader to act on: it is left off the feed rather than
+   * shown as a warning. The denied MCP call beside it *is* placed, so it
+   * stays — and stays unmarked. */
+  an_unresolved_call_never_reaches_the_feed() {
     const feed = instance();
     feed.renderActivity([session("a", [
       mcp("support", "open_ticket", { status: "denied" }),
@@ -329,8 +332,27 @@ const scenarios = {
     ])]);
     feed.tick(10);
     const rows = feed.rows();
-    return { labels: rows.map((r) => r.label), warned: rows.map(
-      (r) => r.className.split(" ").includes("warn")) };
+    return {
+      names: rows.map((r) => r.name),
+      labels: rows.map((r) => r.label),
+      warned: rows.map((r) => r.className.split(" ").includes("warn")),
+    };
+  },
+
+  /* Nothing this feed builds is painted red. Refusals and unplaceable calls
+   * were the only two sources of it, and asked about every row rather than the
+   * two that carried it: a third source would otherwise arrive unnoticed. */
+  no_row_the_feed_builds_is_reddened() {
+    const feed = instance();
+    feed.renderActivity([session("a", [
+      ...repeat(6, {}),
+      ...repeat(2, { status: "denied" }),
+      mcp("support", "open_ticket", { status: "denied" }),
+      skill("code-review", { status: "denied" }),
+      call({ category: "unresolved", component_name: null, tool_name: "mystery_tool" }),
+    ])]);
+    feed.tick(40);
+    return { classes: feed.rows().map((r) => r.className) };
   },
 
   /* Pacing: distinct rows arrive one tick at a time. */
@@ -509,6 +531,26 @@ const scenarios = {
     return { count: feed.rows()[0].count, time: cell("ev-time"), last: cell("evlast") };
   },
 
+  /* The header counts what the page shows. `summary.actions` is the server's
+   * own total and includes the calls this page leaves off, so reading it left
+   * the header claiming more actions than the feed could account for. */
+  the_header_counts_only_the_actions_the_page_shows() {
+    const feed = instance();
+    feed.render({
+      summary: { sessions: 1, actions: 5, coverage: { total: 5, resolved: 3 } },
+      sessions: [session("a", [
+        skill("code-review"),
+        mcp("github", "create_pull_request"),
+        call({}),
+        call({ category: "unresolved", component_name: null, tool_name: "one" }),
+        call({ category: "unresolved", component_name: null, tool_name: "two" }),
+      ])],
+      alerts: [], banners: [], escalate: {},
+    });
+    feed.tick(10);
+    return { header: feed.dom("live-counts").textContent };
+  },
+
   /* The alias is the name in the reader's own `.mcp.json`; the package name is
    * what got installed under it. Only one is the word they recognise. */
   a_row_leads_with_the_alias_not_the_package_name() {
@@ -707,11 +749,19 @@ const scenarios = {
   /* Coverage is what correlation computes, and correlation is the slow part.
    * The header therefore has a real session and action count a second before
    * it has a coverage fraction. */
-  the_header_says_placing_until_coverage_is_known() {
-    const feed = instance();
+  the_header_never_shows_a_coverage_fraction() {
+    const feed = instance();
+    /* The rows are built rather than asserted through `summary.actions`: the
+     * header counts what the page shows, so a fixture that carries the total
+     * and no rows tests the fixture. 82 sessions holding 6,995 calls between
+     * them, which is the window this was measured on. */
+    const sessions = [];
+    for (let i = 0; i < 82; i += 1) {
+      sessions.push(session("s" + i, repeat(i === 81 ? 6995 - 81 * 85 : 85, {})));
+    }
     const state = (coverage) => ({
       summary: { sessions: 82, actions: 6995, coverage },
-      sessions: [], alerts: [], banners: [], escalate: {},
+      sessions: sessions, alerts: [], banners: [], escalate: {},
     });
     feed.render(state(null));
     const during = feed.dom("live-counts").textContent;