@passioncode-ai/fabric-agent-adapter 0.39.0 → 0.39.1

package/plugins/fabric-agent-adapter/skills/building-fabric-services/scripts/fabric_service.py

@@ -18,6 +18,7 @@ import hashlib
 import hmac
 import http.server
 import json
+import math
 import ntpath
 import os
 from pathlib import Path, PurePath
@@ -46,7 +47,7 @@ EXTENSION_KEY = "https://fabric.passioncode.ai/agent-contract/extensions/service
 # The embedded dashboard declaration (fabric-dashboard/0.1, DEC-0036 ED-9), under the well-known
 # document's `extensions`. The kit is assets/dashboard-kit; its version is the one in kit.json.
 DASHBOARD_EXTENSION_KEY = "https://fabric.passioncode.ai/agent-contract/extensions/dashboard/0.1"
-DASHBOARD_KIT = "fabric-dashboard-kit@1.1.0"
+DASHBOARD_KIT = "fabric-dashboard-kit@1.1.1"
 REFERENCE_THEMES = ("graphite", "fabric", "paper", "forest", "ocean", "ember", "contrast")
 EXIT_ALREADY_RUNNING = 75
 # Lifecycle rules: references/lifecycle.md, the rule for this kit's users, which implements the public
@@ -1734,11 +1735,21 @@ _DAY_MS = 86_400_000
 
 
 def _usage_count(value: Any) -> int:
-    return value if isinstance(value, int) and not isinstance(value, bool) and 0 <= value <= 2 ** 53 - 1 else 0
+    """The contract's `count`: Number.isSafeInteger and not negative, so 5.0 (which JavaScript reads as 5) counts."""
+    import fabric_estate  # noqa: E402
+    return int(value) if not isinstance(value, bool) and fabric_estate._safe_integer(value) and value >= 0 else 0
+
+
+def _usage_money(value: Any) -> Optional[float]:
+    """A JSON number as JavaScript holds it (an integer beyond a double is Infinity), or None for anything else."""
+    import fabric_estate  # noqa: E402
+    return fabric_estate._double(value) if isinstance(value, (int, float)) and not isinstance(value, bool) else None
 
 
 def _usage_cost(value: Any) -> float:
-    return float(value) if isinstance(value, (int, float)) and not isinstance(value, bool) and value == value and value >= 0 and value != float("inf") else 0.0
+    """The contract's `cost`: a known, finite, non-negative cost, or 0."""
+    money = _usage_money(value)
+    return money if money is not None and math.isfinite(money) and money >= 0 else 0.0
 
 
 def _exceeds(a: float, b: float) -> bool:
@@ -1797,8 +1808,7 @@ def usage_findings(report: Any) -> List[Dict[str, str]]:
     previous = ""
     for i, day in enumerate(days):
         at = "/days/%d" % i
-        date = day.get("date")
-        date = "" if date is None else (date if isinstance(date, str) else json.dumps(date))
+        date = fabric_estate._show("" if day.get("date") is None else day["date"])  # the contract's show(day.date ?? "")
         if date <= previous:
             flag(at + "/date", "days must run forward without a repeat (%s after %s)" % (date, previous))
         previous = date
@@ -1806,19 +1816,29 @@ def usage_findings(report: Any) -> List[Dict[str, str]]:
         models = _usage_list(day.get("byModel"))
         for j, m in enumerate(models):
             findings.extend(_priced_row(m, "%s/byModel/%d" % (at, j)))
+        # The contract reads every count as `toNumber(x ?? 0)` and writes it with `show`: a string count is read as a
+        # number, and what is no number (an object, "abc") is NaN, which equals no sum, so it is a finding.
+        number = lambda row, f: fabric_estate._js_to_number(row.get(f))  # noqa: E731 - None and absent read as 0
         if not models:
-            spent = any((day.get(f) or 0) > 0 for f in ("calls", "inputTokens", "outputTokens", "cacheReadTokens", "cacheWriteTokens")
-                        if isinstance(day.get(f) or 0, (int, float))) or (isinstance(day.get("costUsd"), (int, float)) and day["costUsd"] > 0)
+            spent = any(number(day, f) > 0 for f in ("calls", "inputTokens", "outputTokens", "cacheReadTokens", "cacheWriteTokens")) \
+                or number(day, "costUsd") > 0
             if spent:
                 flag(at + "/byModel", "a day with calls, tokens or cost names the models they belong to")
             continue
         for field in ("calls", "unpricedCalls", "unmeasuredCalls", "inputTokens", "outputTokens", "cacheReadTokens", "cacheWriteTokens"):
-            total = sum(m.get(field) or 0 for m in models if isinstance(m.get(field) or 0, (int, float)))
-            if (day.get(field) or 0) != total:
-                flag("%s/%s" % (at, field), "the day's %s is not the sum of its models (%s ≠ %s)" % (field, day.get(field) or 0, total))
-        known = sum(m["costUsd"] for m in models if isinstance(m.get("costUsd"), (int, float)) and not isinstance(m.get("costUsd"), bool))
-        day_cost = day.get("costUsd")
-        if isinstance(day_cost, (int, float)) and not isinstance(day_cost, bool) and abs(day_cost - known) > 0.000001 + 1e-9 * max(abs(day_cost), abs(known)):
+            total = 0.0
+            for m in models:
+                total += number(m, field)  # in order, in doubles, as JavaScript adds
+            if number(day, field) != total:
+                shown = fabric_estate._show(0 if day.get(field) is None else day[field])
+                flag("%s/%s" % (at, field), "the day's %s is not the sum of its models (%s ≠ %s)" % (field, shown, fabric_estate._js_string(total)))
+        known = 0.0
+        for m in models:
+            money = _usage_money(m.get("costUsd"))
+            known += money if money is not None else 0.0
+        day_cost = _usage_money(day.get("costUsd"))
+        # The contract's !close(day, known): Infinity or NaN is never close, so it is a finding.
+        if day_cost is not None and not abs(day_cost - known) <= 0.000001 + 1e-9 * max(abs(day_cost), abs(known)):
             flag(at + "/costUsd", "the day's cost is not the sum of its models' known costs")
     # The window.
     if days:
@@ -1865,7 +1885,7 @@ def usage_findings(report: Any) -> List[Dict[str, str]]:
                 run_priced += max(0, _usage_count(run.get("calls")) - _usage_count(run.get("unpricedCalls")))
                 findings.extend(_priced_row(run, "%s/taskRuns/%d" % (at, r)))
             project_priced = max(0, _usage_count(project.get("calls")) - _usage_count(project.get("unpricedCalls")))
-            known_cost = isinstance(project.get("costUsd"), (int, float)) and not isinstance(project.get("costUsd"), bool) and _usage_cost(project.get("costUsd")) == project.get("costUsd")
+            known_cost = _usage_cost(project.get("costUsd")) == _usage_money(project.get("costUsd"))  # as JavaScript holds it
             if run_calls > _usage_count(project.get("calls")):
                 flag(at + "/taskRuns", "a project's task runs hold more calls than the project (%d > %d)" % (run_calls, _usage_count(project.get("calls"))))
             elif run_priced > project_priced:

package/plugins/fabric-agent-adapter/skills/building-fabric-services/scripts/sample_service.py

@@ -258,7 +258,7 @@ def make_handler(svc: Service):
             if url.path == "/":
                 if not self._session_ok():
                     return self._send(401, "Open this dashboard from Fabric Dashboards.", content_type="text/plain")
-                rows = "".join("<li>%s — %s</li>" % (html.escape(e["at"]), html.escape(e["text"]))
+                rows = "".join("<li>%s: %s</li>" % (html.escape(e["at"]), html.escape(e["text"]))
                                for e in reversed(svc.log.fetch(None, 20)))
                 return self._send(200, PAGE.format(name=html.escape(svc.name), agent=html.escape("%s.%s" % (svc.id, svc.instance)), status="ready", rows=rows),
                                   content_type="text/html; charset=utf-8")

package/plugins/fabric-agent-adapter/skills/creating-fabric-agents/SKILL.md

@@ -5,7 +5,7 @@ license: AGPL-3.0-only OR LicenseRef-PassionCode-Commercial
 compatibility: Requires filesystem access and Python 3.9+. Exact schema checks additionally need git, Node.js, pnpm, and the pinned fabric-agent-contract checkout (a public repository). Works without those tools in an explicitly degraded structural-check mode. Ships in one plugin with adapting-projects-to-fabric, whose scripts it reuses.
 metadata:
   author: PassionCode.ai
-  version: "0.39.0"
+  version: "0.39.1"
   contract-version: "0.1.0"
   contract-commit: "c55f2d5a11c9a0197e958e87212fca7ae1154769"
 ---
@@ -14,60 +14,60 @@ metadata:
 
 Design a new agent so that Fabric compatibility is a property of its first commit, not a
 retrofit. The sibling skill `adapting-projects-to-fabric` wraps an interface that already
-exists; this one runs the stages that come *before* an interface exists — the intake
-grill and the knowledge intake — then hands the scaffolding and verification to the same
+exists; this one runs the stages that come *before* an interface exists (the intake
+grill and the knowledge intake), then hands the scaffolding and verification to the same
 pinned machinery, so both doors lead into one pipeline.
 
 ## Boundary
 
 Use this skill to design and build a new provider. Do not use it to:
 
-- adapt a project that already has a stable API, MCP/A2A surface, or CLI — that is
+- adapt a project that already has a stable API, MCP/A2A surface, or CLI: that is
   `adapting-projects-to-fabric`, and entering there skips nothing;
 - design the Fabric host, registry, scheduler, admission service, or binding runtime;
-- build a generic agent with no Fabric requirement — nothing here helps a project that
+- build a generic agent with no Fabric requirement: nothing here helps a project that
   will never be a provider;
 - claim admission: the deliverable is an admission-ready provider bundle, never a
   connected provider.
 
 ## Handing off to neighbouring skills
 
-- The agent's own loop — tool calls, routing and fallback, memory, sub-agents — is
+- The agent's own loop (tool calls, routing and fallback, memory, sub-agents) is
   designed with `agent-orchestrator` (agent-stack).
-- Its eval suite beyond the step-2 observables — trajectories, judges, regression
-  fixtures from traces — is built with `agent-evals` (agent-stack).
+- Its eval suite beyond the step-2 observables (trajectories, judges, regression
+  fixtures from traces) is built with `agent-evals` (agent-stack).
 - Packaging the agent as an Agent Skill or Claude Code plugin goes through `make-skill`.
 
 When one of them is not installed, do that part by hand against its own documentation
 and say in the report which skill was missing.
 
-## Step 0 — the intake grill
+## Step 0: the intake grill
 
 No file is created until every row has an answer. An answer of "later" fails the grill.
 
 | Question | The gate |
 |---|---|
 | **What capability?** | one capability, named as `domain.action` (optionally `@surface`), with input and output shapes statable now |
-| **Who calls it?** | **a named consumer** — the project, schedule, or workflow that will actually invoke this capability. No consumer, no agent: a role that "would be useful" is a catalogue entry, not a build order |
-| **Workflow or agent?** | if every step can be named now, build a deterministic workflow behind the capability and skip the autonomy — an agent buys flexibility with latency, cost, and a new failure class, and that price needs a reason |
+| **Who calls it?** | **a named consumer**: the project, schedule, or workflow that will actually invoke this capability. No consumer, no agent: a role that "would be useful" is a catalogue entry, not a build order |
+| **Workflow or agent?** | if every step can be named now, build a deterministic workflow behind the capability and skip the autonomy; an agent buys flexibility with latency, cost, and a new failure class, and that price needs a reason |
 | **Which profile?** | `mcp` when Fabric owns planning and retries and the capability has a schema; `a2a` when the provider owns its task lifecycle end to end; `local-runner` when it is a terminal agent Fabric drives. When unsure, the sibling skill's profile-selection reference is the decision record |
-| **What effects?** | declare anything money-, deletion-, or publication-adjacent now — the host's floor and grants are designed against these declarations, and one discovered late invalidates the admission |
+| **What effects?** | declare anything money-, deletion-, or publication-adjacent now; the host's floor and grants are designed against these declarations, and one discovered late invalidates the admission |
 | **Where does it run, for whom?** | this machine, the person's cloud or an organization's, and in which contexts (`personal`, `org:<id>`): one instance per context, its secrets, spend and journal never crossing into another. Record which capabilities need the person's machine and what they answer when it is off (references/where-agents-run.md) |
 | **Which models?** | per lane (planning, replies, volume work, media): a primary, a fallback of another vendor, an open-vendor model where it reads what users send, the input kinds each reads, declared as classes in the profile (references/models-and-providers.md) |
 | **Who pays?** | one key per agent and context with its own ceiling, from the estate's key manager, read from the environment; checked before every call; a personal key never pays for an organization |
 | **How does it learn?** | decisions recorded with reasons, one trace per turn, every failure a planted fixture first, history replayed, learnings proposed and never self-approved (references/orchestration-and-learning.md) |
 | **Text for people?** | if it writes anything a person reads (a reply, a message, a post, a report, a UI string), its prompt forbids the em dash (U+2014) and any substitute for it, and a test fails on U+2014 in new output, from the first commit (the resilience reference, *Text for people*) |
 
-## Step 1 — the knowledge intake
+## Step 1: the knowledge intake
 
-If the estate holds prior art — a project that did this job, an audit that names its
-failures, a retro — distil it before writing code:
+If the estate holds prior art (a project that did this job, an audit that names its
+failures, a retro), distil it before writing code:
 
 1. Name the sources: repositories, `docs/`, audits, retrospectives, with references.
 2. Extract **patterns** (what worked, each citing its origin) and **traps** (recorded
    failures and dead ends).
 3. **Convert every trap into a planted eval fixture.** The new agent is not done until
-   it has been watched rejecting the exact defects its predecessors were burned by —
+   it has been watched rejecting the exact defects its predecessors were burned by:
    knowledge transfers as a check, not as prose.
 4. Record the pack in the new project as `docs/knowledge-pack.md` with its sources, so
    the provenance of every borrowed decision survives the person who borrowed it.
@@ -90,10 +90,10 @@ prior art of its own:
 - [orchestration-and-learning.md](references/orchestration-and-learning.md): the work graph,
   calling other agents, stops for a person, learning loops, the loop guard.
 
-## Step 2 — the project skeleton
+## Step 2: the project skeleton
 
 Create the minimal project: repository, `README.md` naming the capability and its
-consumer, and the eval **observables** — for each requirement, the pass/fail criterion
+consumer, and the eval **observables**: for each requirement, the pass/fail criterion
 that would show it met, written now, before the implementation. The input corpus is NOT
 authored now: it grows from real traces once the provider runs, and the step-1 fixtures
 are its seed because a source project's recorded failures count as production.
@@ -122,9 +122,9 @@ workflow names the keys it needs in its checkpoint (`credentials`), never their
 org-index `scripts/check_format.py` reports 0 findings for it before it is called done. **An agent
 someone builds for themselves is not a PassionCode.ai repository:** its licence is its owner's
 choice, nothing about it is published or listed by the organization, and none of these files is
-required of it — though the verified MCP quick start is still how anyone learns to drive it.
+required of it, though the verified MCP quick start is still how anyone learns to drive it.
 
-## Step 3 — scaffold the provider bundle
+## Step 3: scaffold the provider bundle
 
 Reuse the sibling skill's scaffolder against the new skeleton with the profile chosen at
 step 0:
@@ -145,7 +145,7 @@ Pin exactly contract `0.1.0` at commit `c55f2d5a11c9a0197e958e87212fca7ae1154769
 read the pinned guide before implementing protocol details. If this skill is installed
 without its sibling, the scaffolder is absent: create the bundle by hand from the pinned
 contract's `docs/guides/connecting-compatible-agents.md` and mark the structural check
-`NOT_RUN` — do not reconstruct normative rules from memory.
+`NOT_RUN`; do not reconstruct normative rules from memory.
 
 This default accepts underscore capability names; a declared communications name does
 not grant COM access or prove runtime admission. Existing bundles retain their explicit
@@ -160,10 +160,10 @@ tool of its name, and carry the caller's trace (the `building-fabric-services` i
 reference). An agent that is not a service is announced with a provider entry
 (`adapting-projects-to-fabric`, `scripts/fabric_provider.py`).
 
-## Step 4 — implement against the observables
+## Step 4: implement against the observables
 
-If the agent keeps running on the operator's computer — it answers other agents, runs
-long jobs or shows a dashboard — build it as a service with the sibling skill
+If the agent keeps running on the operator's computer (it answers other agents, runs
+long jobs or shows a dashboard), build it as a service with the sibling skill
 `building-fabric-services`: its instance lock, launchd plist, descriptor, well-known
 document and events feed are part of this step, not a later retrofit. If that skill is
 absent, apply the `fabric-service/0.1` rules from the pinned contract's
@@ -179,18 +179,18 @@ provider output is untrusted until schemas and semantic assertions pass. The ste
 observables are the definition of done; an observable attached after the code exists
 lets the output decide what counts as success.
 
-## Step 5 — check, report, and set the canary expectation
+## Step 5: check, report, and set the canary expectation
 
 Run the sibling skill's `check` (structural, then exact when the contract checkout is
 available) and complete `fabric/FABRIC-CONFORMANCE.md` with dated receipts, exactly as
-its workflow steps 5–7 prescribe — this skill adds no second verification path on
+its workflow steps 5–7 prescribe; this skill adds no second verification path on
 purpose. Then record one expectation the report must carry:
 
-> When a Fabric host admits this provider, it enters under a **canary binding** — a
-> checker on its output and a budget cap — regardless of who wrote it. Unsupervised
+> When a Fabric host admits this provider, it enters under a **canary binding** (a
+> checker on its output and a budget cap), regardless of who wrote it. Unsupervised
 > operation is a later, recorded promotion citing eval results and run history.
 
-## Step 6 — propose the operator channel
+## Step 6: propose the operator channel
 
 If the agent has a human stop (a choice, an approval, a confirmation) or emits `notify: true`
 events, propose its **operator channel** to the operator once, now. The channel is the agent's
@@ -206,11 +206,11 @@ operator's four steps:
 4. type the code it shows in the chat with the bot.
 
 In a group shared with other bots the channel follows OC-14…OC-17 (DEC-0035): it stays silent
-unless addressed — `/command@ThisBot`, a reply to its own message or a press of its own button; a
-bare `/command` in a group is not addressed — and a channel nobody receives on is `degraded`
+unless addressed (`/command@ThisBot`, a reply to its own message or a press of its own button; a
+bare `/command` in a group is not addressed), and a channel nobody receives on is `degraded`
 (`receiver-missing`). Say so in the proposal when the operator means to bind a shared group.
 
-Record the answer — `accepted`, `declined` or `later` — in the agent's state and in the
+Record the answer (`accepted`, `declined` or `later`) in the agent's state and in the
 report, and do not ask again; an agent that serves `surfaces.operatorChannel` also shows it as
 `proposal` in its status document. Creating the bot, storing the token and enabling the channel are the
 operator's action: never create the bot, ask for or store the token's value, or enable the
@@ -237,7 +237,7 @@ table with `PASS`, `FAIL`, `NOT_RUN`, or `NOT_VERIFIED`; remaining placeholders;
 operator channel answer (step 6); and the exact next command. Never summarize the outcome as
 "Fabric-compatible" unless every required admission gate passed against the real provider.
 
-## Dashboard handoff — also for consumers
+## Dashboard handoff: also for consumers
 
 When handing a registered service dashboard to a person, or writing the generated
 agent's completion/notification instructions, read and apply

package/plugins/fabric-agent-adapter/skills/creating-fabric-agents/references/dashboard-links.md

@@ -1,4 +1,4 @@
-# Dashboard links — producer and consumer rule
+# Dashboard links: producer and consumer rule
 
 Read when an agent creates a dashboard, implements `<tool> dashboard`, or hands
 an existing Fabric service dashboard to a person. This also applies to generated

package/plugins/fabric-agent-adapter/skills/creating-fabric-agents/references/resilience-and-autonomy.md

@@ -1,6 +1,6 @@
-# Resilience and autonomy — what kept agents working
+# Resilience and autonomy: what kept agents working
 
-Read when designing an agent's loop, its model calls, its spend and its stops — before the first
+Read when designing an agent's loop, its model calls, its spend and its stops, before the first
 stage that calls a model or spends money. These rules come from a retrospective of about twenty
 production agents (2026-10-17): each rule names the failure that taught it, generalized, and the
 mechanism that held after the fix. Every rule is cheaper to build in than to retrofit.
@@ -27,8 +27,8 @@ mechanism that held after the fix. Every rule is cheaper to build in than to ret
    `retryable: false` when a person must act, and `resetsAt` (UTC, `T` and `Z`, at most three
    fraction digits) only when `retryable: true` (contract DEC-0087, `FAC-SEM-119`). Failing a job a
    limit only paused cost callers whole jobs and resubmits.
-2. **Resume first.** Every worker reads its own state — checkpoint, worktree, branches, open
-   pull requests, notes — before it acts, and continues from there. Relaunching from scratch
+2. **Resume first.** Every worker reads its own state (checkpoint, worktree, branches, open
+   pull requests, notes) before it acts, and continues from there. Relaunching from scratch
    after a limit recreated work over committed work and re-issued credentials already held.
 3. **A silent worker is a limit until proven otherwise.** A watcher that sees no progress for N
    minutes, or limit text in the last output, resumes the run with the *same* run id.
@@ -40,19 +40,19 @@ mechanism that held after the fix. Every rule is cheaper to build in than to ret
 6. **Match concurrency to the account's rate, and cool down after a 429** per provider door: ten
    parallel workers met a 429 about hourly and each lost a whole batch; three to five heavy ones,
    resumed in batches, did not. A "busy" or "still starting" dependency is retried a bounded number
-   of times with spacing (a handful, seconds apart, only on refusals classified as transient) —
+   of times with spacing (a handful, seconds apart, only on refusals classified as transient):
    never once, never forever.
-7. **Inside a fallback chain, do not retry a provider that answered 429 or timed out** — move to
+7. **Inside a fallback chain, do not retry a provider that answered 429 or timed out**: move to
    the next one. Retries there stalled a waiting user. Stagger many resumes; bound each worker's
    working set (a narrow time window, a prefix), so one stop does not become a burst.
 
 8. **Move a refused request to another account at most once, and only before any byte reached the
-   client** — a replay after streaming began duplicated output. Persist a provider's `Retry-After`
+   client**: a replay after streaming began duplicated output. Persist a provider's `Retry-After`
    across restarts; a check inside the hold answers the stored observation instead of probing.
 
 ## Model answers are untrusted until accepted
 
-1. **"Answered" is not "usable".** Each call site has its own `accept(text)` — the parser the
+1. **"Answered" is not "usable".** Each call site has its own `accept(text)`: the parser the
    result must pass. Empty content, a refusal, a truncation (`finish_reason: length`) or an
    unparseable answer is a failure, and only an accepted answer may be cached. A cached
    unreadable answer once served "0 labelled" for hours.
@@ -61,13 +61,13 @@ mechanism that held after the fix. Every rule is cheaper to build in than to ret
    with no other-vendor route, and act on a new fallback only after measuring it.
 3. **The checker is never the drafter's vendor.** Choose it per turn from the model that
    *actually* drafted (a fallback may have), in the router, not in configuration. No checker
-   left, or a checker outage, means hold or stay silent — never ship unchecked.
+   left, or a checker outage, means hold or stay silent, never ship unchecked.
 4. **Size the output budget for the answer, not the input.** Reasoning tokens eat `max_tokens`:
    a judge capped at 800 tokens returned no JSON in 8 of 14 calls. Give judges room or turn
    reasoning off for that route; on `length`, retry once with a larger cap.
 5. **Run code checks before model checks**, and degrade to a fixed safe reply with a reason code.
 6. **A model's word verifies nothing.** A fact is verified by stored source text (or two truly
-   independent sources); an effect by the system of record it lands in — never by the page, a
+   independent sources); an effect by the system of record it lands in, never by the page, a
    flag the model set, or its "done".
 7. **A coding agent runs only on a model it knows.** One CLI agent on an unfamiliar vendor's model
    read its instructions and ended its turn with nothing written; measure each (agent, model)
@@ -78,19 +78,19 @@ mechanism that held after the fix. Every rule is cheaper to build in than to ret
 
 ## Money is a ledger
 
-1. **Unknown is unknown, never zero** — in cost, in verdicts, in health — and nothing acts on it.
+1. **Unknown is unknown, never zero** (in cost, in verdicts, in health), and nothing acts on it.
    A missing price is a high estimate, a missing field is `NOT_RUN`, never a pass; a probe that
    timed out is "unreadable", not "credential rejected"; a cooldown that could not be read is not
    "never sent". An owner's refusal inside a successful response (`ok: false` over a 200) is a
    refusal, never an empty result.
-2. **Persist the attempt before dispatch** — its route and a hash of its prompt — and finalize it
+2. **Persist the attempt before dispatch** (its route and a hash of its prompt) and finalize it
    in `finally`; spend is Σ actual + Σ estimate for attempts without an actual. In-memory counters
    reset on every resume. A call that broke before the provider answered is reconciled against
    the provider's own history by that route and hash, never guessed; one provider request id
    belongs to exactly one ledger row.
 3. **Check the cap before every HTTP attempt, retries included**, with one stop rule; record the
    provider's own reported cost per call; count reserved or held tokens as spent.
-4. **A resend of an unknown outcome reuses its idempotency key — or does not happen.** Derive
+4. **A resend of an unknown outcome reuses its idempotency key, or does not happen.** Derive
    keys from the intent (action and entity, or run and step), never from a clock or a random
    value, and make them unique in storage: time-and-random keys let redelivered requests charge
    again. A write whose effect is uncertain ends `failed` with the code `outcome-unknown`; only an
@@ -102,7 +102,7 @@ mechanism that held after the fix. Every rule is cheaper to build in than to ret
    if none), release the reserved money in the same transaction, and never resend the identical
    request; a 4xx while polling is still a lost task.
 6. **A failed outer job cancels the paid work it started**, and a cancel is a row the worker reads
-   at every claim and checkpoint — never an in-memory flag that a restart forgets.
+   at every claim and checkpoint, never an in-memory flag that a restart forgets.
 7. **Reuse what was paid for.** A restarted stage looks up the job's successful call with the
    same route, prompt version and inputs before calling again (one restart made 117 paid calls
    where 49 sufficed). Cache keys are content plus definition, never an identity alone.
@@ -121,14 +121,14 @@ mechanism that held after the fix. Every rule is cheaper to build in than to ret
 2. **Nothing in a user's path waits for a human approval.** Send now or not at all; when unsure,
    say so, open a recorded question, and answer again automatically when the knowledge changes.
    Drafts awaiting approval waited for days.
-3. **Every wait lives in durable storage**, rebuilt on start from a "debt" query — timers in
+3. **Every wait lives in durable storage**, rebuilt on start from a "debt" query; timers in
    process memory died with every restart. A wait that must outlive a session (a credential that
    has not landed yet) is an operating-system job, not a session's background task.
 4. **Stop at the third round.** Tuning wording or patching one heuristic a third time means
    splitting the change or replacing the mechanism with one invariant and a property test.
    Write a review's exit criterion before its rounds start, and block only on what breaks a
    documented promise; the rest becomes a board row with its evidence.
-5. **Find the real cause before telling a person what to do** — a full disk once read as "the
+5. **Find the real cause before telling a person what to do**: a full disk once read as "the
    service stopped" while the service was healthy; check free space and the service's own health
    first.
 6. **Background chores never hold a finished command open**, unattended runs skip them, and an
@@ -144,17 +144,17 @@ mechanism that held after the fix. Every rule is cheaper to build in than to ret
 ## Verification you can believe
 
 1. **A test counts once it was watched failing against a planted defect** (clear bytecode caches
-   first — stale bytecode reported mutants killed); a mutation battery
+   first: stale bytecode reported mutants killed); a mutation battery
    asserts its own reach ("no tests ran" is not "all plants survived"). Exercise every guard
    with a must-catch and a must-pass case.
 2. **Write expectations out; never compute them from the code under test**, and run a reference
-   function and its schema on the same inputs in one test — the most common defect a first reading
+   function and its schema on the same inputs in one test; the most common defect a first reading
    found was a function returning what its own schema refuses. A wall-clock bound sits far above a
    loaded machine and far below the defect it guards.
 3. **Test against the real deployed instance behind its platform**, not a sample the same run
    wrote: a probe passed the shipped sample and failed the first real service behind a router.
-4. **After each wave, three blind readings** — the changed units, everything that reaches them,
-   and the documented behaviour — then one fix round. Green suites hid six to ten real breaks.
+4. **After each wave, three blind readings** (the changed units, everything that reaches them,
+   and the documented behaviour), then one fix round. Green suites hid six to ten real breaks.
 5. **Read a gate's exit code directly**, never through a pipe in the same command (`| tail` hid a
    failed gate as success): write the output to a file, take the status, then read the file.
 6. **"Could not measure" is its own outcome.** An overloaded machine makes a gate refuse, and a
@@ -166,7 +166,7 @@ mechanism that held after the fix. Every rule is cheaper to build in than to ret
 9. **Probe live after every deploy on every consumer channel**, not the default one; read the
    nightly full-suite result first when resuming work, and release from a full local run, not a
    selected subset.
-10. **Port a protocol from the contract's shared vectors, never its prose** — vendored with a hash
+10. **Port a protocol from the contract's shared vectors, never its prose**, vendored with a hash
    per file and run case by case; a prose port accepted a year-0000 date the vectors refused.
 11. **Read an external contract from its raw documentation or a recorded live snapshot**, never
    from a summarising fetch; fail closed on a field nobody documented.
@@ -177,11 +177,11 @@ mechanism that held after the fix. Every rule is cheaper to build in than to ret
    concurrent worker has its own identity; a refused claim names the run that holds the task, never
    a guessed race against a lease that lapsed long ago; a copy that a
    supervisor started backs off on a held lock instead of exiting into a respawn loop. A failed
-   lease renewal is not a lost lease — stop only when the remaining margin runs out.
+   lease renewal is not a lost lease; stop only when the remaining margin runs out.
 2. **Health treats "never finished" as a fault.** Age each phase from its last completion; a
    phase that only ever yielded looked healthy for fifteen days.
 3. **Everything a run creates carries its owner** (run id, pid); the next start sweeps what a dead
-   owner left — markers, test databases, temp roots, container volumes. Nothing a long job needs
+   owner left: markers, test databases, temp roots, container volumes. Nothing a long job needs
    lives in a temp directory; a cleaner removed a test database mid-deploy.
 4. **Check disk and load before heavy work**, and serialize heavy suites behind a lock held for
    the whole run. A disk cleanup never deletes files version control tracks.
@@ -194,16 +194,16 @@ mechanism that held after the fix. Every rule is cheaper to build in than to ret
    seconds) answers a retryable "busy", never a crash or a deadlock; every pooled connection has
    an error listener, and readiness reports the store while liveness reports the process, so a
    database blip takes the instance out of traffic instead of restarting it.
-8. **Every accumulating output has a cap in the code that writes it** — logs, receipts, caches —
+8. **Every accumulating output has a cap in the code that writes it** (logs, receipts, caches),
    with both bounds tested.
 9. **Name the account and context on every cloud CLI call** and verify the account before a write;
    a saved default context once pointed a correct token at another team.
 10. **Log by error name and code**, never a driver's raw message, which can carry connection
-   details. A failed command logs its cause — deadline, signal, exit code, missing program — never a
+   details. A failed command logs its cause (deadline, signal, exit code, missing program), never a
    bare "command failed"; a watched dependency logs once when it fails and once when it recovers,
    never on every poll.
-11. **Admit work only when the machine can carry it** — free disk, swap, a cap on concurrent
-   sessions — and say why when you defer.
+11. **Admit work only when the machine can carry it** (free disk, swap, a cap on concurrent
+   sessions) and say why when you defer.
 
 12. **Keep blocking work off the workers that answer requests**, never let a read wait behind a long
    transaction, and log a transaction held long with the step that held it. Every blocking network