docs: replace examples with inventory and verification workflows

README.md

@@ -250,111 +250,121 @@ For CPU or Apple-silicon use, follow the download, build and server instructions
 
 ## Practical examples
 
+The following invented records illustrate four integrations: receiving inventory, diagnosing an import failure, evaluating an inspection note, and checking backup evidence. They are example inputs, not benchmark results. Start either the reference server or the SH GGUF runner on port 30171 before sending them.
 
-Use the running server at `http://127.0.0.1:30171/v1/systemone`. SH scores all questions jointly without generating text. These examples are illustrative workloads, not measured accuracy results; inspect the actual response on your chosen model and quantization.
-
-
-### Customer support: route, handoff and priority
-
-
-Run this in a second terminal after starting the server:
+### Warehouse receiving: reconcile a delivery record
 
+An inventory application can ask several questions about one receiving note. Here, the model compares the recorded quantities and checks whether the paperwork supports closing the receipt.
 
 ```bash
 curl --fail-with-body http://127.0.0.1:30171/v1/systemone \
   -H "Content-Type: application/json" --data-binary @- <<'JSON'
 {
-  "state": "My account was charged twice. I have contacted support three times and want a person to help with the refund today.",
+  "state": "Purchase order R-417 lists 48 cable reels. The receiving scan recorded 46 reels. Two pallet tags cannot be read, and the receiver has not signed the count sheet.",
   "questions": {
-    "team": {
+    "receipt_action": {
       "type": "choice",
-      "instructions": "Which team should handle this message?",
+      "instructions": "Select the next inventory step supported by the receiving note.",
       "criteria": {
-        "billing": "Charges, refunds and invoices",
-        "technical": "Application errors and login problems",
-        "other": "Requests outside billing and technical support"
+        "close_receipt": "The delivered quantity is reconciled and the count sheet is signed.",
+        "reconcile_count": "The recorded quantity differs from the order or pallet identification is unresolved.",
+        "await_delivery": "The shipment has not reached the receiving area."
       }
     },
-    "handoff": {"type": "noul", "instructions": "Does the customer explicitly request a human agent?"},
-    "priority": {
+    "quantities_match": {
+      "type": "noul",
+      "instructions": "Do the receiving scan and purchase order report the same number of reels?"
+    },
+    "record_completeness": {
       "type": "score",
-      "instructions": "How urgently should support review this request?",
-      "criteria": ["Can wait", "Review today", "Service is blocked right now"]
+      "instructions": "Evaluate how complete the receiving evidence is.",
+      "criteria": [
+        "No quantity or identification evidence is available.",
+        "Some evidence is recorded, but discrepancies or missing sign-off remain.",
+        "Quantities and identifiers are reconciled and sign-off is recorded."
+      ]
     }
   }
 }
 JSON
 ```
 
+This record describes an unresolved count, unequal quantities and partial paperwork. Use those facts to inspect the returned answers. A `choice` question compares the descriptions you provide, a `noul` question returns a yes/no probability, and a `score` question returns an expected position on its ordered, zero-based scale. The score can lie between two levels.
 
-The intended routing label here is `billing`, with a human handoff. This describes the task, not a promised model output. `choice` selects from supplied categories; `noul` scores a yes/no question; `score` uses an ordered scale and returns an expected zero-based level that can be fractional.
-
-
-### Ticket routing, incident severity, agent completion and document routing
-
-
-This Python client uses only the standard library and prints the complete server response. The requests work with the BF16 reference server and the SH GGUF runner on port 30171.
+### Python client
 
+Use this small standard-library client for the remaining examples. It displays the response as received so that you can examine the selected values and probability estimates.
 
 ```python
 import json
 from urllib.request import Request, urlopen
 
-
-def decide(state, questions):
+def evaluate_record(record, questions):
+    payload = json.dumps({"state": record, "questions": questions}).encode("utf-8")
     request = Request(
         "http://127.0.0.1:30171/v1/systemone",
-        data=json.dumps({"state": state, "questions": questions}).encode("utf-8"),
+        data=payload,
         headers={"Content-Type": "application/json"},
         method="POST",
     )
     with urlopen(request, timeout=300) as response:
-        return json.load(response)
-
-
-# Route a ticket to one queue from your own taxonomy.
-print(json.dumps(decide(
-    "I cannot sign in after resetting my password. The reset link has expired.",
-    {"queue": {"type": "choice", "instructions": "Which queue owns the ticket?",
-               "criteria": {"account_access": "Login and password problems",
-                            "billing": "Payments and invoices",
-                            "bug_report": "Other application defects",
-                            "other": "None of these queues"}}}
-), indent=2))
-
-
-# Score an ordered incident severity scale.
-print(json.dumps(decide(
-    "Production checkout is unavailable for all customers. The incident is ongoing.",
-    {"severity": {"type": "score", "instructions": "Assess the incident severity.",
-                  "criteria": ["Informational; no service impact",
-                               "Minor impact with a workaround",
-                               "Major degradation affecting some customers",
-                               "Critical outage affecting all customers"]}}
-), indent=2))
-
-
-# Check an observed result against the original goal.
-print(json.dumps(decide(
-    "Goal: send the weekly report to the team. Observed state: draft saved; the message has not been sent.",
-    {"finished": {"type": "noul", "instructions": "Has the agent completed the goal?"}}
-), indent=2))
-
-
-# Classify a document before selecting an extraction workflow.
-print(json.dumps(decide(
-    "INVOICE 2048. Amount due: USD 240. Payment due within 30 days.",
-    {"document_type": {"type": "choice", "instructions": "Classify the document.",
-                       "criteria": {"invoice": "A request for payment",
-                                    "receipt": "Confirmation of completed payment",
-                                    "meeting_notes": "Notes from a meeting",
-                                    "other": "None of these document types"}}}
-), indent=2))
+        print(json.dumps(json.load(response), indent=2))
 ```
 
+### Data import: identify a column mismatch
+
+An import monitor can classify a diagnostic record before selecting a repair playbook. This input contains rows, but the expected timestamp column is absent.
 
-Each `choice` question selects one category. For independent tags, submit one `noul` question per tag in the same request. Choose probability thresholds on representative validation data before automating routing or handoff. These examples use text input, the validated path for this release.
+```python
+evaluate_record(
+    "Import job J-82 read 1,200 CSV rows. Required column event_time was not found. The file contains a column named timestamp_ms. UTF-8 decoding succeeded.",
+    {"failure_kind": {
+        "type": "choice",
+        "instructions": "Identify the import failure described in this diagnostic record.",
+        "criteria": {
+            "column_mismatch": "The available column names differ from the required schema.",
+            "empty_input": "The file contains no data rows.",
+            "text_encoding": "The importer cannot decode the file contents.",
+            "unresolved": "The record does not establish a failure category."
+        }
+    }}
+)
+```
+
+### Equipment inspection: evaluate a filter reading
+
+A maintenance log can map a written observation onto a defined condition scale. The criterion here is the gauge marking recorded by the inspector.
+
+```python
+evaluate_record(
+    "Inspection of ventilation unit V-12: the filter pressure gauge is above the marked replacement line. The fan guard is secured and the housing has no visible cracks.",
+    {"filter_condition": {
+        "type": "score",
+        "instructions": "Assess the filter condition using the reported gauge position.",
+        "criteria": [
+            "The gauge is inside the normal operating band.",
+            "The gauge is above normal but below the replacement line.",
+            "The gauge has reached or exceeded the replacement line."
+        ]
+    }}
+)
+```
+
+### Backup verification: compare evidence with an acceptance rule
+
+A backup catalog can check whether a verification record satisfies a supplied rule. This example requires both a matching checksum and a successful restore check.
+
+```python
+evaluate_record(
+    "Archive B-206 was written to storage. Verification reported a checksum mismatch. A restore check has not been attempted.",
+    {"backup_verified": {
+        "type": "noul",
+        "instructions": "Does this record satisfy the rule that a verified backup must have a matching checksum AND a successful restore check?"
+    }}
+)
+```
 
+These calls only request decisions; the surrounding application decides what to do with them. Measure accuracy and choose probability thresholds using records from your own workflow. All examples send text, which is the validated input path for these releases.
 
 ## Files