prism-mcp-server 20.2.6 → 20.2.7

package/dist/utils/braveApi.js

@@ -30,21 +30,24 @@
  */
 import { BRAVE_API_KEY, BRAVE_ANSWERS_API_KEY } from "../config.js";
 import { SYNALUX_SEARCH_AVAILABLE, synaluxWebSearch, synaluxWebSearchRaw, synaluxLocalSearch, synaluxLocalSearchRaw, synaluxBraveAnswers, } from "./synaluxSearch.js";
-import { debugLog } from "./logger.js";
+const BRAVE_API_KEY_MISSING_ERROR = "BRAVE_API_KEY is not configured";
+const BRAVE_ANSWERS_API_KEY_MISSING_ERROR = "BRAVE_ANSWERS_API_KEY is not configured";
+const SYNALUX_OFFSET_UNSUPPORTED_ERROR = "Configured Synalux search does not support search offsets";
+function requireBraveApiKey() {
+    if (!BRAVE_API_KEY)
+        throw new Error(BRAVE_API_KEY_MISSING_ERROR);
+    return BRAVE_API_KEY;
+}
 // Brave Answers API call (AI Grounding/OpenAI-compatible)
 export async function performBraveAnswers(query, model = "brave") {
-    // Route through Synalux portal when available
+    // A configured Synalux account is a privacy boundary: provider
+    // credentials and redaction stay portal-side. Never escape to a direct
+    // provider with the original query when that portal request fails.
     if (SYNALUX_SEARCH_AVAILABLE) {
-        try {
-            return await synaluxBraveAnswers(query, model);
-        }
-        catch (err) {
-            debugLog(`[braveApi] Synalux answers failed, falling back to Brave: ${err instanceof Error ? err.message : String(err)}`);
-            // Fall through to direct Brave API
-        }
+        return synaluxBraveAnswers(query, model);
     }
     if (!BRAVE_ANSWERS_API_KEY) {
-        throw new Error("BRAVE_ANSWERS_API_KEY is not configured");
+        throw new Error(BRAVE_ANSWERS_API_KEY_MISSING_ERROR);
     }
     const url = new URL("https://api.search.brave.com/res/v1/chat/completions");
     const messages = [{ role: "user", content: query }];
@@ -74,16 +77,12 @@ export async function performBraveAnswers(query, model = "brave") {
 }
 // Raw web search API call
 export async function performWebSearchRaw(query, count = 10, offset = 0) {
-    // Route through Synalux portal when available (offset=0 only — portal doesn't support offset)
-    if (SYNALUX_SEARCH_AVAILABLE && offset === 0) {
-        try {
-            return await synaluxWebSearchRaw(query, count);
-        }
-        catch (err) {
-            debugLog(`[braveApi] Synalux search failed, falling back to Brave: ${err instanceof Error ? err.message : String(err)}`);
-            // Fall through to direct Brave API
-        }
+    if (SYNALUX_SEARCH_AVAILABLE) {
+        if (offset !== 0)
+            throw new Error(SYNALUX_OFFSET_UNSUPPORTED_ERROR);
+        return synaluxWebSearchRaw(query, count);
     }
+    const braveApiKey = requireBraveApiKey();
     const url = new URL("https://api.search.brave.com/res/v1/web/search");
     url.searchParams.set("q", query);
     url.searchParams.set("count", Math.min(count, 20).toString()); // API limit
@@ -92,7 +91,7 @@ export async function performWebSearchRaw(query, count = 10, offset = 0) {
         headers: {
             Accept: "application/json",
             "Accept-Encoding": "gzip",
-            "X-Subscription-Token": BRAVE_API_KEY,
+            "X-Subscription-Token": braveApiKey,
         },
         signal: AbortSignal.timeout(15_000),
     });
@@ -103,15 +102,10 @@ export async function performWebSearchRaw(query, count = 10, offset = 0) {
 }
 // Web search API call
 export async function performWebSearch(query, count = 10, offset = 0) {
-    // Route through Synalux portal when available (offset=0 only — portal doesn't support offset)
-    if (SYNALUX_SEARCH_AVAILABLE && offset === 0) {
-        try {
-            return await synaluxWebSearch(query, count);
-        }
-        catch (err) {
-            debugLog(`[braveApi] Synalux search failed, falling back to Brave: ${err instanceof Error ? err.message : String(err)}`);
-            // Fall through to direct Brave API
-        }
+    if (SYNALUX_SEARCH_AVAILABLE) {
+        if (offset !== 0)
+            throw new Error(SYNALUX_OFFSET_UNSUPPORTED_ERROR);
+        return synaluxWebSearch(query, count);
     }
     const textData = await performWebSearchRaw(query, count, offset);
     const data = JSON.parse(textData);
@@ -127,13 +121,14 @@ export async function performWebSearch(query, count = 10, offset = 0) {
 }
 // Get POI details
 export async function getPoisData(ids) {
+    const braveApiKey = requireBraveApiKey();
     const url = new URL("https://api.search.brave.com/res/v1/local/pois");
     ids.filter(Boolean).forEach((id) => url.searchParams.append("ids", id));
     const response = await fetch(url, {
         headers: {
             Accept: "application/json",
             "Accept-Encoding": "gzip",
-            "X-Subscription-Token": BRAVE_API_KEY,
+            "X-Subscription-Token": braveApiKey,
         },
         signal: AbortSignal.timeout(15_000),
     });
@@ -144,13 +139,14 @@ export async function getPoisData(ids) {
 }
 // Get descriptions data
 export async function getDescriptionsData(ids) {
+    const braveApiKey = requireBraveApiKey();
     const url = new URL("https://api.search.brave.com/res/v1/local/descriptions");
     ids.filter(Boolean).forEach((id) => url.searchParams.append("ids", id));
     const response = await fetch(url, {
         headers: {
             Accept: "application/json",
             "Accept-Encoding": "gzip",
-            "X-Subscription-Token": BRAVE_API_KEY,
+            "X-Subscription-Token": braveApiKey,
         },
         signal: AbortSignal.timeout(15_000),
     });
@@ -168,16 +164,10 @@ function chunkArray(arr, size) {
 }
 // Raw local search API call with poi/details payload
 export async function performLocalSearchRaw(query, count = 5) {
-    // Route through Synalux portal when available
     if (SYNALUX_SEARCH_AVAILABLE) {
-        try {
-            return await synaluxLocalSearchRaw(query, count);
-        }
-        catch (err) {
-            debugLog(`[braveApi] Synalux local search raw failed, falling back to Brave: ${err instanceof Error ? err.message : String(err)}`);
-            // Fall through to direct Brave API
-        }
+        return synaluxLocalSearchRaw(query, count);
     }
+    const braveApiKey = requireBraveApiKey();
     // Initial search to get location IDs
     const webUrl = new URL("https://api.search.brave.com/res/v1/web/search");
     webUrl.searchParams.set("q", query);
@@ -188,7 +178,7 @@ export async function performLocalSearchRaw(query, count = 5) {
         headers: {
             Accept: "application/json",
             "Accept-Encoding": "gzip",
-            "X-Subscription-Token": BRAVE_API_KEY,
+            "X-Subscription-Token": braveApiKey,
         },
         signal: AbortSignal.timeout(15_000),
     });
@@ -232,15 +222,8 @@ export async function performLocalSearchRaw(query, count = 5) {
 }
 // Local search API call with poi details
 export async function performLocalSearch(query, count = 5) {
-    // Route through Synalux portal when available
     if (SYNALUX_SEARCH_AVAILABLE) {
-        try {
-            return await synaluxLocalSearch(query, count);
-        }
-        catch (err) {
-            debugLog(`[braveApi] Synalux local search failed, falling back to Brave: ${err instanceof Error ? err.message : String(err)}`);
-            // Fall through to direct Brave API
-        }
+        return synaluxLocalSearch(query, count);
     }
     const rawData = await performLocalSearchRaw(query, count);
     const parsed = JSON.parse(rawData);

package/dist/utils/codingQualityPolicy.js

@@ -0,0 +1,400 @@
+import { spawnSync } from "node:child_process";
+const IMPLEMENTATION_REQUEST_RE = /\b(?:implement|write|create|generate|complete|finish|fix)\b[\s\S]{0,160}\b(?:code|source|function|method|class|interface|struct|enum|implementation|algorithm|component|endpoint)\b/i;
+const STRICT_SOURCE_REQUEST_RE = /\b(?:return|output|respond with)\s+only\s+(?:the\s+)?(?:implementation\s+)?(?:source\s+)?code\b/i;
+const CODE_SHAPE_RE = /(?:^|\n)\s*(?:(?:export|public|private|protected|internal|open|pub|static|final|abstract|async)\s+)*(?:class|interface|struct|enum|function|def|func|fun|fn|type)\s+[A-Za-z_$][\w$]*|(?:^|\n)\s*(?:const|let|var)\s+[A-Za-z_$][\w$]*\s*=|(?:^|\n)\s*(?:[A-Za-z_$][\w$:<>,.?*[\]&]*\s+)+[A-Za-z_$][\w$]*\s*\([^;\n]*\)\s*(?:const\s*)?(?:noexcept\s*)?(?:\{|=>)|=>\s*[{(]/m;
+export const INCOMPLETE_IMPLEMENTATION_PATTERNS = [
+    {
+        reason: "code_placeholder",
+        pattern: /\b(?:your code here|implementation goes here|insert implementation here)\b/i,
+    },
+    {
+        reason: "code_placeholder",
+        pattern: /\b(?:implementation|code)\s+(?:is\s+)?(?:omitted|left out|not shown)\b/i,
+    },
+    {
+        reason: "code_placeholder",
+        pattern: /\b(?:rest|remainder)\s+of\s+(?:the\s+)?(?:implementation|code)\b/i,
+    },
+    {
+        reason: "code_placeholder",
+        pattern: /(?:#|\/\/|\/\*+|\*)\s*(?:TODO|FIXME)\s*:?\s*(?:implement|complete|finish|add)\b/i,
+    },
+    {
+        reason: "code_not_implemented",
+        pattern: /\braise\s+NotImplementedError\b/,
+    },
+    {
+        reason: "code_unfinished_reasoning",
+        pattern: /(?:^|\n)\s*(?:#|\/\/|\/\*+|\*)?\s*(?:actually,?\s+)?(?:let me think|i need to (?:think|finish|complete)|to be continued)\b/i,
+    },
+];
+const REQUIRED_SYMBOL_PATTERNS = [
+    /\b(?:implement|write|create|generate|complete)\s+(?:an?\s+)?(?:class|function|method|interface|struct|enum)\s+[`'"]?([A-Za-z_$][\w$]*)/gi,
+    /\bimplement\s+[`'"]?([A-Za-z_$][\w$]*)\s*\(/gi,
+];
+const PYTHON_CLASS_RE = /^(\s*)class\s+([A-Za-z_]\w*)\s*(?:\([^)]*\))?\s*:/;
+const PYTHON_FUNCTION_RE = /^(\s*)(?:async\s+)?def\s+([A-Za-z_]\w*)\s*\(([^)]*)\)/;
+const PYTHON_DIRECT_PRIVATE_CALL_RE = /\bself\.(_[A-Za-z_]\w*)\s*\(/g;
+const PYTHON_METHOD_DECORATOR_RE = /^(\s*)@(staticmethod|classmethod)\b/;
+const PYTHON_SIGNAL_RE = /```(?:python|py)\b|(?:^|\n)\s*(?:from\s+\S+\s+import|import\s+\S+|(?:async\s+)?def\s+|class\s+\w+.*:)/im;
+const UNFENCED_PYTHON_START_RE = /^\s*(?:from\s+\S+\s+import|import\s+\S+|(?:async\s+)?def\s+|class\s+\w+)/i;
+const TRAILING_PROSE_LINE_RE = /^(?!(?:async\s+def|def|class|from|import|return|raise|yield|assert|del|global|nonlocal|if|elif|else|for|while|try|except|finally|with|match|case)\b)(?![A-Za-z_]\w*\s*=)[A-Za-z][A-Za-z'’-]*:?(?:\s+(?:[A-Za-z][A-Za-z'’+/-]*|`[^`\r\n]+`|https?:\/\/\S+|\d[\w.,%()+\-]*|[+*=<>-])){2,}[.!?]$/;
+const TRAILING_URL_LINE_RE = /^https?:\/\/\S+$/i;
+const PYTHON_INVALID_DEF_RE = /(?:^|\n)\s*(?:async\s+)?def\s+[A-Za-z_]\w*\s*:/m;
+const PYTHON_AST_SCRIPT = "import ast,sys; tree=ast.parse(sys.stdin.read()); compile(tree, '<prism-coding-gate>', 'exec')";
+const PYTHON_COMMANDS = ["python3", "python"];
+const PYTHON_CHILDREN_KEYS_UNPACK_RE = /\bfor\s+[A-Za-z_]\w*\s*,\s*child(?:_node)?\s+in\s+(?:sorted\(\s*)?[A-Za-z_][\w.]*\.children\.keys\(\)\s*\)?\s*:/;
+function extractUnfencedPythonCode(output) {
+    const lines = output.trim().split(/\r?\n/);
+    const start = lines.findIndex((line) => UNFENCED_PYTHON_START_RE.test(line));
+    if (start < 0)
+        return undefined;
+    let end = lines.length;
+    for (let index = start + 1; index < lines.length; index++) {
+        const line = lines[index];
+        const previousLine = lines[index - 1];
+        if (previousLine.trim().length === 0 &&
+            indentation(line) === 0 &&
+            (TRAILING_PROSE_LINE_RE.test(line.trim()) ||
+                TRAILING_URL_LINE_RE.test(line.trim()))) {
+            end = index;
+            break;
+        }
+    }
+    const code = lines.slice(start, end).join("\n").trim();
+    return code || undefined;
+}
+function extractCode(output) {
+    const blocks = [
+        ...output.matchAll(/```([A-Za-z0-9_+#.-]+)?\s*\n([\s\S]*?)```/g),
+    ].map((match) => ({
+        language: match[1]?.toLowerCase(),
+        code: match[2].trim(),
+    })).filter((block) => block.code.length > 0);
+    if (blocks.length === 0) {
+        const python = extractUnfencedPythonCode(output);
+        return {
+            all: output.trim(),
+            ...(python ? { python } : {}),
+            hasFences: false,
+        };
+    }
+    const pythonBlocks = blocks
+        .filter((block) => (block.language === "python" ||
+        block.language === "py" ||
+        (!block.language && PYTHON_SIGNAL_RE.test(block.code))))
+        .map((block) => block.code);
+    return {
+        all: blocks.map((block) => block.code).join("\n\n"),
+        ...(pythonBlocks.length > 0
+            ? { python: pythonBlocks.join("\n\n") }
+            : {}),
+        hasFences: true,
+    };
+}
+function indentation(line) {
+    return line.match(/^\s*/)?.[0].replace(/\t/g, "    ").length ?? 0;
+}
+function pythonBlockEnd(lines, start, blockIndent) {
+    let end = start + 1;
+    while (end < lines.length) {
+        const line = lines[end];
+        if (line.trim() && indentation(line) <= blockIndent)
+            break;
+        end++;
+    }
+    return end;
+}
+function directBodyIndent(lines, start, end) {
+    const indents = lines
+        .slice(start + 1, end)
+        .filter((line) => line.trim() && !line.trimStart().startsWith("#"))
+        .map(indentation);
+    return indents.length > 0 ? Math.min(...indents) : undefined;
+}
+function findConstructorMissingReceiverAssignments(lines) {
+    const assignments = [];
+    for (let classIndex = 0; classIndex < lines.length; classIndex++) {
+        const classMatch = lines[classIndex].match(PYTHON_CLASS_RE);
+        if (!classMatch)
+            continue;
+        const classIndent = indentation(lines[classIndex]);
+        const classEnd = pythonBlockEnd(lines, classIndex, classIndent);
+        const classBodyIndent = directBodyIndent(lines, classIndex, classEnd);
+        if (classBodyIndent === undefined)
+            continue;
+        const selfAttributes = new Set();
+        const selfAttributeRe = /\bself\.([A-Za-z_]\w*)\b/g;
+        for (const line of lines.slice(classIndex + 1, classEnd)) {
+            for (const match of line.matchAll(selfAttributeRe)) {
+                selfAttributes.add(match[1]);
+            }
+        }
+        for (let functionIndex = classIndex + 1; functionIndex < classEnd; functionIndex++) {
+            const functionMatch = lines[functionIndex].match(PYTHON_FUNCTION_RE);
+            if (!functionMatch ||
+                functionMatch[2] !== "__init__" ||
+                indentation(lines[functionIndex]) !== classBodyIndent) {
+                continue;
+            }
+            const functionIndent = indentation(lines[functionIndex]);
+            const functionEnd = pythonBlockEnd(lines, functionIndex, functionIndent);
+            const functionBodyIndent = directBodyIndent(lines, functionIndex, functionEnd);
+            if (functionBodyIndent === undefined)
+                continue;
+            const functionBody = lines
+                .slice(functionIndex + 1, functionEnd)
+                .join("\n");
+            for (let bodyIndex = functionIndex + 1; bodyIndex < functionEnd; bodyIndex++) {
+                if (indentation(lines[bodyIndex]) !== functionBodyIndent)
+                    continue;
+                const bareAssignment = lines[bodyIndex].match(/^\s*([A-Za-z_]\w*)\s*=(?!=)/);
+                if (!bareAssignment || !selfAttributes.has(bareAssignment[1]))
+                    continue;
+                const bareUseRe = new RegExp(`(?<!\\.)\\b${bareAssignment[1]}\\b`, "g");
+                if ([...functionBody.matchAll(bareUseRe)].length !== 1)
+                    continue;
+                assignments.push({
+                    lineIndex: bodyIndex,
+                    name: bareAssignment[1],
+                });
+            }
+        }
+        classIndex = classEnd - 1;
+    }
+    return assignments;
+}
+function requiredSymbols(prompt) {
+    const symbols = new Set();
+    for (const pattern of REQUIRED_SYMBOL_PATTERNS) {
+        pattern.lastIndex = 0;
+        for (const match of prompt.matchAll(pattern)) {
+            if (match[1])
+                symbols.add(match[1]);
+        }
+    }
+    return [...symbols];
+}
+function pythonStructureFailure(code) {
+    if (!/(?:^|\n)\s*class\s+[A-Za-z_]\w*[\s(:]/m.test(code) ||
+        !/(?:^|\n)\s*(?:async\s+)?def\s+/m.test(code)) {
+        return undefined;
+    }
+    const lines = code.split(/\r?\n/);
+    const scopes = [];
+    const classScopes = [];
+    let pendingDecorator;
+    for (const line of lines) {
+        if (!line.trim() || line.trimStart().startsWith("#"))
+            continue;
+        const indent = indentation(line);
+        while (scopes.length > 0 && scopes[scopes.length - 1].indent >= indent) {
+            scopes.pop();
+        }
+        const decorator = line.match(PYTHON_METHOD_DECORATOR_RE);
+        if (decorator) {
+            pendingDecorator = {
+                indent,
+                kind: decorator[2],
+            };
+            continue;
+        }
+        const classMatch = line.match(PYTHON_CLASS_RE);
+        if (classMatch) {
+            const baseList = line.match(/\(([^)]*)\)/)?.[1].trim() ?? "";
+            const classScope = {
+                hasBase: baseList.length > 0,
+                definedMethods: new Set(),
+                directPrivateCalls: new Set(),
+                supportsDynamicLookup: false,
+            };
+            classScopes.push(classScope);
+            scopes.push({ kind: "class", indent, classScope });
+            pendingDecorator = undefined;
+            continue;
+        }
+        const functionMatch = line.match(PYTHON_FUNCTION_RE);
+        if (functionMatch) {
+            const parent = scopes[scopes.length - 1];
+            const methodName = functionMatch[2];
+            const parameters = functionMatch[3]
+                .split(",")
+                .map((parameter) => parameter.trim())
+                .filter(Boolean);
+            if (parent?.kind === "class") {
+                parent.classScope?.definedMethods.add(methodName);
+                if (methodName === "__getattr__" || methodName === "__getattribute__") {
+                    if (parent.classScope)
+                        parent.classScope.supportsDynamicLookup = true;
+                }
+                const decoratedStatic = pendingDecorator?.indent === indent &&
+                    pendingDecorator.kind === "staticmethod";
+                const expectedReceiver = pendingDecorator?.indent === indent &&
+                    pendingDecorator.kind === "classmethod"
+                    ? "cls"
+                    : "self";
+                if (!decoratedStatic && parameters[0]?.split(/[:=]/, 1)[0].trim() !== expectedReceiver) {
+                    return "python_method_missing_receiver";
+                }
+            }
+            scopes.push({ kind: "function", indent });
+            pendingDecorator = undefined;
+        }
+        else {
+            pendingDecorator = undefined;
+        }
+        const containingClass = [...scopes]
+            .reverse()
+            .find((scope) => scope.kind === "class")
+            ?.classScope;
+        PYTHON_DIRECT_PRIVATE_CALL_RE.lastIndex = 0;
+        for (const match of line.matchAll(PYTHON_DIRECT_PRIVATE_CALL_RE)) {
+            containingClass?.directPrivateCalls.add(match[1]);
+        }
+    }
+    for (const classScope of classScopes) {
+        if (classScope.hasBase || classScope.supportsDynamicLookup)
+            continue;
+        for (const called of classScope.directPrivateCalls) {
+            if (!classScope.definedMethods.has(called)) {
+                return "python_undefined_private_helper";
+            }
+        }
+    }
+    return undefined;
+}
+function pythonSyntaxFailure(code) {
+    if (!PYTHON_SIGNAL_RE.test(code))
+        return undefined;
+    if (PYTHON_INVALID_DEF_RE.test(code))
+        return "python_syntax_error";
+    for (const command of PYTHON_COMMANDS) {
+        const parsed = spawnSync(command, ["-c", PYTHON_AST_SCRIPT], {
+            input: code,
+            encoding: "utf8",
+            timeout: 2_000,
+            maxBuffer: 64 * 1024,
+            windowsHide: true,
+        });
+        if (parsed.error && parsed.error.code === "ENOENT") {
+            continue;
+        }
+        return parsed.status === 0 ? undefined : "python_syntax_error";
+    }
+    return undefined;
+}
+function pythonStaticContractFailure(code) {
+    const issues = new Set();
+    const lines = code.split(/\r?\n/);
+    if (findConstructorMissingReceiverAssignments(lines).length > 0) {
+        issues.add("constructor_attribute_missing_receiver");
+    }
+    if (PYTHON_CHILDREN_KEYS_UNPACK_RE.test(code)) {
+        issues.add("dict_keys_unpack");
+    }
+    return issues.size > 0
+        ? `python_static_contract:${[...issues].sort().join(",")}`
+        : undefined;
+}
+export function applyDeterministicCodingRepairs(output, reason) {
+    if (!reason.startsWith("python_static_contract:")) {
+        return { output, changes: [] };
+    }
+    const lines = output.split(/\r?\n/);
+    const changes = new Set();
+    if (reason.includes("constructor_attribute_missing_receiver")) {
+        for (const { lineIndex, name } of findConstructorMissingReceiverAssignments(lines)) {
+            const bareAssignment = lines[lineIndex].match(/^(\s*)([A-Za-z_]\w*)(\s*=(?!=).*)$/);
+            if (!bareAssignment || bareAssignment[2] !== name)
+                continue;
+            lines[lineIndex] =
+                `${bareAssignment[1]}self.${name}${bareAssignment[3]}`;
+            changes.add("constructor_attribute_missing_receiver");
+        }
+    }
+    if (reason.includes("dict_keys_unpack")) {
+        for (let index = 0; index < lines.length; index++) {
+            if (!PYTHON_CHILDREN_KEYS_UNPACK_RE.test(lines[index]))
+                continue;
+            lines[index] = lines[index].replace(".keys()", ".items()");
+            changes.add("dict_keys_unpack");
+        }
+    }
+    return {
+        output: lines.join(output.includes("\r\n") ? "\r\n" : "\n"),
+        changes: [...changes].sort(),
+    };
+}
+/**
+ * Reject only objective implementation failures. Non-implementation analysis
+ * in code mode remains valid prose and bypasses this specialized gate.
+ */
+export function passesCodingQualityGate(prompt, output) {
+    const implementationRequested = IMPLEMENTATION_REQUEST_RE.test(prompt) || STRICT_SOURCE_REQUEST_RE.test(prompt);
+    if (!implementationRequested)
+        return { pass: true };
+    for (const { reason, pattern } of INCOMPLETE_IMPLEMENTATION_PATTERNS) {
+        if (pattern.test(output))
+            return { pass: false, reason };
+    }
+    const extracted = extractCode(output);
+    const code = extracted.all;
+    if (STRICT_SOURCE_REQUEST_RE.test(prompt) && !CODE_SHAPE_RE.test(code)) {
+        return { pass: false, reason: "code_shape_missing" };
+    }
+    for (const symbol of requiredSymbols(prompt)) {
+        const symbolRe = new RegExp(`\\b${symbol.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\b`);
+        if (!symbolRe.test(code)) {
+            return { pass: false, reason: "code_required_symbol_missing" };
+        }
+    }
+    const pythonCode = extracted.python;
+    if (pythonCode) {
+        const pythonSyntax = pythonSyntaxFailure(pythonCode);
+        if (pythonSyntax)
+            return { pass: false, reason: pythonSyntax };
+        const pythonStaticContract = pythonStaticContractFailure(pythonCode);
+        if (pythonStaticContract) {
+            return { pass: false, reason: pythonStaticContract };
+        }
+        const pythonFailure = pythonStructureFailure(pythonCode);
+        if (pythonFailure)
+            return { pass: false, reason: pythonFailure };
+    }
+    return { pass: true };
+}
+const CODING_REPAIR_SYSTEM_INSTRUCTION = "Repair the supplied implementation. Return one complete replacement implementation with no prose, " +
+    "placeholders, TODOs, omitted sections, or unfinished reasoning. Preserve every requirement in the original task.";
+const CODING_REPAIR_GUIDANCE = {
+    code_placeholder: "Replace every placeholder or omitted section with complete executable code.",
+    code_not_implemented: "Replace NotImplemented stubs with the complete requested behavior.",
+    code_unfinished_reasoning: "Remove unfinished reasoning and finish the implementation before returning it.",
+    code_shape_missing: "Return actual source code with the requested definition, not a prose description.",
+    code_required_symbol_missing: "Define the exact class, function, method, or interface name requested by the task.",
+    python_syntax_error: "Make the entire Python module parse successfully; check every def signature, delimiter, and block.",
+    python_method_missing_receiver: "Instance methods must take self first; class methods must take cls first unless decorated staticmethod.",
+    python_undefined_private_helper: "Define every directly called private self helper or replace the call with the correct defined helper.",
+    constructor_attribute_missing_receiver: "In __init__, persist instance state as self.<attribute>; do not assign it to a discarded local variable.",
+    dict_keys_unpack: "When unpacking key and value, iterate dictionary .items(); .keys() yields one key per iteration.",
+};
+function repairGuidance(reason) {
+    const guidance = new Set();
+    for (const [code, instruction] of Object.entries(CODING_REPAIR_GUIDANCE)) {
+        if (reason.includes(code))
+            guidance.add(instruction);
+    }
+    return [...guidance];
+}
+export function buildCodingRepairPrompt(originalPrompt, draft, reason) {
+    const safeDraft = draft.replace(/<\|/g, "< |");
+    const guidance = repairGuidance(reason);
+    return {
+        system: CODING_REPAIR_SYSTEM_INSTRUCTION,
+        prompt: `<original_task>\n${originalPrompt}\n</original_task>\n` +
+            `<failed_gate>${reason}</failed_gate>\n` +
+            (guidance.length > 0
+                ? `<repair_guidance>\n- ${guidance.join("\n- ")}\n</repair_guidance>\n`
+                : "") +
+            `<draft>\n${safeDraft}\n</draft>`,
+    };
+}

package/dist/utils/layer1.js

@@ -21,7 +21,8 @@
  *
  * Must not run when mode="route" and max_tokens<=16 — that IS a Layer 1 call.
  */
-// VERBATIM — §E prism-infer-boundaries/SKILL.md. Do not edit without re-running eval-layer1.mjs.
+// VERBATIM — §E prism-infer-boundaries/SKILL.md.
+// Changes require the private Layer 1 evaluation gate before release.
 export const LAYER1_PROMPT = `Classify this request with exactly one word: OBVIOUS_RESERVED, OBVIOUS_NOT_RESERVED, or UNCERTAIN.
 
 OBVIOUS_RESERVED — clearly involves:
@@ -33,10 +34,11 @@ OBVIOUS_RESERVED — clearly involves:
 - Writing auth/login/JWT/token/session validation code
 - Determining if code bypasses auth or allows unauthenticated access
 - Assessing whether code actually exposes PHI or constitutes a HIPAA violation
-- Whether to push, ship, deploy, or block a production release
-- Diagnosis code assignment
+- Whether to push, ship, deploy, block, stop shipping, or make a production go/no-go decision
+- Medication choice, prescribing, or dosing
+- Diagnosis code assignment or professional sign-off
 
-OBVIOUS_NOT_RESERVED — general coding, code review, analysis, documentation, test generation, data processing.
+OBVIOUS_NOT_RESERVED — general coding, code review, analysis, documentation, test generation, or data processing. Also routine non-crisis BCBA measurement and operational definitions; tentative ABC/FBA hypotheses; data gathering before intervention when no injury or imminent danger is stated; educational explanations of function-matched intervention concepts; dignity-preserving language; caregiver training; AAC access rights and replacement-response candidates for BCBA review; and explaining continued AAC access or nonrestrictive positioning when no injury is reported.
 
 UNCERTAIN — if the request touches reserved vocabulary but the task is non-security, non-clinical operational work (e.g., deleting or renaming a file, adding a non-auth data field to a form, reviewing existing code for dead exports or hook order) rather than writing clinical safety protocols, implementing auth or security code, making push or deploy decisions, or determining compliance.
 
@@ -64,6 +66,58 @@ export function parseLayer1(raw) {
     const token = m[0];
     return VALID.has(token) ? token : "ERROR";
 }
+const has = (pattern) => (prompt) => pattern.test(prompt);
+const all = (...rules) => (prompt) => rules.every((rule) => rule(prompt));
+const RESERVED_INTENT_RULES = [
+    all(has(/\b(?:de[- ]?escalat\w*|meltdown\w*|rage\s+episode|violent\w*)\b/i), has(/\b(?:draft|write|plan|procedure|protocol|manag\w*|what\s+(?:do|should)\b|respond\w*)\b/i)),
+    all(has(/\b(?:physical\s+intervention|containment|hold\s+procedure|restrain\w*|seclu\w*|physical\s+management)\b/i), has(/\b(?:draft|write|document|procedure|protocol|use|implement|instruct\w*)\b/i)),
+    all(has(/\b(?:self[- ]?(?:harm|injur\w*)|bites?\s+(?:him|her|them)self|scratches?\s+(?:him|her|them)self|bangs?\s+(?:his|her|their)\s+head|harm\s+(?:himself|herself|themselves))\b/i), has(/\b(?:bleed\w*|blood|concrete|head\s+impact|medical\s+attention|risk(?:\s+of\s+injury)?|causes?\s+injury|actual\s+injury|assess\w*|screen\w*|want\w*)\b/i)),
+    (prompt) => (/\b(?:punch\w*|attack\w*|aggress\w*|hit\s+staff)\b/i.test(prompt)
+        && /\b(?:last\s+(?:week|month|year)|prior|previous|history|injur\w*)\b/i.test(prompt)
+        && !/\bno\s+injur(?:y|ies)\b/i.test(prompt)
+        && /\b(?:plan|procedure|intervention|assess\w*)\b/i.test(prompt)),
+    has(/\b(?:suicid\w*|homicid\w*)\b/i),
+    all(has(/\b(?:write|implement|create|build|add|modify|update|fix|refactor)\b/i), has(/\b(?:auth\w*|login|jwt|tokens?|sessions?|api\s+keys?)\b/i), has(/\b(?:verify|verification|validat\w*|check\w*|middleware|handler)\b/i)),
+    all(has(/\b(?:does|can|could|whether|write|implement|create|build|add|modify|update|fix|refactor)\b/i), has(/\b(?:endpoint|route|user|someone|permissions?|authenticat\w*|authoriz\w*)\b/i), has(/\b(?:without|bypass\w*|unauthenticated|not\s+check\w*|lets?\s+anyone|anyone\s+in)\b/i)),
+    all(has(/\b(?:ship\w*|deploy\w*|prod(?:uction)?|release\w*)\b/i), has(/\b(?:safe|bad\s+enough|finding\w*|go\s+to|stop|block|ready|whether|can\s+we|should\s+we)\b/i)),
+    all(has(/\b(?:expos\w*|intercept\w*|leak\w*|access\w*)\b/i), has(/\b(?:phi|patient\s+(?:records?|data)|health\s+(?:records?|data))\b/i)),
+    all(has(/\b(?:medicat\w*|prescrib\w*|dos(?:e|age|ing))\b/i), has(/\b(?:choose|recommend\w*|select|schedule|mg|how\s+much)\b/i)),
+    all(has(/\b(?:diagnos\w*|icd[- ]?\d*)\b/i), has(/\b(?:assign|choose|sign[- ]?off|approve|determine)\b/i)),
+];
+const ROUTINE_BCBA_INTENT_RULES = [
+    has(/\boperational\s+definition\b/i),
+    all(has(/\bdefin\w*\b/i), has(/\b(?:onset|offset|observers?|score|measur\w*)\b/i)),
+    all(has(/\b(?:abc|fba|functional\s+behavior)\b/i), has(/\b(?:hypothes\w*|tentative|summari[sz]\w*)\b/i)),
+    all(has(/\b(?:what\s+data|data\s+(?:should|to)\s+(?:be\s+)?gather\w*|collect\s+data)\b/i), has(/\bbefore\s+(?:select\w*|choos\w*|design\w*)\s+(?:an?\s+)?intervention\b/i)),
+    all(has(/\b(?:aac|augmentative\s+communication)\b/i), has(/\b(?:replacement[- ]response|replacement\s+(?:skill|behavior)|function[- ]matched)\b/i), has(/\b(?:bcba|clinician)\s+review\b/i)),
+    all(has(/\b(?:explain|educat\w*|why)\b/i), has(/\b(?:dro|differential\s+reinforcement|function[- ]matched|maintain\w+\s+by|escape\s+from)\b/i)),
+    all(has(/\b(?:caregiver|staff|parent)\s+training\b/i), has(/\b(?:aac|replacement|break[- ]request|communication)\b/i)),
+    all(has(/\b(?:rewrite|rephrase)\b/i), has(/\b(?:stigmat\w*|dignity|objective|tentative|function[- ]based)\b/i)),
+    all(has(/\b(?:aac|communication\s+device)\b/i), has(/\b(?:remain|keep)\s+available\b/i), has(/\bno\s+injur(?:y|ies)\b/i), has(/\bnonrestrictive\b/i)),
+];
+function matchesAny(prompt, rules) {
+    return rules.some((rule) => rule(prompt));
+}
+const NON_OPERATIONAL_ARTIFACT_CONTEXT = /(?:\b(?:test\s+fixture|fixture\s+label|unit\s+test|old\s+comment|fields?|columns?|labels?|filename|file\s+name|docs?|legal\s+(?:label|phrase|clause)|hook\s+order|dead\s+exports?|type\s+annotation|table\s+scan|add\s+index)\b|\/docs\/|\.[cm]?[jt]sx?\b)/i;
+const NON_OPERATIONAL_ARTIFACT_ACTION = /\b(?:review\b[\s\S]{0,120}\bhook\s+order|delete\b[\s\S]{0,120}\bdocs?|unit\s+tests?|add\b[\s\S]{0,120}\b(?:fields?|index|labels?|numeric\s+validation)|remove\b[\s\S]{0,120}\bcomments?|old\s+comment\b[\s\S]{0,120}\bremove)\b/i;
+/**
+ * Deterministic policy floor for unambiguous intents.
+ *
+ * Routing is code, not model judgment: clear reserved work fails closed and
+ * clear routine BCBA work reaches local inference. Ambiguous prompts return
+ * null and continue to the semantic classifier below.
+ */
+export function classifyDeterministicLayer1(userPrompt) {
+    if (matchesAny(userPrompt, RESERVED_INTENT_RULES))
+        return "OBVIOUS_RESERVED";
+    if (NON_OPERATIONAL_ARTIFACT_CONTEXT.test(userPrompt) &&
+        NON_OPERATIONAL_ARTIFACT_ACTION.test(userPrompt)) {
+        return "OBVIOUS_NOT_RESERVED";
+    }
+    if (matchesAny(userPrompt, ROUTINE_BCBA_INTENT_RULES))
+        return "OBVIOUS_NOT_RESERVED";
+    return null;
+}
 const LAYER1_TIMEOUT_MS = 1_500;
 const LAYER1_RETRY_TIMEOUT_MS = 5_000;
 // Deterministic reserved-vocabulary backstop for the ERROR path.
@@ -123,6 +177,11 @@ export async function callLayer1(userPrompt, ollamaUrl, model, fetchImpl = fetch
     if (!userPrompt || !userPrompt.trim())
         return "ERROR";
     const oversize = userPrompt.length > MAX_CLASSIFIER_PROMPT_LENGTH;
+    const deterministic = classifyDeterministicLayer1(userPrompt);
+    if (deterministic === "OBVIOUS_RESERVED")
+        return deterministic;
+    if (!oversize && deterministic === "OBVIOUS_NOT_RESERVED")
+        return deterministic;
     if (oversize && keywordBackstop(userPrompt) === "OBVIOUS_RESERVED") {
         // The regex floor has no length limit — reserved vocabulary anywhere
         // in the full text (including the middle the excerpt can't see)