stacktrace-cli 0.2.2__py3-none-any.whl → 0.3.0__py3-none-any.whl

stacktrace_cli/monitor/server.py

@@ -76,7 +76,7 @@ class MonitorConfig:
     #: Minted per run. The page receives it in the URL monitor opens and echoes
     #: it on the one request that spends money.
     token: str = field(default_factory=lambda: secrets.token_urlsafe(16))
-    escalate: bool = False
+    reasoning: bool = False
     budget: int = 10
 
 
@@ -87,7 +87,7 @@ def _asset(name: str) -> bytes:
 def build_server(
     store: StateStore,
     config: MonitorConfig,
-    escalator: Any = None,
+    runner: Any = None,
     set_window: Callable[[str], None] | None = None,
 ) -> ThreadingHTTPServer:
     """Bind and return the server, or raise saying why it could not.
@@ -150,25 +150,25 @@ def build_server(
             if path == "/api/window":
                 self._window()
                 return
-            if path != "/api/escalate":
+            if path != "/api/reasoning":
                 # One POST route exists. Without this check a typo — `POST /`,
-                # `POST /api/escalte` — reaches the escalator and spends a unit
+                # `POST /api/reasonin` — reaches the runner and spends a unit
                 # of budget on a route that was never registered.
                 self.send_error(404)
                 return
-            if not config.escalate or escalator is None:
+            if not config.reasoning or runner is None:
                 # Not 403: without the flag this endpoint does not exist, and
                 # saying "forbidden" would advertise a feature that is off.
                 self.send_error(404)
                 return
-            refusal = _refuse_escalation(self, config)
+            refusal = _refuse_reasoning(self, config)
             if refusal is not None:
                 # 403 and no decrement: a refused request never spends.
                 self._json(
                     {
                         "accepted": False,
                         "reason": refusal,
-                        "remaining": escalator.remaining(),
+                        "remaining": runner.remaining(),
                     },
                     status=403,
                 )
@@ -182,30 +182,30 @@ def build_server(
                     {
                         "accepted": False,
                         "reason": "malformed request body",
-                        "remaining": escalator.remaining(),
+                        "remaining": runner.remaining(),
                     },
                     status=400,
                 )
                 return
-            accepted, reason = escalator.request(session_id)
-            self._json({"accepted": accepted, "reason": reason, "remaining": escalator.remaining()})
+            accepted, reason = runner.request(session_id)
+            self._json({"accepted": accepted, "reason": reason, "remaining": runner.remaining()})
 
         def _window(self) -> None:
             """Re-run the pipeline over a different window.
 
-            Gated exactly as `/api/escalate` is. It spends no budget, but it
+            Gated exactly as `/api/reasoning` is. It spends no budget, but it
             makes this process walk every transcript on the machine again, and
             the origin check is what stops any page in this browser from
             driving that -- a remote page cannot forge `Origin` though it could
             guess the port.
             """
             if set_window is None:
-                # 404 rather than 403, for `/api/escalate`'s reason: without a
+                # 404 rather than 403, for `/api/reasoning`'s reason: without a
                 # watcher to re-run there is no such route, and "forbidden"
                 # would advertise a feature that is not there.
                 self.send_error(404)
                 return
-            refusal = _refuse_escalation(self, config)
+            refusal = _refuse_reasoning(self, config)
             if refusal is not None:
                 self._json({"accepted": False, "reason": refusal}, status=403)
                 return
@@ -271,7 +271,7 @@ def _since(query: str) -> int:
     return 0
 
 
-def _refuse_escalation(handler: BaseHTTPRequestHandler, config: MonitorConfig) -> str | None:
+def _refuse_reasoning(handler: BaseHTTPRequestHandler, config: MonitorConfig) -> str | None:
     """Why this POST may not spend money, or None if it may.
 
     Origin first, because it is the gate that stops the attacker the token
@@ -292,7 +292,7 @@ def serve(
     host: str = "127.0.0.1",
     port: int = 0,
     interval: float = 4.0,
-    escalate: bool = False,
+    reasoning: bool = False,
     budget: int = 10,
     open_browser: bool = True,
     echo: Any = print,
@@ -305,12 +305,12 @@ def serve(
     exists means there is nothing to unwind.
     """
     from stacktrace_cli.detector.cache import default_directory
-    from stacktrace_cli.monitor.escalate import Escalator
+    from stacktrace_cli.monitor.reasoning import ReasoningRunner
     from stacktrace_cli.monitor.state import Snapshot, StateStore
     from stacktrace_cli.monitor.verdicts import RetainedVerdicts
     from stacktrace_cli.monitor.watch import Watcher
 
-    config = MonitorConfig(host=host, port=port, escalate=escalate, budget=budget)
+    config = MonitorConfig(host=host, port=port, reasoning=reasoning, budget=budget)
     store = StateStore(
         Snapshot(
             revision=0,
@@ -319,8 +319,8 @@ def serve(
         )
     )
 
-    escalator: Escalator | None = None
-    # One cache for both, not one each: an escalation's verdict has to be
+    runner: ReasoningRunner | None = None
+    # One cache for both, not one each: a reasoning run's verdict has to be
     # readable by the pass that renders it, and what this process paid for is
     # held in memory rather than on the disk two instances would share.
     verdicts = RetainedVerdicts(default_directory())
@@ -328,13 +328,15 @@ def serve(
         store,
         options=_watcher_options(config, options, verdicts),
         interval=interval,
-        escalate_state=lambda: escalator.state() if escalator else {"enabled": False},
+        reasoning_state=lambda: runner.state() if runner else {"enabled": False},
     )
-    if escalate:
-        escalator = Escalator(
+    if reasoning:
+        runner = ReasoningRunner(
             store=store,
             budget=budget,
-            run=lambda session_id: _escalate_one(session_id, options, verdicts, watcher.invalidate),
+            run=lambda session_id: _reason_about_one(
+                session_id, options, verdicts, watcher.invalidate
+            ),
             note=watcher.note,
         )
 
@@ -342,15 +344,15 @@ def serve(
     # here rather than passed into `Watcher`: the server drives the watcher,
     # never the reverse, and a watcher that could serve would be two owners of
     # one loop.
-    httpd = build_server(store, config, escalator=escalator, set_window=watcher.set_window)
+    httpd = build_server(store, config, runner=runner, set_window=watcher.set_window)
     _thread, stop = watcher.start()
 
     url = f"http://{_authority(config.host, httpd.server_address[1])}/?token={config.token}"
     echo(f"stacktrace monitor on {url}")
     echo("Press Ctrl-C to stop.")
-    if escalate:
+    if reasoning:
         echo(
-            f"--escalate is on: this page can spend your provider quota, "
+            f"--reasoning is on: this page can spend your provider quota, "
             f"{budget} session(s) at most."
         )
     if open_browser:
@@ -403,14 +405,14 @@ def _watcher_options(
     return {
         **options,
         # Read on every pass and written on none: a verdict an earlier
-        # `detect --escalate` paid for is an answer this machine already has,
+        # `detect --reasoning` paid for is an answer this machine already has,
         # and a page that made you buy it again would be the opposite of
         # "free to leave open".
         "cache": verdicts,
     }
 
 
-def _escalate_one(
+def _reason_about_one(
     session_id: str,
     options: JsonObject,
     cache: VerdictCache,
@@ -419,7 +421,7 @@ def _escalate_one(
     """Run stage 3 for the named session, and say what went unanswered.
 
     The id is a *selector*, not a label. `budget=1` alone would spend the unit
-    on whichever escalation the detector ranks first, which on a busy machine
+    on whichever request the detector ranks first, which on a busy machine
     is routinely not the one the person confirmed — so the window is narrowed
     to this session before stage 3 can choose.
 
@@ -434,16 +436,16 @@ def _escalate_one(
     ordinary `Unknown` *values* rather than exceptions, and an outcome holding
     one is deliberately never cached — so the next pass reconstructs the
     session as merely not-requested and the reason the paid run failed is gone.
-    It is returned instead, and the escalator says it on the page.
+    It is returned instead, and the runner says it on the page.
     """
     from stacktrace_cli.analysis import analyse
 
     analysis = analyse(
         **options,
         session_ids=(session_id,),
-        escalate=True,
+        reasoning=True,
         # One session's worth. The page's own budget is what bounds the run;
-        # this bounds the single escalation it just authorised.
+        # this bounds the single reasoning run it just authorised.
         budget=1,
         cache=cache,
     )
@@ -453,7 +455,7 @@ def _escalate_one(
         # written, so there is nothing to re-read — but the unit is spent, and a
         # click that leaves neither an answer nor a reason reads as a dead page.
         return (
-            f"escalating {session_id} found nothing to analyse: the session is no "
+            f"reasoning about {session_id} found nothing to analyse: the session is no "
             "longer on this machine"
         )
     invalidate()
@@ -465,7 +467,7 @@ def _unanswered(session_id: str, unknowns: Sequence[Any]) -> str | None:
 
     The stage matters: a session can carry a `low_coverage` or `truncated`
     unknown from stages one and two on every pass, and repeating those on a
-    click would report a standing condition as this escalation's outcome.
+    click would report a standing condition as this run's outcome.
 
     Reasons, never an unknown's `detail` — the closed vocabulary says which
     kind of failure this was, which is what a banner is for, and the detail
@@ -474,4 +476,4 @@ def _unanswered(session_id: str, unknowns: Sequence[Any]) -> str | None:
     reasons = sorted({u.reason for u in unknowns if u.stage == "reasoning"})
     if not reasons:
         return None
-    return f"escalating {session_id} left a question unanswered: {', '.join(reasons)}"
+    return f"reasoning about {session_id} left a question unanswered: {', '.join(reasons)}"

stacktrace_cli/monitor/site/app.js

@@ -88,7 +88,7 @@ function windowWidth(summary) {
  * that has been shown can be absent from what comes next. Choosing a narrower
  * range breaks that. Kept additively, the rows and cards of the wider range
  * would sit under a header and summaries that had already shrunk — and their
- * escalate buttons would name sessions the server no longer offers. */
+ * reasoning buttons would name sessions the server no longer offers. */
 function clearFeeds() {
   rowBySignature.clear();
   feedOrder.length = 0;
@@ -118,7 +118,7 @@ function render(state) {
   renderAlerts(state.alerts || []);
   /* Last, because it repaints the buttons on cards the line above may have
    * just added. */
-  renderEscalate(state.escalate || {});
+  renderReasoning(state.reasoning || {});
 }
 
 /* Write only when the markup actually differs.
@@ -844,42 +844,42 @@ function addAlert(alert, signature) {
     key: alertKeyOf(alert, signature),
   };
   placeAlert(entry);
-  paintEscalate(entry);
+  paintReasoning(entry);
   return entry;
 }
 
-/* --- escalation ---------------------------------------------------------- */
+/* --- reasoning ----------------------------------------------------------- */
 
-let escalateState = { enabled: false, remaining: 0, running: [] };
+let reasoningState = { enabled: false, remaining: 0, running: [] };
 let sessionsById = new Map();
 
-function renderEscalate(state) {
-  escalateState = Object.assign({ enabled: false, remaining: 0, running: [] }, state);
-  for (const entry of alertBySignature.values()) paintEscalate(entry);
+function renderReasoning(state) {
+  reasoningState = Object.assign({ enabled: false, remaining: 0, running: [] }, state);
+  for (const entry of alertBySignature.values()) paintReasoning(entry);
 }
 
-function paintEscalate(entry) {
-  entry.host.innerHTML = escalateButton(entry.sessionId);
+function paintReasoning(entry) {
+  entry.host.innerHTML = reasoningButton(entry.sessionId);
 }
 
-function escalateButton(sessionId) {
-  if (!escalateState.enabled || !sessionId) return "";
-  if ((escalateState.running || []).indexOf(sessionId) !== -1) {
+function reasoningButton(sessionId) {
+  if (!reasoningState.enabled || !sessionId) return "";
+  if ((reasoningState.running || []).indexOf(sessionId) !== -1) {
     return '<div class="al-lbl">analysing with a model...</div>';
   }
-  if (!escalateState.remaining) {
+  if (!reasoningState.remaining) {
     /* The ceiling is visible before it is hit, not only on the click that
      * finds it. */
-    return '<div class="al-lbl">escalation budget spent</div>';
+    return '<div class="al-lbl">reasoning budget spent</div>';
   }
-  return '<button class="escalate-btn" data-session="' + esc(sessionId) +
+  return '<button class="reasoning-btn" data-session="' + esc(sessionId) +
     '">Analyse with a model</button>';
 }
 
 /* The consent is the prompt, so it is spelled out rather than summarised: which
  * session, where the transcript goes, what it costs in time and money, what the
  * reader gets for it, and how much budget is left. */
-function escalatePrompt(sessionId) {
+function reasoningPrompt(sessionId) {
   return [
     "Analyse this session with a model?",
     "",
@@ -892,7 +892,7 @@ function escalatePrompt(sessionId) {
     "- Answers the three questions the other stages cannot: whether an injected",
     "  instruction was acted on, whether the agent drifted from the request, and",
     "  whether a completion claims work it did not do.",
-    "- " + escalateState.remaining + " escalation(s) left for this monitor session.",
+    "- " + reasoningState.remaining + " reasoning run(s) left for this monitor session.",
     "",
     "A session that has not changed since it was last analysed is answered from",
     "the local cache and costs nothing.",
@@ -916,13 +916,13 @@ function sessionIdentity(sessionId) {
 }
 
 document.addEventListener("click", async function (event) {
-  const button = event.target.closest(".escalate-btn");
+  const button = event.target.closest(".reasoning-btn");
   if (!button) return;
   const sessionId = button.dataset.session;
-  if (!window.confirm(escalatePrompt(sessionId))) return;
+  if (!window.confirm(reasoningPrompt(sessionId))) return;
   button.disabled = true;
   try {
-    const response = await fetch("/api/escalate", {
+    const response = await fetch("/api/reasoning", {
       method: "POST",
       headers: { "Content-Type": "application/json", "X-Stacktrace-Token": TOKEN },
       body: JSON.stringify({ session_id: sessionId }),
@@ -931,7 +931,7 @@ document.addEventListener("click", async function (event) {
     if (!body.accepted) {
       /* Say which gate refused, rather than leaving a dead button: a silent
        * no-op is indistinguishable from a broken page. */
-      window.alert(body.reason || "Escalation refused (HTTP " + response.status + ").");
+      window.alert(body.reason || "Reasoning refused (HTTP " + response.status + ").");
       button.disabled = false;
     }
   } catch (error) {

stacktrace_cli/monitor/site/index.html

@@ -72,15 +72,11 @@
     <span class="panel-note">read from this machine's own transcripts</span>
   </div>
 
-  <div class="legend" id="live-legend">
-    <span><b class="lg-conn">MCP</b> = a link to an outside service</span>
-  </div>
-
   <div class="logs">
     <section class="logcol">
       <header class="logcol-head">
         <span class="logcol-dot"></span>
-        <h3>Agent Session Log Trace</h3>
+        <h3>Agent Session Trace</h3>
         <span class="logcol-sub">every tool, skill &amp; connector your sessions used</span>
       </header>
       <div class="feed" id="activity"><div class="feed-empty">Watching for agent activity&hellip;</div></div>

stacktrace_cli/monitor/site/styles.css

@@ -294,11 +294,6 @@ body.watch-mode .hero, body.watch-mode .band, body.watch-mode .status, body.watc
 .comp-chip.hot { border-color:var(--coral); color:var(--coral-d); background:color-mix(in srgb,var(--coral) 6%,var(--paper)); }
 .comp-chip.hot b { color:var(--coral-d); }
 
-.legend { display:flex; gap:1.4rem; flex-wrap:wrap; margin:1rem 0 1.2rem; padding:0.6rem 0.9rem;
-  background:var(--panel); border:1px solid var(--line); border-radius:4px; font-size:0.74rem; color:var(--ink-dim); }
-.legend b { font-weight:700; }
-.lg-conn { color:var(--coral-d); } .lg-ok { color:var(--ok); } .lg-warn { color:var(--coral-d); }
-
 /* two continuous logs */
 .logs { display:grid; grid-template-columns:minmax(0,1.5fr) minmax(0,1fr); gap:1.2rem; align-items:start; }
 @media (max-width:860px){ .logs { grid-template-columns:1fr; } }
@@ -552,7 +547,7 @@ body.watch-mode .hero, body.watch-mode .band, body.watch-mode .status, body.watc
    
    Everything above this line is the console stylesheet as it stands; these are
    the few rules for elements only `stacktrace monitor` has — a banner for what
-   could not be read, the escalate button, and an empty overview row. They use
+   could not be read, the reasoning button, and an empty overview row. They use
    the tokens declared at the top rather than new colours, so the additions
    cannot drift from the palette they sit in.
    --------------------------------------------------------------------------- */
@@ -604,12 +599,12 @@ body.watch-mode .hero, body.watch-mode .band, body.watch-mode .status, body.watc
 .banner-warn { border-left:3px solid var(--coral); color:var(--ink); }
 .banner code { font-family:var(--mono); font-size:0.9em; }
 
-.escalate-btn { font-family:var(--mono); font-size:0.6rem; font-weight:700;
+.reasoning-btn { font-family:var(--mono); font-size:0.6rem; font-weight:700;
   letter-spacing:0.06em; text-transform:uppercase; cursor:pointer;
   margin-top:0.45rem; padding:0.3rem 0.6rem; border-radius:2px;
   border:1px solid var(--line-2); background:var(--panel); color:var(--ink-dim); }
-.escalate-btn:hover { border-color:var(--coral); color:var(--coral-d); }
-.escalate-btn:disabled { opacity:0.5; cursor:progress; }
+.reasoning-btn:hover { border-color:var(--coral); color:var(--coral-d); }
+.reasoning-btn:disabled { opacity:0.5; cursor:progress; }
 
 /* Spans, session ids and component coordinates are identifiers, not prose:
    they are compared character by character and wrap badly in a proportional

stacktrace_cli/monitor/state.py

@@ -31,7 +31,7 @@ class Snapshot:
     summary: JsonObject = field(default_factory=dict)
     sessions: list[JsonObject] = field(default_factory=list)
     alerts: list[JsonObject] = field(default_factory=list)
-    escalate: JsonObject = field(default_factory=dict)
+    reasoning: JsonObject = field(default_factory=dict)
     #: What the page must say out loud rather than leave to an empty column: a
     #: reader that failed, a session with no agent kind, a tick that raised.
     banners: list[str] = field(default_factory=list)
@@ -43,7 +43,7 @@ class Snapshot:
             "summary": self.summary,
             "sessions": self.sessions,
             "alerts": self.alerts,
-            "escalate": self.escalate,
+            "reasoning": self.reasoning,
             "banners": self.banners,
         }
 
@@ -65,7 +65,7 @@ class StateStore:
         as "nothing changed".
 
         It takes the previous snapshot for the same reason. A publisher that
-        changes one field — an escalation starting, a banner arriving — has to
+        changes one field — a reasoning run starting, a banner arriving — has to
         read the rest of the view from somewhere, and reading it with
         `current()` before calling this would let a tick land in between and be
         overwritten with its own predecessor.

stacktrace_cli/monitor/verdicts.py

@@ -1,11 +1,11 @@
 """The verdict cache a page reads, holding on to what this process paid for.
 
 Monitor reads the verdict cache and never writes it (ADR-0026, clause 2): a
-verdict on disk is one `detect --escalate` paid for, and a page left open must
+verdict on disk is one `detect --reasoning` paid for, and a page left open must
 not be able to touch it.
 
 That alone loses the answer a click just bought, because a page never sees the
-run's return value. An escalation's finding reaches the reader by being read
+run's return value. A reasoning run's finding reaches the reader by being read
 back out of the cache on the next pass — so with nothing between the two but a
 cache this side may not write, the finding is gone and a person spent a budget
 unit and provider quota for nothing.
@@ -31,7 +31,7 @@ class RetainedVerdicts(VerdictCache):
 
     def __init__(self, directory: Path, max_age_seconds: int = MAX_AGE_SECONDS) -> None:
         super().__init__(directory, max_age_seconds)
-        # Written by the escalation worker, read by the watcher thread: two
+        # Written by the reasoning worker, read by the watcher thread: two
         # threads by construction, unlike the single-threaded `detect` run the
         # base class was written for.
         self._lock = threading.Lock()

stacktrace_cli/monitor/watch.py

@@ -122,7 +122,7 @@ class Watcher:
         analyse_fn: Callable[..., Analysis] | None = None,
         stream_fn: Callable[..., Iterable[Analysis]] = analyse_progressively,
         advisory_hook: Callable[..., Any] | None = None,
-        escalate_state: Callable[[], JsonObject] | None = None,
+        reasoning_state: Callable[[], JsonObject] | None = None,
     ) -> None:
         self._store = store
         self._options = dict(options)
@@ -148,7 +148,7 @@ class Watcher:
         #: Held on the instance, not built per tick: the whole point is that it
         #: outlives one pass. A test asserts the identity is stable.
         self.advisory_hook = advisory_hook or advisory_attacher(_CachingAdvisoryLookup())
-        self._escalate_state = escalate_state or (dict)
+        self._reasoning_state = reasoning_state or (dict)
         self._fingerprint: _Fingerprint | None = None
         #: Whether anything has reached the page yet. Progressive publication
         #: exists for a page with nothing on it; once there is something, an
@@ -156,7 +156,7 @@ class Watcher:
         self._painted = False
         #: Said once, kept on every later pass. A pass rebuilds the page from
         #: its own analysis, and something that happened *between* passes — an
-        #: escalation that answered nothing — has no analysis to be rebuilt
+        #: reasoning run that answered nothing — has no analysis to be rebuilt
         #: from, so a message published on its own would be erased by the next
         #: tick rather than read.
         self._notices: list[str] = []
@@ -233,9 +233,9 @@ class Watcher:
     def invalidate(self) -> None:
         """Make the next tick re-run even though nothing on disk moved.
 
-        An escalation leaves a verdict in the cache, which is an input to the
+        A reasoning run leaves a verdict in the cache, which is an input to the
         pipeline the transcript fingerprint cannot see. Without this the page
-        would keep its pre-escalation snapshot until an agent happened to write
+        would keep its pre-reasoning snapshot until an agent happened to write
         something — so the answer a person just paid for would arrive whenever,
         or never.
         """
@@ -286,7 +286,7 @@ class Watcher:
                         snapshot_from(
                             found,
                             revision=revision,
-                            escalate=self._escalate_state(),
+                            reasoning=self._reasoning_state(),
                             last_active=_last_active(found, by_stem),
                         )
                     )
@@ -326,7 +326,7 @@ class Watcher:
             lambda previous, revision: replace(
                 previous,
                 revision=revision,
-                escalate=self._escalate_state(),
+                reasoning=self._reasoning_state(),
                 banners=[*previous.banners, message],
             )
         )

stacktrace_cli/remote/cli.py

@@ -350,14 +350,13 @@ def _mask_token(token: str) -> str:
     help="Use this Agent BOM instead of scanning for its kind.",
 )
 @click.option(
-    "--escalate/--no-escalate",
+    "--reasoning",
+    is_flag=True,
     default=False,
-    show_default=True,
-    help="Send flagged sessions to the agent's own CLI for semantic analysis. "
-    "Off by default here, the inverse of `stacktrace detect`: stage 3 spends "
-    "the developer's own provider quota and is the one stage that sends "
-    "session content off this machine, and an unattended run is the wrong "
-    "place for either to be implicit.",
+    help="Analyse flagged sessions with a reasoning model, run through the "
+    "agent's own CLI. Off by default: stage 3 spends the developer's own "
+    "provider quota and is the one stage that sends session content off this "
+    "machine, and an unattended run is the wrong place for either to be implicit.",
 )
 @click.option(
     "--budget",
@@ -409,7 +408,7 @@ def detect(
     agent_kinds: tuple[str, ...],
     since: str,
     bom_paths: tuple[Path, ...],
-    escalate: bool,
+    reasoning: bool,
     budget: int,
     sample_budget: int,
     cache: bool,
@@ -437,7 +436,7 @@ def detect(
         "bom_paths": bom_paths,
         "project_map": project_map,
         "root": root,
-        "escalate": escalate,
+        "reasoning": reasoning,
         "budget": budget,
         "sample_budget": sample_budget,
         "cache": cache,

stacktrace_cli/remote/sync_detect.py

@@ -131,7 +131,7 @@ def _collect_detect_run(
     bom_paths: tuple[Path, ...],
     project_map: tuple[str, ...],
     root: Path | None,
-    escalate: bool,
+    reasoning: bool,
     budget: int,
     sample_budget: int,
     cache: bool,
@@ -151,10 +151,16 @@ def _collect_detect_run(
             bom_paths=bom_paths,
             project_map=project_map,
             root=root,
-            escalate=escalate,
+            reasoning=reasoning,
             budget=budget,
             sample_budget=sample_budget,
-            cache=VerdictCache(default_directory()) if cache and escalate else None,
+            # Not gated on `reasoning`. A verdict already paid for is an answer
+            # this run has, and `reasoning` governs whether new ones may be
+            # commissioned, not whether old ones may be read -- the rule
+            # `run_detector` states at its cache pass. Gating it here made a
+            # scheduled run call a session ungraded that `stacktrace detect`
+            # calls graded, off the same cache and with neither one spending.
+            cache=VerdictCache(default_directory()) if cache else None,
         )
     except ValueError as error:
         raise SyncError(str(error)) from error
@@ -314,7 +320,7 @@ def sync_detect(
     bom_paths: tuple[Path, ...] = (),
     project_map: tuple[str, ...] = (),
     root: Path | None = None,
-    escalate: bool = False,
+    reasoning: bool = False,
     budget: int = 10,
     sample_budget: int = 0,
     cache: bool = True,
@@ -338,7 +344,7 @@ def sync_detect(
         bom_paths=bom_paths,
         project_map=project_map,
         root=root,
-        escalate=escalate,
+        reasoning=reasoning,
         budget=budget,
         sample_budget=sample_budget,
         cache=cache,
@@ -414,7 +420,7 @@ def build_detect_dry_run_payloads(
     bom_paths: tuple[Path, ...] = (),
     project_map: tuple[str, ...] = (),
     root: Path | None = None,
-    escalate: bool = False,
+    reasoning: bool = False,
     budget: int = 10,
     sample_budget: int = 0,
     cache: bool = True,
@@ -433,7 +439,7 @@ def build_detect_dry_run_payloads(
         bom_paths=bom_paths,
         project_map=project_map,
         root=root,
-        escalate=escalate,
+        reasoning=reasoning,
         budget=budget,
         sample_budget=sample_budget,
         cache=cache,

{stacktrace_cli-0.2.2.dist-info → stacktrace_cli-0.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: stacktrace-cli
-Version: 0.2.2
+Version: 0.3.0
 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>
@@ -126,14 +126,15 @@ because it is installed.
 ## What leaves your machine
 
 Two of `detect`'s three stages run entirely locally and need no model or
-credential. The third sends flagged sessions to the agent's *own* CLI — the
-provider that produced the transcript, never a different one — capped by
-`--budget`; `--no-escalate` turns it off and leaves the two local stages.
+credential, and they are the two a bare `detect` runs. The third sends flagged
+sessions to the agent's *own* CLI — the provider that produced the transcript,
+never a different one — and runs only when you pass `--reasoning`, capped by
+`--budget`.
 
 `sessions` omits prompts, tool arguments and results unless you pass
 `--include-content`. `monitor` binds to loopback only, refuses a non-loopback
-address rather than warning about it, and escalates nothing unless `--escalate`
-is given.
+address rather than warning about it, and analyses nothing with a model unless
+`--reasoning` is given.
 
 ## Status