@vantageos/backend-doctor 0.1.0

package/dist/detectors/source/identity.d.ts

@@ -0,0 +1,47 @@
+import type { LiveDetector } from "@vantageos/mcp-doctor";
+import type { Detector, DetectorResult, Tree } from "../../engine-types.js";
+/** The standard both are pinned against (short hash a9d7877b), §15/§18. */
+export declare const IDENTITY_STANDARD_PIN = "analysis/vantagepeers/backend-standard/backend-standard.md @ a9d7877b4947ed8ae61d234433debb2182a2ba44 (elpiarthera/ElPi-Corp) \u00A715/\u00A718";
+type SrcFile = Tree["files"][number];
+/** A registrable entry — structurally the RegistryEntry the orchestrator spreads
+ * into REGISTRY. We do NOT import registry.ts; we mirror its shape so the
+ * orchestrator owns the integration (same discipline as security.ts). */
+export interface IdentityDetectorEntry {
+    detector: Detector;
+    ruleId: string;
+    standardPin: string;
+}
+interface Site {
+    rel: string;
+    n: number;
+    note: string;
+}
+interface Scan {
+    conform: Site[];
+    violate: Site[];
+    cnj: Site[];
+}
+export declare function scanR6(files: SrcFile[]): Scan;
+export declare function scanR16(files: SrcFile[]): Scan;
+/** A live-probe outcome for R-6: what a boundary-less write call returned. */
+export type LiveWriteOutcome = {
+    kind: "refused";
+    message: string;
+} | {
+    kind: "accepted";
+};
+/** Classify an R-6 live probe: a boundary-less write MUST be refused fail-closed. */
+export declare function classifyR6Live(id: string, tool: string, outcome: LiveWriteOutcome): DetectorResult;
+/** Classify an R-16 live probe: a triggered error MUST carry {code,field,message}. */
+export declare function classifyR16Live(id: string, payload: string): DetectorResult;
+/** Pull tool names from a served `tools/list` payload of unknown shape. */
+export declare function extractToolNames(payload: unknown): string[];
+/** True when a served tool result signals a refusal rather than a success. */
+export declare function looksLikeRefusal(res: unknown): boolean;
+/** R-6 — static primary + live secondary (LiveDetector). */
+export declare const R6: Detector & LiveDetector;
+/** R-16 — static primary + live secondary (LiveDetector). */
+export declare const R16: Detector & LiveDetector;
+/** The two, in a form the orchestrator spreads into REGISTRY. */
+export declare const IDENTITY_DETECTORS: IdentityDetectorEntry[];
+export {};

package/dist/detectors/source/identity.js

@@ -0,0 +1,410 @@
+/** The standard both are pinned against (short hash a9d7877b), §15/§18. */
+export const IDENTITY_STANDARD_PIN = "analysis/vantagepeers/backend-standard/backend-standard.md @ a9d7877b4947ed8ae61d234433debb2182a2ba44 (elpiarthera/ElPi-Corp) §15/§18";
+function emptyScan() {
+    return { conform: [], violate: [], cnj: [] };
+}
+function base(rel) {
+    return (rel.split("/").pop() ?? rel).toLowerCase();
+}
+/** a source file we should judge — never a test or generated file. */
+function isJudgeable(f) {
+    const b = base(f.rel);
+    return (!b.endsWith(".test.ts") &&
+        !f.rel.includes("__tests__") &&
+        !f.rel.includes("_generated/"));
+}
+/** an EXECUTING line (not a comment-only line). */
+function code(l) {
+    return !l.comment;
+}
+/** convex source only — R-6/R-16 govern the data layer's write handlers. */
+function isConvex(f) {
+    return /(^|\/)convex\//.test(f.rel);
+}
+/**
+ * Reduce a scan to ONE engine DetectorResult (identical precedence to the
+ * security.ts SOURCE kind): a concrete VIOLATION site is decisive; else any
+ * could-not-judge → could-not-judge WITH a reason; else any conform → present;
+ * else (zero applicable sites) → could-not-judge naming the empty scan. A found
+ * bad file:line is never a silent pass.
+ */
+function decide(ruleId, id, check, scan, emptyReason) {
+    const nC = scan.conform.length;
+    const nV = scan.violate.length;
+    const nJ = scan.cnj.length;
+    const breakdown = `[conform=${nC} non-conforming=${nV} could-not-judge=${nJ}]`;
+    const fmt = (s) => s
+        .slice(0, 3)
+        .map((x) => `${x.rel}:${x.n} (${x.note})`)
+        .join("; ");
+    if (nV > 0) {
+        return {
+            id,
+            anchor: `${scan.violate[0].rel}:${scan.violate[0].n}`,
+            state: "non-conforming",
+            verdict: `${ruleId}: ${nV} site(s) VIOLATE (${check}). ${breakdown} Violations: ${fmt(scan.violate)}.${nC ? ` Conform site(s): ${fmt(scan.conform)}.` : ""}`,
+        };
+    }
+    if (nJ > 0) {
+        const reason = `${ruleId}: ${nJ} site(s) could not be judged — ${fmt(scan.cnj)}. This is NOT a clean bill. ${breakdown}`;
+        return {
+            id,
+            anchor: `${scan.cnj[0].rel}:${scan.cnj[0].n}`,
+            state: "could-not-judge",
+            verdict: reason,
+            reason,
+        };
+    }
+    if (nC > 0) {
+        return {
+            id,
+            anchor: `${scan.conform[0].rel}:${scan.conform[0].n}`,
+            state: "present",
+            verdict: `${ruleId}: ${nC} applicable site(s) conform (${check}); 0 violations. ${breakdown} Conform: ${fmt(scan.conform)}.`,
+        };
+    }
+    return {
+        id,
+        anchor: "source:no-applicable-site",
+        state: "could-not-judge",
+        verdict: emptyReason,
+        reason: emptyReason,
+    };
+}
+/** Split a convex file into its top-level mutation/internalMutation handler
+ * blocks. A block runs from `export const <name> = mutation(` to the next
+ * top-level `export ` (or EOF). Queries/actions are not R-6 write handlers. */
+function splitMutationHandlers(f) {
+    const out = [];
+    const open = /export\s+const\s+(\w+)\s*=\s*(?:internalMutation|mutation)\s*\(/;
+    const topExport = /^export\s+/;
+    let cur = null;
+    for (const l of f.lines) {
+        const m = code(l) ? open.exec(l.raw) : null;
+        if (m) {
+            if (cur)
+                out.push(cur);
+            cur = { name: m[1], startN: l.n, lines: [l] };
+            continue;
+        }
+        if (cur) {
+            // a new top-level export that is NOT this handler's opener ends the block.
+            if (code(l) && topExport.test(l.raw)) {
+                out.push(cur);
+                cur = null;
+            }
+            else {
+                cur.lines.push(l);
+            }
+        }
+    }
+    if (cur)
+        out.push(cur);
+    return out;
+}
+// ---------------------------------------------------------------------------
+// R-6 — a write derives its org/tenant boundary from a VERIFIED IDENTITY claim
+// (or the TARGET resource) and refuses when absent — never from a caller-
+// supplied argument. (standard §15 line 71 / §18 line 395)
+//
+// SOURCE READ (see file header): memoriesScoped.storeMemoryScoped (identity via
+// resolveOrgId + assertNamespaceAllowed) and tasks.update/complete/start/
+// deleteTask (resource via assertTaskCallerAuthorized) are conform; tasks.create
+// and briefingNotes.create insert a boundary field taken from a caller arg with
+// NO guard — the violation.
+// ---------------------------------------------------------------------------
+const R6_WRITE = /ctx\.db\.(?:insert|patch|replace|delete)\s*\(/;
+const R6_IDENTITY_GUARD = /getUserIdentity|resolveOrgId|resolveOrgContext|assertNamespaceAllowed|expectedOrgIdForNamespace|tenantSlug|organizationId|organizationSlug|AUTH_NO_ORG|AUTH_NAMESPACE_DENIED/;
+const R6_RESOURCE_GUARD = /assertTaskCallerAuthorized|RBAC_DENIED|\.createdBy\s*===|\.assignedTo\s*===|\.orchestratorId\s*===|callerOrchestrator\s*===\s*["']system["']|note\.createdBy/;
+const R6_BOUNDARY_ARG = /\b(?:createdBy|orgId|orgSlug|namespace|orchestratorId|ownerId|tenantId)\b/;
+export function scanR6(files) {
+    const scan = emptyScan();
+    for (const f of files) {
+        if (!isJudgeable(f) || !isConvex(f))
+            continue;
+        for (const h of splitMutationHandlers(f)) {
+            let writeLine = 0;
+            let guard = false;
+            let boundaryArg = false;
+            for (const l of h.lines) {
+                if (!code(l))
+                    continue;
+                if (!writeLine && R6_WRITE.test(l.raw))
+                    writeLine = l.n;
+                if (R6_IDENTITY_GUARD.test(l.raw) || R6_RESOURCE_GUARD.test(l.raw))
+                    guard = true;
+                if (R6_BOUNDARY_ARG.test(l.raw))
+                    boundaryArg = true;
+            }
+            if (!writeLine)
+                continue; // not a write handler — R-6 does not govern it.
+            if (guard) {
+                scan.conform.push({
+                    rel: f.rel,
+                    n: writeLine,
+                    note: `${h.name}: boundary derived from a verified identity / target-resource guard`,
+                });
+            }
+            else if (boundaryArg) {
+                scan.violate.push({
+                    rel: f.rel,
+                    n: writeLine,
+                    note: `${h.name}: writes a boundary field (org/createdBy/namespace) taken from a caller argument with no identity/resource guard — the boundary is the argument`,
+                });
+            }
+            else {
+                scan.cnj.push({
+                    rel: f.rel,
+                    n: writeLine,
+                    note: `${h.name}: writes with no identity/resource guard and no clearly caller-supplied boundary field — deferred, not statically confirmed`,
+                });
+            }
+        }
+    }
+    return scan;
+}
+// ---------------------------------------------------------------------------
+// R-16 — a refusal returns a structured error {code, field/scope, message} and
+// defaults fail-closed. (standard §15 line 99 / §18 line 405)
+//
+// SOURCE READ: tasks.ts throws carry a stable UPPER_SNAKE_CASE code
+// (RBAC_DENIED, TASK_NOT_FOUND, TASK_START_BLOCKED, SCAN_CAP_EXCEEDED,
+// INVALID_RANGE, ...) plus interpolated `${JSON.stringify({...})}` context — the
+// conform contract shape. briefingNotes.ts throws
+// `new ConvexError("Unauthorized: ...")` — a refusal with NO structured code:
+// the violation. A generic validation throw ("invalid status: ...") is neither a
+// coded contract nor a security refusal — not counted here.
+// ---------------------------------------------------------------------------
+const R16_CODE_TOKEN = /\b[A-Z][A-Z0-9]*(?:_[A-Z0-9]+)+\b/;
+// authorization vocabulary — a REFUSAL, not a generic validation message. Kept
+// narrow on purpose: "not allowed" alone matched a tasks.ts array-alias
+// validation throw, which is not an R-16 refusal-contract site.
+const R16_REFUSAL_KW = /unauthori|forbidden|\bdenied\b|not creator|may not|permission|is not (?:the |a )?(?:creator|owner|authorized)/i;
+/** Collect every `new ConvexError(...)` / `new Error(...)` throw payload
+ * (multi-line, joined). A refusal thrown as a plain `Error` with no code is
+ * exactly the R-16 violation, so both throw kinds are read. */
+function collectConvexErrorThrows(f) {
+    const out = [];
+    const lines = f.lines;
+    for (let i = 0; i < lines.length; i++) {
+        const l = lines[i];
+        if (!code(l) || !/new (?:Convex)?Error\s*\(/.test(l.raw))
+            continue;
+        let payload = l.raw;
+        // gather until the throw statement closes (`);`) or a short window ends.
+        for (let j = i + 1; j < lines.length && j <= i + 6 && !/\)\s*;/.test(payload); j++) {
+            payload += `\n${lines[j].raw}`;
+        }
+        out.push({ n: l.n, payload });
+    }
+    return out;
+}
+export function scanR16(files) {
+    const scan = emptyScan();
+    for (const f of files) {
+        if (!isJudgeable(f) || !isConvex(f))
+            continue;
+        for (const t of collectConvexErrorThrows(f)) {
+            if (R16_CODE_TOKEN.test(t.payload)) {
+                scan.conform.push({
+                    rel: f.rel,
+                    n: t.n,
+                    note: "refusal carries a stable UPPER_SNAKE_CASE code + interpolated context",
+                });
+            }
+            else if (R16_REFUSAL_KW.test(t.payload)) {
+                scan.violate.push({
+                    rel: f.rel,
+                    n: t.n,
+                    note: "refusal thrown with no structured UPPER_SNAKE_CASE code — an opaque refusal a caller cannot branch on",
+                });
+            }
+            // else: a generic validation throw — not a structured-refusal contract site.
+        }
+    }
+    return scan;
+}
+// ---- static detector wrappers ---------------------------------------------
+const R6_ID = "R-6 write boundary from a verified identity, not a caller argument";
+const R16_ID = "R-16 refusal returns {code, field/scope, message}, fail-closed";
+const R6_CHECK = "a write derives its org/tenant boundary from a verified identity claim or the target resource, never a caller argument";
+const R16_CHECK = "a refusal throws a ConvexError with a stable UPPER_SNAKE_CASE code + context, never an opaque message";
+/** Classify an R-6 live probe: a boundary-less write MUST be refused fail-closed. */
+export function classifyR6Live(id, tool, outcome) {
+    if (outcome.kind === "accepted") {
+        return {
+            id,
+            anchor: `live:${tool}`,
+            state: "non-conforming",
+            verdict: `R-6 (live): tool "${tool}" ACCEPTED a write with no verified identity/boundary — fail-open.`,
+        };
+    }
+    if (/RBAC|AUTH|ORG|unauthori|denied|required|forbidden/i.test(outcome.message)) {
+        return {
+            id,
+            anchor: `live:${tool}`,
+            state: "present",
+            verdict: `R-6 (live): tool "${tool}" refused a boundary-less write fail-closed (${outcome.message.slice(0, 80)}).`,
+        };
+    }
+    const reason = `R-6 (live): tool "${tool}" refused, but the refusal names no boundary/identity/auth cause — cannot confirm it is R-6 fail-closed vs incidental validation. NOT a clean bill.`;
+    return {
+        id,
+        anchor: `live:${tool}`,
+        state: "could-not-judge",
+        verdict: reason,
+        reason,
+    };
+}
+/** Classify an R-16 live probe: a triggered error MUST carry {code,field,message}. */
+export function classifyR16Live(id, payload) {
+    const hasCode = R16_CODE_TOKEN.test(payload);
+    const hasMessage = payload.trim().length > 0;
+    if (hasCode && hasMessage) {
+        return {
+            id,
+            anchor: "live:error-contract",
+            state: "present",
+            verdict: `R-16 (live): a triggered refusal carried a structured UPPER_SNAKE_CASE code + message (${payload.slice(0, 80)}).`,
+        };
+    }
+    if (R16_REFUSAL_KW.test(payload)) {
+        return {
+            id,
+            anchor: "live:error-contract",
+            state: "non-conforming",
+            verdict: `R-16 (live): a triggered refusal carried NO structured code — opaque error contract (${payload.slice(0, 80)}).`,
+        };
+    }
+    const reason = `R-16 (live): could not trigger a classifiable refusal — the served response is neither a coded refusal nor a recognisable one. NOT a clean bill.`;
+    return {
+        id,
+        anchor: "live:error-contract",
+        state: "could-not-judge",
+        verdict: reason,
+        reason,
+    };
+}
+const R6_WRITE_TOOL = /create|update|delete|write|store|insert|complete|start|set_/i;
+async function r6RunLive(session) {
+    const cnj = (why) => ({
+        id: R6_ID,
+        anchor: "live:unavailable",
+        state: "could-not-judge",
+        verdict: `R-6 (live): ${why}`,
+        reason: `R-6 (live): ${why}`,
+    });
+    let tools;
+    try {
+        tools = await session.listTools();
+    }
+    catch (e) {
+        return cnj(`could not launch/introspect a running MCP session (listTools failed: ${String(e)}). Static half stands alone.`);
+    }
+    const names = extractToolNames(tools);
+    const target = names.find((n) => R6_WRITE_TOOL.test(n));
+    if (!target)
+        return cnj("the running server advertised no write tool to probe boundary-less.");
+    try {
+        const res = await session.callTool(target, {});
+        if (looksLikeRefusal(res)) {
+            return classifyR6Live(R6_ID, target, {
+                kind: "refused",
+                message: stringifyResult(res),
+            });
+        }
+        return classifyR6Live(R6_ID, target, { kind: "accepted" });
+    }
+    catch (e) {
+        return classifyR6Live(R6_ID, target, {
+            kind: "refused",
+            message: String(e),
+        });
+    }
+}
+async function r16RunLive(session) {
+    const cnj = (why) => ({
+        id: R16_ID,
+        anchor: "live:unavailable",
+        state: "could-not-judge",
+        verdict: `R-16 (live): ${why}`,
+        reason: `R-16 (live): ${why}`,
+    });
+    let tools;
+    try {
+        tools = await session.listTools();
+    }
+    catch (e) {
+        return cnj(`could not launch/introspect a running MCP session (listTools failed: ${String(e)}). Static half stands alone.`);
+    }
+    const names = extractToolNames(tools);
+    if (names.length === 0)
+        return cnj("the running server advertised no tool to trigger an error on.");
+    try {
+        // deliberately invalid args to trigger the error contract.
+        const res = await session.callTool(names[0], {
+            __backend_doctor_invalid__: true,
+        });
+        return classifyR16Live(R16_ID, stringifyResult(res));
+    }
+    catch (e) {
+        return classifyR16Live(R16_ID, String(e));
+    }
+}
+// ---- small helpers for the live probes (pure, testable) -------------------
+/** Pull tool names from a served `tools/list` payload of unknown shape. */
+export function extractToolNames(payload) {
+    const arr = Array.isArray(payload)
+        ? payload
+        : payload &&
+            typeof payload === "object" &&
+            Array.isArray(payload.tools)
+            ? payload.tools
+            : [];
+    const names = [];
+    for (const t of arr) {
+        if (t &&
+            typeof t === "object" &&
+            typeof t.name === "string") {
+            names.push(t.name);
+        }
+    }
+    return names;
+}
+/** True when a served tool result signals a refusal rather than a success. */
+export function looksLikeRefusal(res) {
+    if (!res || typeof res !== "object")
+        return false;
+    const r = res;
+    if (r.isError === true || r.error != null || typeof r.code === "string")
+        return true;
+    return (R16_REFUSAL_KW.test(stringifyResult(res)) ||
+        R16_CODE_TOKEN.test(stringifyResult(res)));
+}
+function stringifyResult(res) {
+    if (typeof res === "string")
+        return res;
+    try {
+        return JSON.stringify(res);
+    }
+    catch {
+        return String(res);
+    }
+}
+/** R-6 — static primary + live secondary (LiveDetector). */
+export const R6 = {
+    id: R6_ID,
+    run: (tree) => decide("R-6", R6_ID, R6_CHECK, scanR6(tree.files), "R-6: zero convex write handlers matched in the scanned tree — cannot certify boundary derivation. NOT a clean bill."),
+    runLive: r6RunLive,
+};
+/** R-16 — static primary + live secondary (LiveDetector). */
+export const R16 = {
+    id: R16_ID,
+    run: (tree) => decide("R-16", R16_ID, R16_CHECK, scanR16(tree.files), "R-16: zero ConvexError throw sites matched in the scanned convex tree — cannot certify the error contract. NOT a clean bill."),
+    runLive: r16RunLive,
+};
+/** The two, in a form the orchestrator spreads into REGISTRY. */
+export const IDENTITY_DETECTORS = [
+    { detector: R6, ruleId: "R-6", standardPin: IDENTITY_STANDARD_PIN },
+    { detector: R16, ruleId: "R-16", standardPin: IDENTITY_STANDARD_PIN },
+];

package/dist/detectors/source/jobs.d.ts

@@ -0,0 +1,10 @@
+import type { Detector } from "../../engine-types.js";
+import { type Scan, type SourceDetectorEntry, type SrcFile } from "./_scan.js";
+export declare function scanR19(files: SrcFile[]): Scan;
+export declare function scanR20(files: SrcFile[]): Scan;
+export declare function scanR23(files: SrcFile[]): Scan;
+export declare const R19: Detector;
+export declare const R20: Detector;
+export declare const R23: Detector;
+/** The three, in a form the orchestrator spreads into REGISTRY. */
+export declare const SOURCE_JOBS_DETECTORS: SourceDetectorEntry[];

package/dist/detectors/source/jobs.js

@@ -0,0 +1,209 @@
+import { base, code, emptyScan, isJudgeable, SOURCE_STANDARD_PIN, srcDetector, } from "./_scan.js";
+// ---------------------------------------------------------------------------
+// R-19 — a table holding personal data declares a retention period AND exposes
+// an executable subject-deletion path. (standard §15 line 117 / line 408)
+//
+// SOURCE READ: convex/schema.ts `licenses` (line 973) holds `customerEmail`
+// (line 975) and declares `expiresAt` (line 981, "purchasedAt + 365d") — a stated
+// retention duration in the same table block. The executable delete mechanism
+// lives in code: convex/memories.ts `softDeleteMemory` (line 341) +
+// `expireMemoriesByTtl` (line 376), convex/messages.ts `deleteMessage` (line 580).
+// PATTERN, two parts: (a) a schema table block carrying a personal-data field
+// (customerEmail / email / customerName) must declare a retention field
+// (expiresAt / ttl / deletedAt) WITHIN the block window — else violation; and
+// (b) a subject-deletion mechanism must exist SOMEWHERE in the scanned tree —
+// a table that states retention but where no delete path is visible is a
+// could-not-judge (retention alone is not erasure).
+// ---------------------------------------------------------------------------
+const PERSONAL_FIELD = /customeremail|customername|\bemail:\b|\bemail\s*:/i;
+const RETENTION_FIELD = /expiresat|ttl:|deletedat/i;
+const DELETE_MECHANISM = /softdelete|expire\w*byttl|deletemessage|ctx\.db\.delete\s*\(/i;
+const BLOCK_WINDOW = 40;
+function isSchema(f) {
+    return base(f.rel) === "schema.ts";
+}
+export function scanR19(files) {
+    const scan = emptyScan();
+    // Part (b): is a subject-deletion mechanism visible anywhere in the tree?
+    let deletePath = null;
+    for (const f of files) {
+        if (!isJudgeable(f))
+            continue;
+        for (const l of f.lines) {
+            if (code(l) && DELETE_MECHANISM.test(l.raw)) {
+                deletePath = { rel: f.rel, n: l.n };
+                break;
+            }
+        }
+        if (deletePath)
+            break;
+    }
+    for (const f of files) {
+        if (!isJudgeable(f) || !isSchema(f))
+            continue;
+        for (let i = 0; i < f.lines.length; i++) {
+            const l = f.lines[i];
+            if (!code(l) || !PERSONAL_FIELD.test(l.raw))
+                continue;
+            // look for a retention field within the surrounding table-block window.
+            let retention = 0;
+            for (let j = Math.max(0, i - BLOCK_WINDOW); j <= Math.min(f.lines.length - 1, i + BLOCK_WINDOW); j++) {
+                if (code(f.lines[j]) && RETENTION_FIELD.test(f.lines[j].raw)) {
+                    retention = f.lines[j].n;
+                    break;
+                }
+            }
+            if (!retention) {
+                scan.violate.push({
+                    rel: f.rel,
+                    n: l.n,
+                    note: "table holds a personal-data field but declares no retention duration (expiresAt/ttl/deletedAt) in the block — storage-limitation gap",
+                });
+            }
+            else if (!deletePath) {
+                scan.cnj.push({
+                    rel: f.rel,
+                    n: l.n,
+                    note: `retention declared (line ${retention}) but no subject-deletion mechanism (softDelete/expireByTtl/deleteMessage) visible in the scanned tree — retention alone is not erasure`,
+                });
+            }
+            else {
+                scan.conform.push({
+                    rel: f.rel,
+                    n: l.n,
+                    note: `personal-data table declares retention (line ${retention}) and a delete path exists at ${deletePath.rel}:${deletePath.n}`,
+                });
+            }
+        }
+    }
+    return scan;
+}
+// ---------------------------------------------------------------------------
+// R-20 — background/scheduled work is bounded per run and observable (logs each
+// run's outcome). (standard §15 line 119 / line 409)
+//
+// SOURCE READ: convex/recurringTasks.ts (the cron target `processDueTasks`)
+// bounds its scan with the TASK_LIST_SCAN_CAP wide-scan-cap pattern (line 128)
+// and logs each run's outcome with `console.log`/`console.error` (lines 347-360).
+// convex/crons.ts wires it on a numeric interval (`{ minutes: 15 }`, line 9).
+// PATTERN: a background-job handler file (recurring / monitor / sweep / poll /
+// resolver / cleanup) is conform iff it declares a numeric per-run bound (a
+// `.take(` / a `_CAP` / a `limit`) AND names an outcome log (`console.`). A job
+// file that collects unbounded or logs nothing is the violation.
+// ---------------------------------------------------------------------------
+const JOB_FILE = /recurring|monitor|sweep|poll|resolver|cleanup|digest|cron/i;
+const RUN_BOUND = /\.take\s*\(|_cap\b|\blimit\b/i;
+const OUTCOME_LOG = /console\.(log|error|warn|info)\s*\(/;
+function isJobFile(f) {
+    return JOB_FILE.test(base(f.rel));
+}
+export function scanR20(files) {
+    const scan = emptyScan();
+    for (const f of files) {
+        if (!isJudgeable(f) || !isJobFile(f))
+            continue;
+        let boundLine = 0;
+        let logLine = 0;
+        for (const l of f.lines) {
+            if (!code(l))
+                continue;
+            if (!boundLine && RUN_BOUND.test(l.raw))
+                boundLine = l.n;
+            if (!logLine && OUTCOME_LOG.test(l.raw))
+                logLine = l.n;
+        }
+        if (boundLine && logLine) {
+            scan.conform.push({
+                rel: f.rel,
+                n: boundLine,
+                note: `background job bounds its run (line ${boundLine}) and logs its outcome (line ${logLine})`,
+            });
+        }
+        else if (!boundLine) {
+            scan.violate.push({
+                rel: f.rel,
+                n: logLine || 1,
+                note: "background job declares no per-run bound (.take/_CAP/limit) — an unbounded run does not ship",
+            });
+        }
+        else {
+            scan.cnj.push({
+                rel: f.rel,
+                n: boundLine,
+                note: "background job bounds its run but no outcome log (console.*) found — observability not statically confirmed",
+            });
+        }
+    }
+    return scan;
+}
+// ---------------------------------------------------------------------------
+// R-23 — a public write / expensive read declares a numeric rate AND runtime
+// bound, or a written exception. (standard §15 line 125 / line 412)
+//
+// SOURCE READ: convex/credentials.ts issues a Bearer under a rate limit of
+// `maxPerWindow: 5` over `windowMs: 60_000` (lines 513-514), rejecting with a
+// `429` (line 523) — numeric rate + numeric window. PATTERN: a file that
+// references a rate-limit control (`rateLimit` / `maxPerWindow` / `windowMs`) is
+// conform iff BOTH a numeric window and a numeric max are present; a rate-limit
+// control whose bounds are only non-numeric placeholders (no numeric literal) is
+// the violation (unless a written exception is on file).
+// ---------------------------------------------------------------------------
+const RATE_REF = /ratelimit|maxperwindow|windowms|per\s+(minute|second|hour)/i;
+const NUMERIC_WINDOW = /windowms\s*:\s*\d|(\d[\d_]*)\s*(ms|_?000)\b|per\s+(minute|second|hour)/i;
+const NUMERIC_MAX = /maxperwindow\s*:\s*\d|\b\d+\s*(req|requests|per)\b/i;
+const WRITTEN_EXCEPTION = /allow-unbounded|written exception|rate-limit exception/i;
+function referencesRate(f) {
+    return f.lines.some((l) => code(l) && RATE_REF.test(l.raw));
+}
+export function scanR23(files) {
+    const scan = emptyScan();
+    for (const f of files) {
+        if (!isJudgeable(f) || !referencesRate(f))
+            continue;
+        let windowLine = 0;
+        let maxLine = 0;
+        let exception = 0;
+        for (const l of f.lines) {
+            if (!code(l))
+                continue;
+            if (!windowLine && NUMERIC_WINDOW.test(l.raw))
+                windowLine = l.n;
+            if (!maxLine && NUMERIC_MAX.test(l.raw))
+                maxLine = l.n;
+            if (!exception && WRITTEN_EXCEPTION.test(l.raw))
+                exception = l.n;
+        }
+        if (windowLine && maxLine) {
+            scan.conform.push({
+                rel: f.rel,
+                n: maxLine,
+                note: `rate control declares a numeric max (line ${maxLine}) and window (line ${windowLine})`,
+            });
+        }
+        else if (exception) {
+            scan.conform.push({
+                rel: f.rel,
+                n: exception,
+                note: `rate bound absent but a written exception is on file (line ${exception})`,
+            });
+        }
+        else {
+            scan.violate.push({
+                rel: f.rel,
+                n: windowLine || maxLine || 1,
+                note: "rate-limit control present but its bound is not numeric (placeholder) and no written exception on file",
+            });
+        }
+    }
+    return scan;
+}
+// ---- detectors ------------------------------------------------------------
+export const R19 = srcDetector("R-19", "R-19 personal data declares retention + a subject-deletion path", "a personal-data table declares a retention field and a delete mechanism exists in the tree", scanR19, "R-19: no personal-data table field matched in the scanned schema — cannot certify retention/erasure. NOT a clean bill.");
+export const R20 = srcDetector("R-20", "R-20 background work is bounded and observable", "a background job declares a numeric per-run bound and logs its outcome", scanR20, "R-20: no background-job handler file matched in the scanned tree — cannot certify bounded/observable jobs. NOT a clean bill.");
+export const R23 = srcDetector("R-23", "R-23 rate + runtime bound declared or written exception", "a rate-limit control declares a numeric max and window, or a written exception is on file", scanR23, "R-23: no rate-limit control referenced in the scanned tree — cannot certify the rate/runtime bound. NOT a clean bill.");
+/** The three, in a form the orchestrator spreads into REGISTRY. */
+export const SOURCE_JOBS_DETECTORS = [
+    { detector: R19, ruleId: "R-19", standardPin: SOURCE_STANDARD_PIN },
+    { detector: R20, ruleId: "R-20", standardPin: SOURCE_STANDARD_PIN },
+    { detector: R23, ruleId: "R-23", standardPin: SOURCE_STANDARD_PIN },
+];

package/dist/detectors/source/lifecycle.d.ts

@@ -0,0 +1,6 @@
+import type { Detector } from "../../engine-types.js";
+import { type Scan, type SourceDetectorEntry, type SrcFile } from "./_scan.js";
+export declare function scanR43(files: SrcFile[]): Scan;
+export declare const R43: Detector;
+/** In the form the orchestrator spreads into REGISTRY. */
+export declare const SOURCE_LIFECYCLE_DETECTORS: SourceDetectorEntry[];