plexora 0.0.35__tar.gz → 0.0.36__tar.gz

{plexora-0.0.35/plexora.egg-info → plexora-0.0.36}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plexora
-Version: 0.0.35
+Version: 0.0.36
 Summary: OpenSeadragon-based cellular image viewing and analysis tool.
 Author-email: BioCognia <support@biocognia.com>
 License-Expression: LicenseRef-Plexora-EULA-1.0

{plexora-0.0.35 → plexora-0.0.36}/plexora/agent/bridge_roles.py

@@ -151,6 +151,8 @@ def describe(capability) -> dict:
     The descriptor id is `plexora:<capability name>`; the tool name is what a
     peer calls (`POST /agent/v1/capabilities/<tool_name>`, or the MCP tool).
     """
+    from plexora.agent.schemas import compact_schema
+
     entitlement = capability.entitlement if capability.entitlement not in (None, "free") \
         else None
     return {
@@ -165,7 +167,9 @@ def describe(capability) -> dict:
         "execution": capability.execution,
         "viewer_required": bool(capability.viewer_required),
         "entitlement": entitlement,
-        "input_schema": capability.input_model.model_json_schema()
+        # What a peer shows a model: pydantic's schema less what says
+        # nothing to it (`schemas.compact_schema`); Plexora validates the call.
+        "input_schema": compact_schema(capability.input_model.model_json_schema())
         if capability.input_model else None,
         "version": capability.version,
         "tags": [str(tag) for tag in capability.tags],

{plexora-0.0.35 → plexora-0.0.36}/plexora/agent/render_spec.py

@@ -214,11 +214,12 @@ class RenderInput(ProjectInput):
                                            description="Regions to outline over the picture "
                                                        "(GeoJSON or boxes, full-resolution "
                                                        "pixels).")
+    #: Ones that cannot be drawn are listed in the manifest's not_rendered,
+    #: with the reason.
     layers: Literal["visible", "none"] | list[str] = Field(
         "visible", description="The scene's other layers to draw over the image: "
                                "'visible' (as the viewer shows them), 'none', or a list "
-                               "of layer ids. Ones that cannot be drawn are listed in "
-                               "the manifest's not_rendered, with the reason.")
+                               "of layer ids.")
     view: str | None = Field(
         None, max_length=48,
         description="For a z-stack (inspect_volume): which plane or projection to draw -- "

{plexora-0.0.35 → plexora-0.0.36}/plexora/agent/schemas.py

@@ -23,6 +23,62 @@ class AgentModel(BaseModel):
     model_config = ConfigDict(extra="forbid")
 
 
+def compact_schema(schema: Any) -> Any:
+    """An input model's JSON schema as a model is shown it, with what pydantic
+    adds that says nothing to the model taken out -- and nothing a call could
+    use: validation is the model's own, never this schema's.
+
+    - `title` on every property and model (the property's name already says it);
+    - an optional field's `anyOf: [X, {"type": "null"}]` with `default: null`
+      is X: leaving the field out is the null (a field whose default is not
+      null, or one that is required, keeps its null branch, which then means
+      something);
+    - a tagged union's `discriminator` mapping beside its `oneOf`: each branch
+      carries its tag as a `const`.
+
+    On render_region, whose options are nested models, about a fifth."""
+    if isinstance(schema, list):
+        return [compact_schema(item) for item in schema]
+    if not isinstance(schema, dict):
+        return schema
+    out = {}
+    for key, value in schema.items():
+        if key == "title" and isinstance(value, str):
+            continue
+        if key == "discriminator" and "oneOf" in schema:
+            continue
+        if key in _VALUES:
+            out[key] = value          # data, not schema: kept byte for byte
+        elif key in ("properties", "$defs", "definitions") and isinstance(value, dict):
+            required = set(schema.get("required") or ()) if key == "properties" else None
+            out[key] = {name: (_without_null(compact_schema(node))
+                               if required is not None and name not in required
+                               else compact_schema(node))
+                        for name, node in value.items()}
+        else:
+            out[key] = compact_schema(value)
+    return out
+
+
+#: Schema keywords whose value is data (a default, an example), never walked.
+_VALUES = ("default", "const", "enum", "examples", "required")
+
+
+def _without_null(node: Any) -> Any:
+    """An optional property's schema without its null branch, when null is
+    only its default (`compact_schema`)."""
+    if not isinstance(node, dict) or node.get("default", None) is not None:
+        return node
+    branches = node.get("anyOf")
+    if not isinstance(branches, list) or len(branches) != 2 or {"type": "null"} not in branches:
+        return node
+    other = next(b for b in branches if b != {"type": "null"})
+    rest = {k: v for k, v in node.items() if k not in ("anyOf", "default")}
+    if not isinstance(other, dict) or set(other) & set(rest):
+        return node
+    return {**other, **rest}
+
+
 def _trim(text: str, limit: int) -> str:
     """`text` cut to `limit` characters: at the last sentence end in the
     second half of the limit, else the last word, then an ellipsis."""
@@ -56,13 +112,14 @@ class NoInput(AgentModel):
 
 
 #: What a `qc` field says, wherever an estimate or a sample takes one
-#: (plexora/agent/cell_exclusions.py).
+#: (plexora/agent/cell_exclusions.py). Inside a gating session the session's
+#: own setting applies; no effect where QC was never run; `off` also when QC
+#: is suspected wrong.
 QC_FIELD_DESCRIPTION = (
-    "Which QC failures to leave out of this estimate, sample or picture (the gate itself "
-    "always applies to every cell). strict (the default): cells QC called exclude or warn, "
-    "and for this marker the cells QC flagged it unreliable in; exclude: warn calls kept; "
-    "off: QC ignored -- only when the user asks, or QC is suspected wrong. Inside a gating "
-    "session the session's own setting applies. No effect where QC was never run.")
+    "QC failures left out of this estimate, sample or picture (the gate still applies to "
+    "every cell). strict (default): cells QC called exclude or warn, and the cells QC "
+    "flagged this marker unreliable in; exclude: warn calls kept; off: QC ignored (only "
+    "when the user asks).")
 
 
 class QcInput(AgentModel):

{plexora-0.0.35 → plexora-0.0.36}/plexora/agent/sessions/tools.py

@@ -118,15 +118,20 @@ def status_input(limit_decisions):
                                     "mirror into (defaults to the one mirrored before).")
         pause: bool | None = Field(None, description="Pause (true) or resume (false) the "
                                                      "session.")
+        detail: Literal["brief", "full"] = Field(
+            "brief", description="brief: state, progress, counts, and the units still open "
+                                 "or left for a person, by state and why; full: every "
+                                 "unit's fields, the checks and scan, the residual, the "
+                                 "budget spent, mirroring, the delegate block, the "
+                                 "vocabulary and the reading guide.")
+        guide: bool = Field(False, description="Send the reading guide packets point into "
+                            "(`evidence.guide`, `answer_schema.see`): once, before you "
+                            "answer packets yourself.")
         known_guide: str | None = Field(None, description="The `guide_version` you hold: the "
                                         "reading guide is then not sent again.")
         units: Literal["open", "all"] = Field(
             "open", description="open: list only the units still to settle and those left "
                                 "for a person (the counts cover the rest); all: every unit.")
-        detail: Literal["brief", "full"] = Field(
-            "brief", description="brief: the units list capped (with a count of the rest), "
-                                 "the residual as its top rows plus totals, no strictness "
-                                 "table or vocabulary; full: all of it.")
         limits: dict[str, Literal[limit_decisions]] | None = Field(
             None, description="Answers to the session's limit questions (`requests` of a "
                               "`waiting_for_user` result), by unit: `continue` grants another "
@@ -249,6 +254,15 @@ class SessionTools:
         return {}
 
     def status_extra(self, engine, detail="brief") -> dict:
+        """More fields for the full status (`detail: full`)."""
+        return {}
+
+    def brief_unit(self, unit):
+        """What a brief status shows of one listed unit, under its id."""
+        return None
+
+    def brief_extra(self, engine) -> dict:
+        """More fields for the brief status (a workflow's checks, say)."""
         return {}
 
     def status_input_model(self):
@@ -567,6 +581,10 @@ class SessionTools:
                           paused=bool(inp.pause), paused_by="agent" if inp.pause else None)
             return {"session_id": inp.session_id, "paused": bool(inp.pause), "state": state,
                     "progress": progress}
+        # The reading guide (~20k characters) goes to a caller that asks for
+        # it -- one about to answer packets (`guide`), or the whole status --
+        # never to one asking how the session stands.
+        send_guide = inp.guide or inp.detail == "full"
         with self.engine_for(call, inp.session_id, st=st) as engine:
             record = engine.record
             if inp.reattach_viewer:
@@ -575,28 +593,34 @@ class SessionTools:
                                view_id=inp.view_id or mirror_.get("view_id"))
             replay = record.get("outstanding_packet") \
                 if inp.reattach_viewer and inp.replay_mirror else None
-            units = [self.unit_row(u) for u in self.listed_units(record, inp.units)]
-            shown, omitted = _capped(units, inp.units)
-            out = {"session_id": inp.session_id, "state": record["state"],
-                   "mode": record["options"]["mode"], "images": record["images"],
-                   "progress": engine.progress(), "units": shown,
-                   "units_omitted": omitted, "truncated": omitted > 0,
-                   "used": record.get("used"),
-                   "estimated_vision_tokens": budgets.vision_tokens(
-                       (record.get("used") or {}).get("pixels", 0)),
-                   "summary": self.summary_of(record),
-                   **self.guide(record["options"].get("reading"), inp.known_guide),
-                   "mirror": record.get("mirror"), "control": st.control(inp.session_id),
-                   "outstanding_packet": record.get("outstanding_packet"),
-                   "receipts": len(record.get("receipts") or []),
-                   "replayed": len(record.get("replayed") or []),
-                   "limit_requests": [self.limit_brief(u["limit_request"])
-                                      for u in engine.waiting_for_user()],
-                   **self.status_extra(engine, inp.detail),
-                   **self.delegate_block(record, inp.session_id)}
-            models = engine.models_used()
-            if models:
-                out["models"] = models
+            guide = self.guide(record["options"].get("reading"), inp.known_guide) \
+                if send_guide else {}
+            if inp.detail == "brief":
+                out = {**self.brief(engine, st, inp), **guide}
+                if guide:
+                    out.pop("guide", None)
+            else:
+                units = [self.unit_row(u) for u in self.listed_units(record, inp.units)]
+                shown, omitted = _capped(units, inp.units)
+                out = {"session_id": inp.session_id, "state": record["state"],
+                       "mode": record["options"]["mode"], "images": record["images"],
+                       "progress": engine.progress(), "units": shown,
+                       "units_omitted": omitted, "truncated": omitted > 0,
+                       "used": record.get("used"),
+                       "estimated_vision_tokens": budgets.vision_tokens(
+                           (record.get("used") or {}).get("pixels", 0)),
+                       "summary": self.summary_of(record), **guide,
+                       "mirror": record.get("mirror"), "control": st.control(inp.session_id),
+                       "outstanding_packet": record.get("outstanding_packet"),
+                       "receipts": len(record.get("receipts") or []),
+                       "replayed": len(record.get("replayed") or []),
+                       "limit_requests": [self.limit_brief(u["limit_request"])
+                                          for u in engine.waiting_for_user()],
+                       **self.status_extra(engine, inp.detail),
+                       **self.delegate_block(record, inp.session_id)}
+                models = engine.models_used()
+                if models:
+                    out["models"] = models
         if replay and not st.control(inp.session_id).get("viewer_detached"):
             try:
                 packet, _ = st.read_packet(inp.session_id, replay)
@@ -606,6 +630,65 @@ class SessionTools:
                 out["mirror"] = self.mirror(call, inp.session_id, packet, replay=True)
         return out
 
+    def brief(self, engine, st, inp) -> dict:
+        """The status by default: what a person asks of a session -- its state,
+        progress and counts, and the units still open or left for a person,
+        grouped by type and state and under `why` by the reason each closed
+        with (`brief_unit` says what is shown of one). Whatever waits on
+        someone (a limit question, a pause) is added when there is one;
+        `detail: full` has the rest."""
+        record = engine.record
+        progress = engine.progress()
+        summary = self.summary_of(record)
+        listed = self.listed_units(record, inp.units)
+        limit = MAX_LIST if inp.units == "all" else MAX_STATUS_UNITS
+        groups: dict = {}
+        for unit in listed[:limit]:
+            key = (unit.get("type"), unit.get("state"))
+            name = str(unit.get("id") or unit.get("channel") or unit.get("marker"))
+            groups.setdefault(key, {}).setdefault(unit.get("reason"), {})[name] = \
+                self.brief_unit(unit)
+        rows = []
+        for (kind, state), by_why in groups.items():
+            group = {**({"type": kind} if kind else {}), "state": state}
+            plain = by_why.pop(None, None)
+            if plain:
+                group["units"] = plain
+            if by_why:
+                group["why"] = dict(sorted(by_why.items(),
+                                           key=lambda item: (-len(item[1]), item[0])))
+            rows.append(group)
+        out = {"session_id": inp.session_id, "state": record["state"],
+               "mode": record["options"]["mode"], "images": record["images"],
+               "progress": {k: v for k, v in progress.items()
+                            if k in ("units_done", "units_total") or (
+                                v and k in ("by_type", "waiting_for_user", "not_profiled",
+                                            "not_scanned"))},
+               "summary": {k: v for k, v in summary.items()
+                           if k not in ("by_state", "units_done", "units_total")
+                           and v not in (None, [], {}, "")},
+               "units": rows,
+               **({"units_omitted": len(listed) - limit} if len(listed) > limit else {}),
+               **self.brief_extra(engine)}
+        requests = [self.limit_brief(u["limit_request"]) for u in engine.waiting_for_user()]
+        if requests:
+            out["limit_requests"] = requests
+        control = st.control(inp.session_id)
+        held = {k: control.get(k) for k in ("paused", "paused_by", "stopped", "stopped_by")
+                if control.get(k)}
+        if held:
+            out["control"] = held
+        if record.get("outstanding_packet"):
+            out["outstanding_packet"] = record["outstanding_packet"]
+        if inp.reattach_viewer:
+            out["mirror"] = record.get("mirror")
+        if record["state"] not in self.FINISHED_STATES \
+                and record["options"].get("reading") == "once":
+            out["guide"] = "not sent: guide=true sends the reading guide packets point into"
+        out["more"] = ("detail='full' adds every unit's fields, the checks and scan, the "
+                       "residual, the budget spent and mirroring")
+        return out
+
     def finish(self, call, inp):
         from plexora.agent import jobs, registry
 

{plexora-0.0.35 → plexora-0.0.36}/plexora/ai/bench.py

@@ -468,7 +468,7 @@ def run_session(session, project, markers, agent, *, mode="apply", limit=400, op
         result = _ok(invoke(session, "gating_answer", {
             "session_id": sid, "packet_id": packet["packet_id"],
             "answer": agent.answer(packet)}))["next"]
-    status = _ok(invoke(session, "gating_session_status", {"session_id": sid,
+    status = _ok(invoke(session, "gating_session_status", {"session_id": sid, "detail": "full",
                                                            "known_guide": started.get(
                                                                "guide_version")}))
     status["sent_to_agent"] = sent

{plexora-0.0.35 → plexora-0.0.36}/plexora/ai/bench_qc.py

@@ -652,7 +652,8 @@ def run_scene(session, made, arm, agent_style, *, seed=0, cell_um=25.0):
         finish_answer = invoke(session, "qc_session_finish", {"session_id": sid})
         agent_text.see(finish_answer["result"])
         status_answer = invoke(session, "qc_session_status", {"session_id": sid,
-                                                              "units": "all"})
+                                                              "units": "all",
+                                                              "detail": "full"})
         agent_text.see(status_answer["result"])
         status = status_answer["result"]
         document = results.load(project)

{plexora-0.0.35 → plexora-0.0.36}/plexora/ai/harness/capabilities.py

@@ -5,8 +5,8 @@
                            its calls billed through the gateway
     ai.run_status          one run (by run id or job id), or the recent ones
     ai.run_control         pause / resume / stop the run's session
-    ai.balance             the account's credit, the price list, and what a
-                           run of this project would be quoted
+    ai.balance             the organisation's credit, the price list, and what
+                           a run of this project would be quoted (its ceiling)
 
 `/ai/v1` (server/routes/ai_routes.py) and MCP reach these through
 `registry.invoke`, so receipts and audit lines are the same whoever asks.
@@ -42,6 +42,15 @@ AI_EVENTS = ("ai_run", "ai_context", "ai_usage", "ai_paused", "ai_finished")
 #: Credits are 10,000 micro-dollars (the gateway's `credit_micro`).
 CREDIT_MICRO = 10_000
 
+#: How a run is charged, beside its estimate (`ai_balance`): the gateway's
+#: ledger charges a declared run min(metered calls, quote) and holds the
+#: quote from the one organisation wallet while it runs.
+CHARGING = ("each estimate is the quote a run is declared with: up to that many credits. Every "
+            "model call is metered and the run is charged what its calls cost, never more than "
+            "the quote, which is held from the wallet while the run lasts. The wallet is the "
+            "organisation's one AI wallet, which every product's AI -- a Plexora run, a "
+            "conversation -- draws on.")
+
 
 def run_id_for(job_id: str) -> str:
     return "air_" + str(job_id).removeprefix("job_")
@@ -78,8 +87,8 @@ def _workflow(kind):
 
 class RunInput(AgentModel):
     kind: Literal["gating", "contrast", "qc"] = Field(
-        description="gating: Auto Gating of the project's markers; contrast: auto contrast -- "
-                    "how bright each marker is drawn, no gating; qc: AutoQC of its image.")
+        description="gating: Auto Gating of the markers; contrast: how bright each marker is "
+                    "drawn, no gating; qc: AutoQC of the image.")
     project: str
     markers: list[str] | None = Field(None, max_length=200, description="gating, contrast: the "
                                       "markers (default: every marker of the table).")
@@ -91,21 +100,22 @@ class RunInput(AgentModel):
     resume_session: str | None = Field(None, description="Continue this paused session (after "
                                        "a credit pause, say) instead of starting one.")
     dev: bool = Field(False, description="The gateway's dev route (internal testing accounts "
-                                         "only; billed at provider cost).")
+                                         "only).")
     model: str | None = Field(None, max_length=80, description="With dev only: the model to use.")
     units_per_worker: int | None = Field(None, ge=1, le=16, description="Units one rolling "
                                          "worker covers (default: 1 marker, 4 QC units).")
+    #: Default: the session's `lanes`, chosen from the panel; more lanes
+    #: finish sooner.
     parallel_markers: int | None = Field(None, ge=1, le=8, description="gating: markers answered "
-                                         "side by side, each lane with its own workers (default: "
-                                         "the session's `lanes`, chosen from the panel). The "
-                                         "gates are the serial run's; more lanes finish sooner.")
+                                         "side by side, each lane its own workers; the gates are "
+                                         "the serial run's.")
     start_options: dict | None = Field(None, description="Extra options for the session's start "
                                        "(the workflow's own, e.g. QC's map_cell_um).")
+    #: A cheap text model normalises it (plexora.ai.context); empty: no call.
     context: str | None = Field(None, max_length=1000, description="gating: the user's note about "
                                 "the sample, as typed (\"melanoma from skin\", \"only gate CD3 and "
-                                "CD8\"). A cheap text model normalises it (plexora.ai.context) into the "
-                                "session's biology; it narrows the markers only when it says so "
-                                "explicitly. Empty: no call, every marker.")
+                                "CD8\"): read into the session's biology, narrowing the markers only "
+                                "when it says so.")
 
 
 class _Relay:
@@ -535,6 +545,7 @@ def balance(call, inp):
                                "affordable": credits * credit <= out["available_micro"],
                                **({"unavailable": why} if why else {}), **words}
         out["estimates"] = estimates
+        out["charging"] = CHARGING
         out["project"] = inp.project
     return out
 
@@ -551,10 +562,12 @@ def capabilities():
     return [
         cap(name="ai.run_session", tool_name="ai_run_session",
             purpose="Gate the project's markers or quality-control its image with Plexora AI, inside "
-                    "Plexora: the session runs on a job and every decision is a model call billed in "
-                    "Plexora AI credits (quoted per marker or channel before anything is spent). An "
-                    "open viewer's agent panel shows it. Resume a session paused for credit with "
-                    "resume_session.",
+                    "Plexora: the session runs on a job and every decision is a model call, paid from "
+                    "the organisation's AI credit wallet. The run is quoted before anything is spent "
+                    "(ai_balance's estimate: the price per marker or channel times their number) and "
+                    "the quote is a ceiling -- up to that many credits: each call is metered and the "
+                    "run is charged what its calls cost, never more. An open viewer's agent panel "
+                    "shows it. Resume a session paused for credit with resume_session.",
             permission="reversible_write", input_model=RunInput, handler=run_session, execution="job",
             writes=("gates", "rois", "qc"), persistent=True, egress="rendered_pixels",
             reads=("image", "table", "mask", "rois")),
@@ -567,7 +580,8 @@ def capabilities():
             permission="reversible_write", input_model=ControlInput, handler=run_control,
             persistent=True, egress="metadata"),
         cap(name="ai.balance", tool_name="ai_balance",
-            purpose="The account's Plexora AI credit, the price per marker / channel, and what a run "
-                    "of a project would be quoted.",
+            purpose="The organisation's AI credit wallet (every product's AI draws on it), the price "
+                    "per marker / channel, and what a Plexora AI run of a project would be quoted: up "
+                    "to that many credits, charged as metered.",
             permission="read", input_model=BalanceInput, handler=balance, egress="metadata"),
     ]

{plexora-0.0.35 → plexora-0.0.36}/plexora/ai/harness/chat_capabilities.py

@@ -121,7 +121,8 @@ def capabilities():
     return [
         cap(name="ai.chat_start", tool_name="ai_chat_start",
             purpose="Start a Plexora AI conversation: an assistant inside Plexora that answers questions "
-                    "about the user's projects by calling Plexora's tools, billed in Plexora AI credits.",
+                    "about the user's projects by calling Plexora's tools, billed to the organisation's AI "
+                    "credits.",
             permission="reversible_write", input_model=StartInput, handler=chat_start,
             writes=("conversation",)),
         cap(name="ai.chat_send", tool_name="ai_chat_send",

{plexora-0.0.35 → plexora-0.0.36}/plexora/ai/harness/decision.py

@@ -670,7 +670,8 @@ class DecisionRun:
             first = self._await_setup(self.lanes[0], started)
             if first.get("state") in ("stopped", "paused", "cancelled", "failed"):
                 return first
-            planned = _ok(self._invoke(self.wf.STATUS, {"session_id": self.session_id}))
+            planned = _ok(self._invoke(self.wf.STATUS, {"session_id": self.session_id,
+                                                        "detail": "full"}))
             started = {**started, "n_units": planned.get("n_units"), "channels": planned.get("channels")}
         else:
             first = None
@@ -1262,7 +1263,8 @@ class DecisionRun:
         finished = None
         if self.session_id and self.parallel > 1:
             try:
-                state = _ok(self._invoke(self.wf.STATUS, {"session_id": self.session_id}))
+                state = _ok(self._invoke(self.wf.STATUS, {"session_id": self.session_id,
+                                                          "detail": "full"}))
                 self.peak_outstanding = int(state.get("outstanding_peak") or 0)
             except Exception:             # noqa: BLE001 -- a count for the summary only
                 pass

{plexora-0.0.35 → plexora-0.0.36}/plexora/ai/skills/gate-image/SKILL.md

@@ -36,10 +36,8 @@ A cell table with cell-id/x/y roles; image channels and a mask for the looks.
 3. Hand packets out as the start's `delegate` says (`how`). Its `brief` is a
    worker's whole prompt: add no skill or guide text; keep only the lines it
    returns. `lanes`: launch them all in one message. `waiting_for_user`: ask the user, pass their word as
-   `gating_session_status` `limits`; never answer for them. Pass the start's
-   `guide_version` as `known_guide` on every `gating_session_status`, or the
-   guide is sent again. Without workers, answer packets yourself
-   (gate-packets) and start a new conversation
+   `gating_session_status` `limits`; never answer for them. Without workers,
+   answer packets yourself (gate-packets) and start a new conversation
    every {{ENGINE.markers_per_worker}} markers or so: each call re-reads all
    earlier packets.
 4. Ask the user (`ask_user`) only what neither numbers nor panel settle:

{plexora-0.0.35 → plexora-0.0.36}/plexora/ai/skills/gate-packets/SKILL.md

@@ -18,7 +18,7 @@ A session `gating_session_status` finds.
 
 ## Decision logic
 
-1. `gating_session_status` (no `known_guide`) sends the `reading_guide` once:
+1. `gating_session_status` with `guide: true` sends the `reading_guide` once:
    judge every packet by it. Stop once `progress.units_done` rose by your
    brief's number (default {{ENGINE.markers_per_worker}}); a brief with
    `reader` (plus `tasks` or `parallel`): pass them on every call, count

{plexora-0.0.35 → plexora-0.0.36}/plexora/ai/skills/gate-review/SKILL.md

@@ -141,7 +141,8 @@ numbers and flags; each picture's artifact id and what it shows.
   (gating/qc-cells says how to tell an artifact QC caught from the marker's
   own problem).
 - Confidence words (`high`, `moderate`, `low`, ...) come from the session's
-  rule table (`gating_session_status` `vocabulary` lists them); report them as
+  rule table (`gating_session_status` `detail: "full"` lists them under
+  `vocabulary`); report them as
   given.
 
 ## Mutation policy

{plexora-0.0.35 → plexora-0.0.36}/plexora/ai/skills/gating/dataset.md

@@ -56,7 +56,8 @@ looks.
      look on this image.
 4. Without workers, start a fresh conversation per image when the panel is
    large; continue with `gating_next` and the `session_id`.
-5. `gating_session_status` shows each marker's `strategy` under `dataset`
+5. `gating_session_status` shows each marker's `strategy` (per image under
+   `dataset` with `detail: "full"`)
    (the classes `compare_gates_across_images` gives: one aligned gate
    `global_aligned`, a gate `per_batch`, `globally_informed_per_image`, or each
    image `per_image`). Report it per marker, with the image as the unit.

{plexora-0.0.35 → plexora-0.0.36}/plexora/ai/skills/gating/decisions.md

@@ -77,9 +77,10 @@ the packet.
   (gate-review).
 - `gating_report` lists per marker the final gate, the Auto proposal, the
   tier, the confidence, the flags and the decisions; `get_all_gates` shows
-  each gate's method; `export_gates` writes CSV files. Status `models` shows
-  which model answered each task when the user's models file splits the work.
+  each gate's method; `export_gates` writes CSV files. Status `models`
+  (`detail: "full"`) shows which model answered each task when the user's
+  models file splits the work.
 - A bulk pass a restart stopped resumes at the next `gating_next`
-  (`gating_session_status` `bulk` says whether it runs).
+  (`gating_session_status` `bulk` says when it is not running).
 - A packet's `mirror` says whether the open viewer shows the same thing;
   `viewer_not_available` while mirroring: the session goes on headless.

{plexora-0.0.35 → plexora-0.0.36}/plexora/ai/skills/qc-image/SKILL.md

@@ -56,10 +56,10 @@ user's data; every export keeps every input row.
 
 The packet is the authority on its own question: what you may answer is its
 `allowed` list and its `answer_schema`, and every number you need is in its
-`evidence`. The start (and `qc_session_status`) returns a `reading_guide`
-once; each packet names the entries it relies on in `evidence.guide` and its
-schema in `answer_schema.see`. Pass `guide_version` back as `known_guide` next
-time and the guide is not sent again.
+`evidence`. The start (and `qc_session_status` with `guide: true`) returns a
+`reading_guide` once; each packet names the entries it relies on in
+`evidence.guide` and its schema in `answer_schema.see`. Pass `guide_version`
+back as `known_guide` next time and the guide is not sent again.
 
 ## When to use
 
@@ -106,12 +106,12 @@ suffixes; when the names do not say, `set_qc_cycles` states them.
    reply carries the pass's `job_id`: wait on it with `job_wait` (it streams
    the progress) rather than calling `qc_next` again and again, then call
    `qc_next` once it is done.
-   A start (or `qc_session_status`) with `delegate` means the user's models
-   file assigns QC tasks to models: do not answer packets yourself. Launch the
-   entry of `delegate.workers` whose `launch` is `now`, on its `model`, with
-   its `brief` as the whole prompt and only `delegate.tools`, in the
-   foreground, and wait for its lines (no wake-ups, messages or status polls
-   while it runs). One that returns `other_tasks <task>`: launch the worker
+   A start (or `qc_session_status` `detail: "full"`) with `delegate` means the
+   user's models file assigns QC tasks to models: do not answer packets
+   yourself. Launch the entry of `delegate.workers` whose `launch` is `now`,
+   on its `model`, with its `brief` as the whole prompt and only
+   `delegate.tools`, in the foreground, and wait for its lines (no wake-ups,
+   messages or status polls while it runs). One that returns `other_tasks <task>`: launch the worker
    whose `tasks` hold that task (an `on_demand` one only then); one that
    stops at its quota: launch its group again. One that returns
    `other_tasks` naming the visual pass hands you a packet no worker takes:

{plexora-0.0.35 → plexora-0.0.36}/plexora/cli.py

@@ -1686,10 +1686,10 @@ def _build_ai_parser():
                        help="With experience: print the summary as JSON.")
     _gating_limit_arguments(bench, "--on-limit", "--max-extensions")
 
-    # Plexora's own harness: AI features with no external agent, billed in
-    # Plexora AI credits through the gateway (plexora/ai/harness).
+    # Plexora's own harness: AI features with no external agent, billed to the
+    # organisation's AI credits through the gateway (plexora/ai/harness).
     run = subs.add_parser("run", help="Run an AI feature inside Plexora (no external agent), "
-                                      "billed in Plexora AI credits.")
+                                      "billed to your organisation's AI credits.")
     run.add_argument("run_target", choices=("gating", "contrast", "qc"),
                      help="gating: Auto Gating of the markers; contrast: auto contrast -- how "
                           "bright each marker is drawn, no gating; qc: AutoQC of the image.")
@@ -1744,12 +1744,12 @@ def _build_ai_parser():
     trace.add_argument("--cache", action="store_true", help="The run's prompt-cache report.")
     trace.add_argument("--json", dest="trace_json", action="store_true")
     chat = subs.add_parser("chat", help="Talk to Plexora AI in the terminal: it answers by calling "
-                                        "Plexora's tools, billed in Plexora AI credits.")
+                                        "Plexora's tools, billed to your organisation's AI credits.")
     chat.add_argument("--resume", default=None, metavar="ID", help="Continue a conversation.")
     chat.add_argument("--dev", action="store_true", help="Use the gateway's dev route (internal testing).")
     chat.add_argument("--model", default=None, help="With --dev: the model to use.")
     chat.add_argument("--gateway", default=None, help="Gateway URL (default: the BioCognia AI gateway).")
-    credits = subs.add_parser("credits", help="Plexora AI credit balance and recent usage.")
+    credits = subs.add_parser("credits", help="Your organisation's AI credit balance and Plexora's recent usage.")
     credits.add_argument("--days", type=int, default=30)
     credits.add_argument("--dev", action="store_true")
     credits.add_argument("--gateway", default=None)

{plexora-0.0.35 → plexora-0.0.36}/plexora/client/src/js/views/agentPanel.js

@@ -865,7 +865,7 @@ window.PlexoraAgentPanel = (function () {
         // with no marker matching an image channel): said, not hidden.
         if (estimate.blocked) return { disabled: true, detail: String(estimate.blocked) };
         if (estimate.unavailable || units <= 0) return { omit: true };
-        const cost = `~${creditCount(estimate.credits)} credits`;
+        const cost = `up to ${creditCount(estimate.credits)} credits`;
         const skipped = (estimate.channels?.unmatched || []).length;
         const detail = ` · ${plural(units, estimate.unit || kind.noun)}`
             + (estimate.confirm && skipped ? ` · ${skipped} without an image channel` : "");

{plexora-0.0.35 → plexora-0.0.36}/plexora/mcp/resources_gating.py

@@ -23,8 +23,8 @@ def register(server, runtime):
         return _answer(runtime, "gating.session_status", {})
 
     @resource("plexora://gating/session/{session_id}", "gating-session",
-              "One gating session: every unit's state, confidence and gate; what it spent; "
-              "its open questions.")
+              "One gating session: each marker's gate, state, confidence and why it needs "
+              "review; its progress and open questions.")
     def session(session_id: str) -> str:
         return _answer(runtime, "gating.session_status", {"session_id": session_id})