@vantageos/backend-doctor 0.1.2 → 0.1.4

package/README.md

@@ -81,7 +81,7 @@ A `could-not-judge` rule is an **abstention** — a human verdict is owed, never
 
 Every input is pinned and, where it is a vendored document, proven byte-identical to its upstream git blob (an un-hashable vendored doc is an authority granted to oneself).
 
-**The single authority for which standard fixture is active is the loader constant** `STANDARD_FILE` in [`src/detectors/standard/_doc.ts`](./src/detectors/standard/_doc.ts) — currently `backend-standard-4265226e.md` (49 rules — adds R-50, org isolation on a subscribed read is a typed empty result, never an uncaught throw; canonical source: ElPi-Corp `analysis/vantagepeers/backend-standard/backend-standard.md`). Everything else is provenance, NOT the active pin: `PINS.txt` and any other `fixtures/backend-standard-<sha>.md` still in the tree (e.g. the superseded `backend-standard-a9d7877b.md`, 47 rules — it lacks R-48) are kept only to show what was scored before. If any of them disagrees with `STANDARD_FILE`, `STANDARD_FILE` wins. Read the active pin from `STANDARD_FILE`, never from `PINS.txt` or a number typed elsewhere — following a stale `PINS.txt` would silently score the superseded 47-rule document and never surface R-48. See [`PINS.txt`](./PINS.txt) for the engine, backend snapshot, and MCP-family doc + VR inventory pins.
+**The single authority for which standard fixture is active is the loader constant** `STANDARD_FILE` in [`src/detectors/standard/_doc.ts`](./src/detectors/standard/_doc.ts) — currently `backend-standard-4bcd605.md` (50 rules — R-50/R-51, org isolation on a subscribed read / a pre-org write is a typed empty/unauthorised result, never an uncaught throw; at this pin a gated `customQuery`/`customMutation` wrapper is JUDGED red/green from its readable `customCtx`, not could-not-judge; canonical source: ElPi-Corp `analysis/vantagepeers/backend-standard/backend-standard.md`). Everything else is provenance, NOT the active pin: `PINS.txt` and any other `fixtures/backend-standard-<sha>.md` still in the tree (e.g. the superseded `backend-standard-a9d7877b.md`, 47 rules — it lacks R-48) are kept only to show what was scored before. If any of them disagrees with `STANDARD_FILE`, `STANDARD_FILE` wins. Read the active pin from `STANDARD_FILE`, never from `PINS.txt` or a number typed elsewhere — following a stale `PINS.txt` would silently score the superseded 47-rule document and never surface R-48. See [`PINS.txt`](./PINS.txt) for the engine, backend snapshot, and MCP-family doc + VR inventory pins.
 
 ## Discipline (how a detector is proven)
 

package/dist/coverage.d.ts

@@ -4,7 +4,7 @@
  * canonical 48-rule standard (51ec7af1) to 2bb402f7, which closes R-7/R-8/R-37/R-40
  * as a written-justification-token control (§23) — the paired standard PR the four
  * decisive detectors below track. Still 48 rules; the pin moves forward with them. */
-export declare const STANDARD_SHA = "4265226eb6698c7dfbae3ced77df564e877908ad";
+export declare const STANDARD_SHA = "4bcd605656ceff52d4f1593a9176cd6b988471be";
 export declare const VENDORED_STANDARD_PATH: string;
 /**
  * Derive the full rule list R-1..R-42 from the VENDORED standard fixture —

package/dist/coverage.js

@@ -18,8 +18,8 @@ const here = dirname(fileURLToPath(import.meta.url));
  * canonical 48-rule standard (51ec7af1) to 2bb402f7, which closes R-7/R-8/R-37/R-40
  * as a written-justification-token control (§23) — the paired standard PR the four
  * decisive detectors below track. Still 48 rules; the pin moves forward with them. */
-export const STANDARD_SHA = "4265226eb6698c7dfbae3ced77df564e877908ad";
-export const VENDORED_STANDARD_PATH = join(here, "..", "fixtures", "backend-standard-4265226e.md");
+export const STANDARD_SHA = "4bcd605656ceff52d4f1593a9176cd6b988471be";
+export const VENDORED_STANDARD_PATH = join(here, "..", "fixtures", "backend-standard-4bcd605.md");
 /**
  * Derive the full rule list R-1..R-42 from the VENDORED standard fixture —
  * never typed, never a git show against a local repo. Reads the `**R-NN`

package/dist/detectors/oracle-axis1.js

@@ -29,7 +29,7 @@ export const VR_ORACLE_PATH = join(here, "..", "..", "fixtures", "vr-by-tool-day
  * §2 [shared] contract columns are DERIVED from this file, never hardcoded.
  * Defined locally (not imported from coverage.ts) to avoid a registry ↔ coverage
  * import cycle. */
-export const VENDORED_STANDARD_PATH = join(here, "..", "..", "fixtures", "backend-standard-4265226e.md");
+export const VENDORED_STANDARD_PATH = join(here, "..", "..", "fixtures", "backend-standard-4bcd605.md");
 /** Load any backend inventory CSV generically from its OWN header — the shared
  * fields are DERIVED from these real headers, never a prose illustration. */
 export function loadInventory(path) {

package/dist/detectors/source/isolation.js

@@ -91,8 +91,16 @@ function discoverBuilders(files) {
                 const gates = ORG_THROW.test(codeRegion) ||
                     ORG_THROW_HELPER.test(codeRegion) ||
                     GATE_HELPER.test(codeRegion);
-                if (gates && !CONTRACT_MARKER.test(rawRegion))
-                    b.gated.set(name, { rel: f.rel, n: l.n });
+                if (gates && !CONTRACT_MARKER.test(rawRegion)) {
+                    // The wrapper's customCtx body is READABLE — judge its no-org
+                    // disposition: a typed empty/unauthorized return means the
+                    // subscription receives a shape (conform); otherwise the gate
+                    // throws NO_ORG into every subscribed query built from it
+                    // (non-conforming). No CNJ on this class — the wrapper source is
+                    // visible, so R-50 judges it.
+                    const typedEmpty = TYPED_EMPTY_RETURN.test(codeRegion);
+                    b.gated.set(name, { rel: f.rel, n: l.n, throws: !typedEmpty });
+                }
             }
             else if (base === BASE_INTERNAL_QUERY)
                 b.nonSubject.add(name);
@@ -128,6 +136,9 @@ const ORG_THROW_HELPER = /\b(?:requireWorkspaceId|requireOrgId|requireOrgSlug|ge
 // subscribing client always receives a shape it can render.
 const SAFE_RESOLVER = /\bwithOrgScope\s*\(/;
 const CONTRACT_MARKER = /isolation-contract:|client-safe-empty|@client-must-not-subscribe/i;
+// A TYPED EMPTY / UNAUTHORIZED RETURN in a wrapper's customCtx (or a handler): the
+// no-org path returns a shape the subscribing client can render instead of throwing.
+const TYPED_EMPTY_RETURN = /return\s+\{[^}]*\b(?:unauthorized|forbidden|noOrg|no_org|denied|empty)\b|return\s+\{[^}]*\b(?:orgSlug|orgId)\s*:\s*null\b|return\s+\{\s*items\s*:\s*\[\s*\]/i;
 /** delimit a function body from its opener at index i by matching braces. */
 function queryBlock(lines, i) {
     let depth = 0;
@@ -164,13 +175,14 @@ export function scanR50(files) {
             note: `builder "${a.name}" = customQuery(${a.base}, …) — its base "${a.base}" resolves to neither \`query\` (public) nor \`internalQuery\`, so whether definitions using it are subscribed queries cannot be enumerated; R-50 refuses rather than certify a surface it cannot see (never a silent green)`,
         });
     }
-    // A GATED public customQuery builder: its customCtx runs an auth/org gate that can
-    // throw, so every subscribed query built from it inherits that throw in the shared
-    // wrapper — invisible to a per-handler scan. REFUSE per builder (could-not-judge),
-    // naming it and counting its dependent subscribed queries, so a customQuery
-    // codebase never reads "R-50 clean" by the opener simply not looking into the
-    // wrapper. (The remedy a human confirms: the wrapper returns a typed empty/unauth
-    // context on the no-org path, or documents an isolation-contract on the builder.)
+    // A GATED public customQuery builder: its customCtx runs an auth/org gate, so
+    // every subscribed query built from it inherits that gate's no-org disposition in
+    // the shared wrapper. That disposition is READABLE in the wrapper's own customCtx
+    // body (unlike a bare handler, where "does a client reach it pre-org" is not
+    // visible), so R-50 JUDGES the builder — never CNJ on this class: a wrapper that
+    // throws NO_ORG with no typed-empty return fires an uncaught Server Error into
+    // every subscription (non-conforming); a wrapper that returns a typed empty/
+    // unauthorized context on the no-org path hands the subscription a shape (conform).
     for (const [name, at] of builders.gated) {
         let deps = 0;
         for (const f of files) {
@@ -184,11 +196,20 @@ export function scanR50(files) {
                     deps += 1;
             }
         }
-        scan.cnj.push({
-            rel: at.rel,
-            n: at.n,
-            note: `customQuery builder "${name}" gates every query built from it in its customCtx (an auth/org require*/throw), and ${deps} subscribed query(ies) route through it — whether that wrapper THROWS into a subscription or returns a typed empty/unauthorized context on the no-org path is not decidable from the query surface. R-50 refuses (a human confirms the wrapper's no-org shape, or the builder carries an isolation-contract marker) — never a silent green obtained by not looking into the wrapper`,
-        });
+        if (at.throws) {
+            scan.violate.push({
+                rel: at.rel,
+                n: at.n,
+                note: `customQuery builder "${name}" gates in its shared customCtx (an auth/org require*/throw) and returns NO typed-empty context on the no-org path — the throw fires into the ${deps} subscribed query(ies) that route through it as an uncaught Server Error the client cannot catch. Return a typed empty/unauthorized context from the wrapper's customCtx on no-org, or document an isolation-contract marker on the builder`,
+            });
+        }
+        else {
+            scan.conform.push({
+                rel: at.rel,
+                n: at.n,
+                note: `customQuery builder "${name}" gates in its shared customCtx but returns a typed empty/unauthorized context on the no-org path (no throw) — the ${deps} subscribed query(ies) built from it receive a shape the client can render, not an uncaught throw`,
+            });
+        }
     }
     for (const f of files) {
         if (!isJudgeable(f))

package/dist/detectors/source/write-isolation.d.ts

@@ -0,0 +1,5 @@
+import type { Detector } from "../../engine-types.js";
+import { type Scan, type SourceDetectorEntry, type SrcFile } from "./_scan.js";
+export declare function scanR51(files: SrcFile[]): Scan;
+export declare const R51: Detector;
+export declare const SOURCE_WRITE_ISOLATION_DETECTORS: SourceDetectorEntry[];

package/dist/detectors/source/write-isolation.js

@@ -0,0 +1,226 @@
+import { code, emptyScan, isJudgeable, SOURCE_STANDARD_PIN, srcDetector, } from "./_scan.js";
+const CUSTOM_MUTATION_OPEN = /(?:export\s+)?const\s+([A-Za-z0-9_]+)\s*=\s*customMutation\s*\(/;
+const CUSTOM_QUERY_DEF = /(?:export\s+)?const\s+([A-Za-z0-9_]+)\s*=\s*customQuery\s*\(/;
+const FIRST_IDENT = /([A-Za-z_][A-Za-z0-9_]*)/;
+const BASE_PUBLIC_MUTATION = "mutation";
+const BASE_INTERNAL_MUTATION = "internalMutation";
+// A no-org throw a write inherits: an org-keyed ConvexError, or a write/org gate
+// helper that throws when no org is resolved.
+const ORG_THROW = /throw\b[^;]*\b(?:NO_ORG|ORG_REQUIRED|RBAC_DENIED|no org|missing org|organization is required|not in (?:an )?org)/i;
+const WRITE_GATE_HELPER = /\b(?:requireWriteAccess|requireWorkspaceId|requireOrgId|getEffectiveWorkspaceId|getOrgIdOrThrow|ensureCurrentOrg)\s*\(/;
+// a gate helper generally (any require*/ensure*/assert* access check in a wrapper).
+const GATE_HELPER = /\b(?:require|ensure|assert)[A-Z][A-Za-z0-9_]*\s*\(/;
+// a TYPED unauthorized RESULT — the write returns a shape instead of throwing.
+const TYPED_UNAUTH_RETURN = /return\s+\{[^}]*\b(?:unauthorized|forbidden|noOrg|no_org|denied|ok\s*:\s*false)\b/i;
+const CONTRACT_MARKER = /write-contract:|client-must-not-write-before-org|isolation-contract:/i;
+function discoverWriteBuilders(files) {
+    const b = {
+        publicMutation: new Set([BASE_PUBLIC_MUTATION]),
+        nonSubject: new Set([
+            BASE_INTERNAL_MUTATION,
+            "query",
+            "internalQuery",
+            "action",
+            "internalAction",
+            "httpAction",
+        ]),
+        gated: new Map(),
+        ambiguous: [],
+    };
+    for (const f of files) {
+        if (!isJudgeable(f))
+            continue;
+        const codeLines = f.lines.filter(code);
+        const allLines = f.lines;
+        for (let i = 0; i < codeLines.length; i++) {
+            const l = codeLines[i];
+            // a customQuery wrapper is a READ builder — not R-51's subject.
+            if (CUSTOM_QUERY_DEF.test(l.raw))
+                continue;
+            const cm = CUSTOM_MUTATION_OPEN.exec(l.raw);
+            if (!cm)
+                continue;
+            const name = cm[1];
+            const afterOpen = l.raw.slice((cm.index ?? 0) + cm[0].length);
+            let base = FIRST_IDENT.exec(afterOpen)?.[1];
+            for (let j = i + 1; !base && j < codeLines.length && j <= i + 4; j++) {
+                base = FIRST_IDENT.exec(codeLines[j].raw)?.[1];
+            }
+            if (base === BASE_PUBLIC_MUTATION) {
+                b.publicMutation.add(name);
+                const codeRegion = codeLines
+                    .slice(i, i + 10)
+                    .map((x) => x.raw)
+                    .join("\n");
+                const startAbs = allLines.indexOf(l);
+                const rawRegion = startAbs >= 0
+                    ? allLines
+                        .slice(Math.max(0, startAbs - 3), startAbs + 14)
+                        .map((x) => x.raw)
+                        .join("\n")
+                    : codeRegion;
+                const gates = ORG_THROW.test(codeRegion) ||
+                    WRITE_GATE_HELPER.test(codeRegion) ||
+                    GATE_HELPER.test(codeRegion);
+                if (gates && !CONTRACT_MARKER.test(rawRegion)) {
+                    // The wrapper's customCtx is readable — judge its no-org disposition:
+                    // a typed unauthorized return means writes receive a shape (conform);
+                    // otherwise the gate throws NO_ORG into every write (non-conforming).
+                    const typedUnauth = TYPED_UNAUTH_RETURN.test(codeRegion);
+                    b.gated.set(name, { rel: f.rel, n: l.n, throws: !typedUnauth });
+                }
+            }
+            else if (base === BASE_INTERNAL_MUTATION)
+                b.nonSubject.add(name);
+            else
+                b.ambiguous.push({
+                    rel: f.rel,
+                    n: l.n,
+                    name,
+                    base: base ?? "<unresolved>",
+                });
+        }
+    }
+    return b;
+}
+function definitionOpener(raw, set) {
+    const names = [...set].sort((a, z) => z.length - a.length);
+    const alt = names.map((n) => n.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|");
+    const re = new RegExp(`(?:export\\s+)?const\\s+([A-Za-z0-9_]+)\\s*=\\s*(${alt})\\s*\\(`);
+    const m = re.exec(raw);
+    return m ? { name: m[1], builder: m[2] } : null;
+}
+function mutationBlock(lines, i) {
+    let depth = 0;
+    let seenOpen = false;
+    const body = [];
+    for (let j = i; j < lines.length; j++) {
+        const l = lines[j];
+        body.push(l);
+        for (const ch of l.raw) {
+            if (ch === "{") {
+                depth += 1;
+                seenOpen = true;
+            }
+            else if (ch === "}")
+                depth -= 1;
+        }
+        if (seenOpen && depth <= 0)
+            return { lines: body, unterminated: false };
+    }
+    return { lines: body, unterminated: seenOpen };
+}
+export function scanR51(files) {
+    const scan = emptyScan();
+    const builders = discoverWriteBuilders(files);
+    for (const a of builders.ambiguous) {
+        scan.cnj.push({
+            rel: a.rel,
+            n: a.n,
+            note: `write builder "${a.name}" = customMutation(${a.base}, …) — its base "${a.base}" resolves to neither \`mutation\` nor \`internalMutation\`, so whether definitions using it are public writes cannot be enumerated; R-51 refuses rather than certify a surface it cannot see`,
+        });
+    }
+    for (const [name, at] of builders.gated) {
+        let deps = 0;
+        for (const f of files) {
+            if (!isJudgeable(f))
+                continue;
+            for (const l of f.lines) {
+                if (!code(l))
+                    continue;
+                if (definitionOpener(l.raw, new Set([name])))
+                    deps += 1;
+            }
+        }
+        if (at.throws) {
+            scan.violate.push({
+                rel: at.rel,
+                n: at.n,
+                note: `customMutation builder "${name}" gates every write built from it in its shared customCtx (requireWriteAccess/an org gate that throws) and returns NO typed-unauthorized result on the no-org path — the throw fires into the ${deps} public write(s) that route through it as an uncaught Server Error a pre-org client shell cannot render. Return a typed unauthorized result from the wrapper's customCtx on no-org, or document a write-contract marker on the builder asserting a client cannot reach these pre-org`,
+            });
+        }
+        else {
+            scan.conform.push({
+                rel: at.rel,
+                n: at.n,
+                note: `customMutation builder "${name}" gates in its shared customCtx but returns a typed unauthorized result on the no-org path (no throw) — the ${deps} public write(s) built from it receive a shape a pre-org client can render, not an uncaught Server Error`,
+            });
+        }
+    }
+    for (const f of files) {
+        if (!isJudgeable(f))
+            continue;
+        const lines = f.lines;
+        for (let i = 0; i < lines.length; i++) {
+            if (!code(lines[i]))
+                continue;
+            const opener = definitionOpener(lines[i].raw, builders.publicMutation);
+            if (!opener)
+                continue;
+            // a write built through a GATED customMutation wrapper is covered by the
+            // builder-level refusal above — skip the per-handler pass.
+            if (builders.gated.has(opener.builder))
+                continue;
+            const block = mutationBlock(lines, i);
+            i += block.lines.length - 1;
+            const fn = opener.name;
+            if (block.unterminated) {
+                scan.cnj.push({
+                    rel: f.rel,
+                    n: block.lines[0].n,
+                    note: `${fn}: a public mutation block could not be delimited (unbalanced braces) — whether its no-org path throws or returns a typed unauthorized result is not statically decidable; a human must judge (never a silent PASS)`,
+                });
+                continue;
+            }
+            const blockText = block.lines
+                .filter(code)
+                .map((l) => l.raw)
+                .join("\n");
+            const blockAll = block.lines.map((l) => l.raw).join("\n");
+            const throwsOnNoOrg = ORG_THROW.test(blockText) || WRITE_GATE_HELPER.test(blockText);
+            const typedUnauth = TYPED_UNAUTH_RETURN.test(blockText);
+            const hasMarker = CONTRACT_MARKER.test(blockAll);
+            if (!throwsOnNoOrg && !typedUnauth && !hasMarker)
+                continue; // not a subject
+            if (typedUnauth) {
+                // The write returns a shape on the no-org path — a pre-org client can render
+                // it, not an uncaught Server Error. Green.
+                scan.conform.push({
+                    rel: f.rel,
+                    n: block.lines[0].n,
+                    note: `${fn}: public mutation returns a typed unauthorized result on the no-org path — a pre-org client receives a shape it can render, not an uncaught Server Error`,
+                });
+            }
+            else if (hasMarker) {
+                // A throwing write that CARRIES a write-contract marker: the marker is the
+                // author's recorded claim that a client cannot reach this write pre-org —
+                // a claim the reviewer verifies, not one convex/ can prove. could-not-judge
+                // (Eta #141 REVISE: CNJ is reserved for the marker-borne claim, not the
+                // bare accusation).
+                scan.cnj.push({
+                    rel: f.rel,
+                    n: block.lines[0].n,
+                    note: `${fn}: public mutation throws on the missing-org path AND carries a write-contract marker — the marker records a claim that a client cannot reach this write before an org exists, which convex/ cannot verify. R-51 refuses (a reviewer checks the marker's claim) — never a silent green`,
+                });
+            }
+            else {
+                // Bare throwing write: no typed-unauthorized return AND no write-contract
+                // marker — the two absences are both readable in convex/. The accusation
+                // stands (an uncaught Server Error on any pre-org render path) until the
+                // author returns a shape or records the unreachability claim. RED, never
+                // CNJ (Eta #141 REVISE: deleting this red deletes the only pressure to
+                // write the marker).
+                scan.violate.push({
+                    rel: f.rel,
+                    n: block.lines[0].n,
+                    note: `${fn}: public mutation throws on the missing-org path (org-keyed ConvexError or requireWriteAccess/requireWorkspaceId/getEffectiveWorkspaceId) with NO typed-unauthorized return and NO write-contract marker — both absences readable in convex/. A pre-org client shell issuing this write receives an uncaught Server Error. Return a typed unauthorized result, or record a write-contract marker if a client cannot reach it pre-org`,
+                });
+            }
+        }
+    }
+    return scan;
+}
+export const R51 = srcDetector("R-51", "R-51 a public mutation returns a typed unauthorized result on the no-org path, never an uncaught throw a pre-org client shell cannot render", "a public write either returns a typed unauthorized result / documents its client contract, or a human confirms a pre-org client cannot reach it — it never throws NO_ORG on a path an ordinary render can hit", scanR51, "R-51: no public mutation matched in the scanned tree — no write to certify. NOT a clean bill.");
+export const SOURCE_WRITE_ISOLATION_DETECTORS = [
+    { detector: R51, ruleId: "R-51", standardPin: SOURCE_STANDARD_PIN },
+];

package/dist/detectors/standard/_doc.d.ts

@@ -1,6 +1,6 @@
 import type { Detector, DetectorResult } from "../../engine-types.js";
 /** The vendored-fixture basename used as the anchor file for every doc site. */
-export declare const STANDARD_FILE = "backend-standard-4265226e.md";
+export declare const STANDARD_FILE = "backend-standard-4bcd605.md";
 export declare const VENDORED_STANDARD_PATH: string;
 /** The standard all four are pinned against (short hash a9d7877b). */
 export declare const STANDARD_DOC_PIN = "analysis/vantagepeers/backend-standard/backend-standard.md @ a9d7877b4947ed8ae61d234433debb2182a2ba44 (elpiarthera/ElPi-Corp) \u00A714/\u00A711/\u00A710/\u00A73";

package/dist/detectors/standard/_doc.js

@@ -2,7 +2,7 @@
 // detectors that read THE STANDARD ITSELF as their material — R-42, R-15, R-32,
 // R-39. Unlike the source-tree detectors (which read convex/ via `tree.files`)
 // and the oracle detectors (which read the CSV), these read the VENDORED standard
-// fixture `fixtures/backend-standard-4265226e.md` — the material at the pin. The
+// fixture `fixtures/backend-standard-4bcd605.md` — the material at the pin. The
 // engine's contract types are DERIVED from engine-types.ts, never re-spelled.
 //
 // THE LAW (the one that caught R-5): every predicate is derived from the ACTUAL
@@ -13,7 +13,7 @@ import { readFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 /** The vendored-fixture basename used as the anchor file for every doc site. */
-export const STANDARD_FILE = "backend-standard-4265226e.md";
+export const STANDARD_FILE = "backend-standard-4bcd605.md";
 /** The vendored standard at the pin — DATA on the same footing as the oracle CSV.
  * Resolved locally (not via coverage.ts) so this module carries no import cycle
  * with registry.ts. Same file coverage.ts's VENDORED_STANDARD_PATH points at. */

package/dist/not-checkable.js

@@ -16,7 +16,7 @@
 // gentler word — it was emptied.
 import { STANDARD_FILE } from "./detectors/standard/_doc.js";
 export const NOT_MECHANICALLY_CHECKABLE = {
-    "R-48": "R-48 authority-totality detector pending — task k17chpr4kzp399j3s7r7edpm4s8cscbz; text pinned at 4265226e so coverage cannot pretend 47 is complete. No mechanical control yet; R-48 is enumerated and visible, never silently dropped.",
+    "R-48": "R-48 authority-totality detector pending — task k17chpr4kzp399j3s7r7edpm4s8cscbz; text pinned at 4bcd605 so coverage cannot pretend 47 is complete. No mechanical control yet; R-48 is enumerated and visible, never silently dropped.",
 };
 /**
  * One `could-not-judge` DetectorResult per NOT_MECHANICALLY_CHECKABLE rule, so

package/dist/registry.d.ts

@@ -1,6 +1,6 @@
 import type { Detector } from "./engine-types.js";
 /** The standard both pins the whole wave against. */
-export declare const STANDARD_PIN = "analysis/vantagepeers/backend-standard/backend-standard.md @ 4265226eb6698c7dfbae3ced77df564e877908ad (elpiarthera/ElPi-Corp)";
+export declare const STANDARD_PIN = "analysis/vantagepeers/backend-standard/backend-standard.md @ 4bcd605656ceff52d4f1593a9176cd6b988471be (elpiarthera/ElPi-Corp)";
 export interface RegistryEntry {
     detector: Detector;
     ruleId: string;

package/dist/registry.js

@@ -14,13 +14,14 @@ import { SOURCE_LIFECYCLE_DETECTORS } from "./detectors/source/lifecycle.js";
 import { SOURCE_READBUDGET_DETECTORS } from "./detectors/source/readbudget.js";
 import { SOURCE_REFUSAL_DETECTORS } from "./detectors/source/refusal.js";
 import { SOURCE_SECURITY_DETECTORS } from "./detectors/source/security.js";
+import { SOURCE_WRITE_ISOLATION_DETECTORS } from "./detectors/source/write-isolation.js";
 import { SOURCE_WRITESAFETY_DETECTORS } from "./detectors/source/writesafety.js";
 import { R41, SIBLING_PIN } from "./detectors/standard/r41-frontier.js";
 import { R46_STANDARD_PIN, STANDARD_SOURCE_DETECTORS, } from "./detectors/standard/r46-returns-validator.js";
 import { STANDARD_DOC_DETECTORS } from "./detectors/standard/standard-doc.js";
 import { makeR14, makeR38 } from "./detectors/structural.js";
 /** The standard both pins the whole wave against. */
-export const STANDARD_PIN = "analysis/vantagepeers/backend-standard/backend-standard.md @ 4265226eb6698c7dfbae3ced77df564e877908ad (elpiarthera/ElPi-Corp)";
+export const STANDARD_PIN = "analysis/vantagepeers/backend-standard/backend-standard.md @ 4bcd605656ceff52d4f1593a9176cd6b988471be (elpiarthera/ElPi-Corp)";
 export const REGISTRY = [
     ...PER_ROW_PREDICATES.map((spec) => ({
         detector: makeOracleDetector(spec),
@@ -108,6 +109,12 @@ export const REGISTRY = [
         // workspaces:ensureCurrent + prefs:sidebar). Extends the R-11 isolation
         // family; a mutation refusing an unauthorized write (R-16) is out of scope.
         ...SOURCE_ISOLATION_DETECTORS,
+        // R-51 — the WRITE counterpart of R-50: a public mutation whose no-org path
+        // throws NO_ORG (requireWriteAccess/getEffectiveWorkspaceId) into a pre-org
+        // client shell is a VIOLATION unless it returns a typed unauthorised result or
+        // documents a client contract; a gated customMutation wrapper (writeMutation) is
+        // refused (could-not-judge) since client reachability is not visible from convex/.
+        ...SOURCE_WRITE_ISOLATION_DETECTORS,
         ...SOURCE_CONTRACT_DETECTORS,
         ...IDENTITY_DETECTORS,
         // The four STANDARD-DOCUMENT detectors (R-42/R-15/R-32/R-39): each reads the