@skillsmith/core 0.11.3 → 0.11.5

package/dist/src/security/scanner/patterns.js.map

@@ -1 +1 @@
-{"version":3,"file":"patterns.js","sourceRoot":"","sources":["../../../../src/security/scanner/patterns.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"patterns.js","sourceRoot":"","sources":["../../../../src/security/scanner/patterns.ts"],"names":[],"mappings":"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"}

package/dist/src/security/scanner/patterns.scope.d.ts

@@ -0,0 +1,62 @@
+/**
+ * SMI-5881: Pattern scope model — replaces the old per-source-text
+ * multiline-detection heuristic function (formerly in
+ * SecurityScanner.helpers.ts, deleted entirely, no compatibility shim).
+ * @module @skillsmith/core/security/scanner/patterns.scope
+ *
+ * The deleted heuristic sniffed a regex's SOURCE TEXT for the literal
+ * two-character sequences `\r`/`\n` (or a `(?:^|\n)` prefix) to decide
+ * whether a pattern should be tested against the full document (`content`)
+ * or per-line. This heuristic was wrong in BOTH directions:
+ *
+ * - False negative: a pattern that spans lines via a bounded `[\s\S]{0,N}`
+ *   character class (which matches a literal newline character at runtime)
+ *   but has no literal `\r`/`\n` ESCAPE SEQUENCE in its regex source was
+ *   scanned per-line only, so a genuinely cross-line attack could never fire
+ *   (AD_HTML_COMMENT_VERB/NOUN, AD_NESTED_INSTRUCTION_BLOCK, AD_ZERO_WIDTH).
+ * - False positive: a pattern containing a NEGATED newline-excluding class
+ *   (`[^\n]{0,80}?`, deliberately forbidding a newline crossing) still
+ *   contains the literal substring `\n` in its `.source` text, so the naive
+ *   heuristic misclassified it as content-scope anyway (JB_JS3A/JS3B,
+ *   AD_AN3A) — harmless today (these patterns are correctly kept out of the
+ *   per-line pass since they were never meant to be tested there either) but
+ *   still a real classification bug, not deliberate design.
+ *
+ * PATTERN_SCOPE replaces the heuristic with an explicit, fail-closed,
+ * per-pattern declaration: `'line'` (per-line pass only), `'content'`
+ * (full-document pass only), or `'both'` (tested in both passes — needed to
+ * fix the false-negative class above without losing existing single-line
+ * coverage). There is no default: an unmapped pattern throws at scan time
+ * (`resolvePatternScope`) and the whole module fails to load if any pattern
+ * in `SCOPED_PATTERN_SETS` is missing an entry (`assertScopeCoverage`, called
+ * at the bottom of this file). Unlike the evidence-tier map (which safely
+ * defaults an unmapped pattern to its STRONGEST tier), scope has no
+ * analogous safe default — a pattern silently scanned in the WRONG pass (or
+ * neither) is a silent coverage gap, not a conservative failure mode.
+ *
+ * Every scope assignment below is BASELINE-PRESERVING relative to the old
+ * heuristic's actual current behavior, with exactly 4 explicit promotions
+ * (`'line'` → `'both'`, section 1.4 of the SMI-5881 design): AD_HTML_COMMENT_
+ * VERB, AD_HTML_COMMENT_NOUN, AD_NESTED_INSTRUCTION_BLOCK, AD_ZERO_WIDTH.
+ * Every other pattern — including the two known false positives above
+ * (JB_JS3A/JS3B, AD_AN3A) — keeps whatever scope the old heuristic already
+ * computed for it; re-scoping any of those changes finding cardinality and
+ * needs its own corpus review, out of scope for this P0 fix.
+ */
+export type PatternScope = 'line' | 'content' | 'both';
+export declare const PATTERN_SCOPE: ReadonlyMap<RegExp, PatternScope>;
+/** Every pattern array consumed by a scope-resolving scan function. */
+export declare const SCOPED_PATTERN_SETS: ReadonlyArray<{
+    name: string;
+    patterns: readonly RegExp[];
+}>;
+/**
+ * Resolve a pattern's scope by object identity. Throws (does NOT default) for
+ * any pattern reaching a scope-resolving scanner without a PATTERN_SCOPE
+ * entry — there is no safe default direction for scope the way there is for
+ * evidence tier (classifyEvidence's fail-closed-to-strongest-tier doesn't
+ * apply here: a pattern scanned in the wrong pass, or neither, is a silent
+ * coverage gap regardless of which "direction" you'd guess).
+ */
+export declare function resolvePatternScope(pattern: RegExp): PatternScope;
+//# sourceMappingURL=patterns.scope.d.ts.map

package/dist/src/security/scanner/patterns.scope.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"patterns.scope.d.ts","sourceRoot":"","sources":["../../../../src/security/scanner/patterns.scope.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AAKH,MAAM,MAAM,YAAY,GAAG,MAAM,GAAG,SAAS,GAAG,MAAM,CAAA;AA+EtD,eAAO,MAAM,aAAa,EAAE,WAAW,CAAC,MAAM,EAAE,YAAY,CAI1D,CAAA;AAEF,uEAAuE;AACvE,eAAO,MAAM,mBAAmB,EAAE,aAAa,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAA;CAAE,CAI5F,CAAA;AAED;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,YAAY,CASjE"}

package/dist/src/security/scanner/patterns.scope.js

@@ -0,0 +1,207 @@
+/**
+ * SMI-5881: Pattern scope model — replaces the old per-source-text
+ * multiline-detection heuristic function (formerly in
+ * SecurityScanner.helpers.ts, deleted entirely, no compatibility shim).
+ * @module @skillsmith/core/security/scanner/patterns.scope
+ *
+ * The deleted heuristic sniffed a regex's SOURCE TEXT for the literal
+ * two-character sequences `\r`/`\n` (or a `(?:^|\n)` prefix) to decide
+ * whether a pattern should be tested against the full document (`content`)
+ * or per-line. This heuristic was wrong in BOTH directions:
+ *
+ * - False negative: a pattern that spans lines via a bounded `[\s\S]{0,N}`
+ *   character class (which matches a literal newline character at runtime)
+ *   but has no literal `\r`/`\n` ESCAPE SEQUENCE in its regex source was
+ *   scanned per-line only, so a genuinely cross-line attack could never fire
+ *   (AD_HTML_COMMENT_VERB/NOUN, AD_NESTED_INSTRUCTION_BLOCK, AD_ZERO_WIDTH).
+ * - False positive: a pattern containing a NEGATED newline-excluding class
+ *   (`[^\n]{0,80}?`, deliberately forbidding a newline crossing) still
+ *   contains the literal substring `\n` in its `.source` text, so the naive
+ *   heuristic misclassified it as content-scope anyway (JB_JS3A/JS3B,
+ *   AD_AN3A) — harmless today (these patterns are correctly kept out of the
+ *   per-line pass since they were never meant to be tested there either) but
+ *   still a real classification bug, not deliberate design.
+ *
+ * PATTERN_SCOPE replaces the heuristic with an explicit, fail-closed,
+ * per-pattern declaration: `'line'` (per-line pass only), `'content'`
+ * (full-document pass only), or `'both'` (tested in both passes — needed to
+ * fix the false-negative class above without losing existing single-line
+ * coverage). There is no default: an unmapped pattern throws at scan time
+ * (`resolvePatternScope`) and the whole module fails to load if any pattern
+ * in `SCOPED_PATTERN_SETS` is missing an entry (`assertScopeCoverage`, called
+ * at the bottom of this file). Unlike the evidence-tier map (which safely
+ * defaults an unmapped pattern to its STRONGEST tier), scope has no
+ * analogous safe default — a pattern silently scanned in the WRONG pass (or
+ * neither) is a silent coverage gap, not a conservative failure mode.
+ *
+ * Every scope assignment below is BASELINE-PRESERVING relative to the old
+ * heuristic's actual current behavior, with exactly 4 explicit promotions
+ * (`'line'` → `'both'`, section 1.4 of the SMI-5881 design): AD_HTML_COMMENT_
+ * VERB, AD_HTML_COMMENT_NOUN, AD_NESTED_INSTRUCTION_BLOCK, AD_ZERO_WIDTH.
+ * Every other pattern — including the two known false positives above
+ * (JB_JS3A/JS3B, AD_AN3A) — keeps whatever scope the old heuristic already
+ * computed for it; re-scoping any of those changes finding cardinality and
+ * needs its own corpus review, out of scope for this P0 fix.
+ */
+import { JAILBREAK_PATTERNS, AI_DEFENCE_PATTERNS } from './patterns.jailbreak.js';
+import { SSRF_INSTRUCTION_PATTERNS } from './patterns.js';
+// Index-aligned with JAILBREAK_PATTERNS (patterns.jailbreak.ts). Every entry
+// here is 'line' except the two naive-heuristic false positives (JB_JS3A/
+// JS3B, index 17/18 — see module doc comment) and the 3 genuinely multi-line
+// split-word patterns (index 20-22), both baseline-preserving, not promoted.
+const JAILBREAK_SCOPE = [
+    'line', // JB_IGNORE_PREVIOUS
+    'line', // JB_DISREGARD_PREVIOUS
+    'line', // JB_DEVELOPER_MODE
+    'line', // JB_DAN_BARE
+    'line', // JB_DO_ANYTHING_NOW
+    'line', // JB_JAILBREAK_BARE
+    'line', // JB_BYPASS_RESTRICTIONS
+    'line', // JB_PRETEND_NO_RESTRICTIONS
+    'line', // JB_ACT_NO_ETHICS
+    'line', // JB_YOU_ARE_NOW_FREE
+    'line', // JB_IGNORE_SAFETY_GUIDELINES
+    'line', // JB_HYPOTHETICAL_SCENARIO
+    'line', // JB_JN1_MODE_FRAME
+    'line', // JB_JN2_DEVELOPER_MODE_FRAME
+    'line', // JB_JN3_PERSONA_FRAME
+    'line', // JB_JS1_STATE_BARE
+    'line', // JB_JS2_NOUN_MODE_STATE
+    'content', // JB_JS3A_DEV_MODE_THEN_CAPABILITY (naive-heuristic FP, baseline-preserved)
+    'content', // JB_JS3B_CAPABILITY_THEN_DEV_MODE (naive-heuristic FP, baseline-preserved)
+    'line', // JB_JS4_OBEDIENCE_COMPULSION
+    'content', // JB_SPLIT_IGNORE (genuinely multi-line)
+    'content', // JB_SPLIT_DISREGARD (genuinely multi-line)
+    'content', // JB_SPLIT_BYPASS (genuinely multi-line)
+];
+// Index-aligned with AI_DEFENCE_PATTERNS (patterns.jailbreak.ts). Indices
+// 2, 3, 10, 13 are the 4 explicit promotions ('line' -> 'both', SMI-5881 P0
+// follow-up); index 19 (AD_AN3A) is the naive-heuristic FP, baseline-preserved
+// as 'content' despite its own name/comment implying line-scope.
+const AI_DEFENCE_SCOPE = [
+    'content', // AD_ROLE_MARKER_BARE
+    'line', // AD_BRACKET_HIDDEN (deliberately kept line-only, see patterns.jailbreak.ts)
+    'both', // AD_HTML_COMMENT_VERB — PROMOTED (was 'line')
+    'both', // AD_HTML_COMMENT_NOUN — PROMOTED (was 'line')
+    'line', // AD_HOMOGRAPH_RUN_PLUS_KEYWORD
+    'line', // AD_MIXED_SCRIPT_WORD
+    'line', // AD_XML_TAG_BARE (deliberately kept line-only, see patterns.jailbreak.ts)
+    'line', // AD_BASE64_INSTRUCTIONS
+    'content', // AD_DELIMITER_BARE
+    'line', // AD_JSON_ROLE_FIELD
+    'both', // AD_NESTED_INSTRUCTION_BLOCK — PROMOTED (was 'line')
+    'content', // AD_CRLF_INJECTION (the P0 pattern — see patterns.jailbreak.ts)
+    'line', // AD_TEMPLATE_LITERAL
+    'both', // AD_ZERO_WIDTH — PROMOTED (was 'line')
+    'line', // AD_MARKDOWN_LINK_PAYLOAD
+    'line', // AD_ESCAPE_SEQUENCE_ABUSE
+    'line', // AD_ZALGO_COMBINING
+    'line', // AD_AN1_ROLE_BODY_SAME_LINE
+    'content', // AD_AN2_ROLE_BODY_NEXT_LINE
+    'content', // AD_AN3A_CHAT_TOKEN_BODY_SAME_LINE (naive-heuristic FP, baseline-preserved)
+    'content', // AD_AN3B_CHAT_TOKEN_BODY_NEXT_LINE
+];
+// Index-aligned with SSRF_INSTRUCTION_PATTERNS (patterns.ts). None are 'both'
+// — scanSsrfPatterns' older skip-based two-pass cannot correctly service it
+// (see assertScopeCoverage's SSRF-never-'both' assertion below).
+const SSRF_SCOPE = [
+    'line', // file://
+    'line', // gopher://
+    'line', // dict://
+    'line', // ldap://
+    'line', // localhost
+    'line', // 127.0.0.\d+
+    'line', // 0.0.0.0
+    'line', // 169.254.169.254 (cloud metadata, bare)
+    'line', // file:///etc/(passwd|shadow|hosts) (bare)
+    'line', // gopher://localhost (bare)
+    'content', // multiline file://
+    'content', // multiline localhost/127/0.0.0.0
+    'content', // multiline gopher://
+];
+export const PATTERN_SCOPE = new Map([
+    ...JAILBREAK_PATTERNS.map((p, i) => [p, JAILBREAK_SCOPE[i]]),
+    ...AI_DEFENCE_PATTERNS.map((p, i) => [p, AI_DEFENCE_SCOPE[i]]),
+    ...SSRF_INSTRUCTION_PATTERNS.map((p, i) => [p, SSRF_SCOPE[i]]),
+]);
+/** Every pattern array consumed by a scope-resolving scan function. */
+export const SCOPED_PATTERN_SETS = [
+    { name: 'JAILBREAK_PATTERNS', patterns: JAILBREAK_PATTERNS },
+    { name: 'AI_DEFENCE_PATTERNS', patterns: AI_DEFENCE_PATTERNS },
+    { name: 'SSRF_INSTRUCTION_PATTERNS', patterns: SSRF_INSTRUCTION_PATTERNS },
+];
+/**
+ * Resolve a pattern's scope by object identity. Throws (does NOT default) for
+ * any pattern reaching a scope-resolving scanner without a PATTERN_SCOPE
+ * entry — there is no safe default direction for scope the way there is for
+ * evidence tier (classifyEvidence's fail-closed-to-strongest-tier doesn't
+ * apply here: a pattern scanned in the wrong pass, or neither, is a silent
+ * coverage gap regardless of which "direction" you'd guess).
+ */
+export function resolvePatternScope(pattern) {
+    const scope = PATTERN_SCOPE.get(pattern);
+    if (scope === undefined) {
+        throw new Error(`[SecurityScanner] pattern /${pattern.source}/${pattern.flags} has no PATTERN_SCOPE entry. ` +
+            `Every pattern reaching a scope-resolving scanner must declare 'line' | 'content' | 'both'.`);
+    }
+    return scope;
+}
+const VALID_SCOPES = new Set(['line', 'content', 'both']);
+/**
+ * Named (patterns, scope) pairs consumed by the length-parity and
+ * value-validity checks below. Kept separate from SCOPED_PATTERN_SETS (which
+ * only names the pattern arrays, not their scope-array counterpart) so a
+ * length mismatch between a PATTERNS array and its SCOPE array is caught
+ * directly, rather than relying on index-aligned `.map()` silently reading
+ * past the shorter array's end (see assertScopeCoverage's doc comment).
+ */
+const SCOPE_ARRAY_PAIRS = [
+    { name: 'JAILBREAK_PATTERNS', patterns: JAILBREAK_PATTERNS, scopes: JAILBREAK_SCOPE },
+    { name: 'AI_DEFENCE_PATTERNS', patterns: AI_DEFENCE_PATTERNS, scopes: AI_DEFENCE_SCOPE },
+    { name: 'SSRF_INSTRUCTION_PATTERNS', patterns: SSRF_INSTRUCTION_PATTERNS, scopes: SSRF_SCOPE },
+];
+/**
+ * Module-load gate: throws (making this module un-importable) if any pattern
+ * in SCOPED_PATTERN_SETS lacks a PATTERN_SCOPE entry, if any
+ * SSRF_INSTRUCTION_PATTERNS member is scoped 'both' (scanSsrfPatterns' older
+ * skip-based two-pass, SecurityScanner.ssrf.ts, cannot correctly service
+ * 'both' — see its own inline comment), OR — the case `Map.has()` alone
+ * cannot catch — if a PATTERNS array and its index-aligned SCOPE array have
+ * drifted out of length parity (e.g. a pattern appended without a
+ * corresponding scope entry). `new Map([[p, undefined]])` still reports
+ * `.has(p) === true`, so an out-of-range `SCOPE[i]` read during the Map's
+ * construction would silently pass a has()-only check; the explicit
+ * length-equality and value-membership checks below close that gap.
+ * Deterministic (no data dependence), so it can't be silently skipped by a
+ * lucky test-ordering fluke.
+ */
+function assertScopeCoverage() {
+    for (const { name, patterns, scopes } of SCOPE_ARRAY_PAIRS) {
+        if (patterns.length !== scopes.length) {
+            throw new Error(`[SecurityScanner] ${name} has ${patterns.length} pattern(s) but its scope array has ` +
+                `${scopes.length} entries — they must be index-aligned and equal length. ` +
+                `Add or remove a scope entry in patterns.scope.ts to match.`);
+        }
+    }
+    for (const { name, patterns } of SCOPED_PATTERN_SETS) {
+        patterns.forEach((pattern, index) => {
+            const scope = PATTERN_SCOPE.get(pattern);
+            if (!PATTERN_SCOPE.has(pattern) || scope === undefined) {
+                throw new Error(`[SecurityScanner] ${name}[${index}] (/${pattern.source}/${pattern.flags}) has no ` +
+                    `PATTERN_SCOPE entry. Add one to patterns.scope.ts before this pattern can be scanned.`);
+            }
+            if (!VALID_SCOPES.has(scope)) {
+                throw new Error(`[SecurityScanner] ${name}[${index}] (/${pattern.source}/${pattern.flags}) has an invalid ` +
+                    `PATTERN_SCOPE value ${JSON.stringify(scope)} — must be 'line', 'content', or 'both'.`);
+            }
+        });
+    }
+    SSRF_INSTRUCTION_PATTERNS.forEach((pattern, index) => {
+        if (PATTERN_SCOPE.get(pattern) === 'both') {
+            throw new Error(`[SecurityScanner] SSRF_INSTRUCTION_PATTERNS[${index}] (/${pattern.source}/${pattern.flags}) ` +
+                `is scoped 'both', but scanSsrfPatterns' two-pass cannot service 'both' — use 'line' or 'content'.`);
+        }
+    });
+}
+assertScopeCoverage();
+//# sourceMappingURL=patterns.scope.js.map

package/dist/src/security/scanner/patterns.scope.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"patterns.scope.js","sourceRoot":"","sources":["../../../../src/security/scanner/patterns.scope.ts"],"names":[],"mappings":"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"}

package/dist/src/security/scanner/regex-utils.d.ts

@@ -10,6 +10,26 @@
  * to prevent catastrophic backtracking attacks.
  */
 export declare const MAX_LINE_LENGTH_FOR_REGEX = 10000;
+/**
+ * SMI-5881: Cap for the FULL-CONTENT (multiline "pass 1") regex scan, in
+ * UTF-16 code units (JavaScript `string.length` — NOT bytes/code points; see
+ * SecurityScanner.ts's content-length finding message).
+ *
+ * Equal to MAX_LINE_LENGTH_FOR_REGEX today (both 10_000) but declared
+ * separately because the two caps protect different scan passes (per-line vs
+ * whole-document) and may need to diverge later. This is a ReDoS budget
+ * input, not a free parameter — raising it requires first proving
+ * AD_CRLF_INJECTION-class patterns stay linear at the new size. Measured
+ * (SMI-5881): the fixed AD_CRLF_INJECTION pattern is already ~4x slower per
+ * doubling of input size on some adversarial inputs at sizes past this cap,
+ * extrapolating to unacceptable latency well before 1,000,000 — so this cap
+ * is NOT raised as part of SMI-5881 even though larger trust tiers allow a
+ * much bigger `maxContentLength`. See SecurityScanner.ts's
+ * `effectiveMultilineLimit` (`Math.min(MAX_CONTENT_LENGTH_FOR_REGEX,
+ * maxContentLength)`) for how this interacts with the per-tier content-length
+ * ceiling.
+ */
+export declare const MAX_CONTENT_LENGTH_FOR_REGEX = 10000;
 /**
  * SMI-882: Safe regex test with length limit
  * Applies input length limit before regex matching to prevent ReDoS attacks.

package/dist/src/security/scanner/regex-utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"regex-utils.d.ts","sourceRoot":"","sources":["../../../../src/security/scanner/regex-utils.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;;;GAKG;AACH,eAAO,MAAM,yBAAyB,QAAQ,CAAA;AAE9C;;;;;;;;GAQG;AACH,wBAAgB,aAAa,CAC3B,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,MAAM,EACb,SAAS,GAAE,MAAkC,GAC5C,gBAAgB,GAAG,IAAI,CAIzB;AAED;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAC5B,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,MAAM,EACb,SAAS,GAAE,MAAkC,GAC5C,OAAO,CAIT"}
+{"version":3,"file":"regex-utils.d.ts","sourceRoot":"","sources":["../../../../src/security/scanner/regex-utils.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;;;GAKG;AACH,eAAO,MAAM,yBAAyB,QAAQ,CAAA;AAE9C;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,4BAA4B,QAA4B,CAAA;AAErE;;;;;;;;GAQG;AACH,wBAAgB,aAAa,CAC3B,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,MAAM,EACb,SAAS,GAAE,MAAkC,GAC5C,gBAAgB,GAAG,IAAI,CAIzB;AAED;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAC5B,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,MAAM,EACb,SAAS,GAAE,MAAkC,GAC5C,OAAO,CAIT"}

package/dist/src/security/scanner/regex-utils.js

@@ -10,6 +10,26 @@
  * to prevent catastrophic backtracking attacks.
  */
 export const MAX_LINE_LENGTH_FOR_REGEX = 10000;
+/**
+ * SMI-5881: Cap for the FULL-CONTENT (multiline "pass 1") regex scan, in
+ * UTF-16 code units (JavaScript `string.length` — NOT bytes/code points; see
+ * SecurityScanner.ts's content-length finding message).
+ *
+ * Equal to MAX_LINE_LENGTH_FOR_REGEX today (both 10_000) but declared
+ * separately because the two caps protect different scan passes (per-line vs
+ * whole-document) and may need to diverge later. This is a ReDoS budget
+ * input, not a free parameter — raising it requires first proving
+ * AD_CRLF_INJECTION-class patterns stay linear at the new size. Measured
+ * (SMI-5881): the fixed AD_CRLF_INJECTION pattern is already ~4x slower per
+ * doubling of input size on some adversarial inputs at sizes past this cap,
+ * extrapolating to unacceptable latency well before 1,000,000 — so this cap
+ * is NOT raised as part of SMI-5881 even though larger trust tiers allow a
+ * much bigger `maxContentLength`. See SecurityScanner.ts's
+ * `effectiveMultilineLimit` (`Math.min(MAX_CONTENT_LENGTH_FOR_REGEX,
+ * maxContentLength)`) for how this interacts with the per-tier content-length
+ * ceiling.
+ */
+export const MAX_CONTENT_LENGTH_FOR_REGEX = MAX_LINE_LENGTH_FOR_REGEX;
 /**
  * SMI-882: Safe regex test with length limit
  * Applies input length limit before regex matching to prevent ReDoS attacks.

package/dist/src/security/scanner/regex-utils.js.map

@@ -1 +1 @@
-{"version":3,"file":"regex-utils.js","sourceRoot":"","sources":["../../../../src/security/scanner/regex-utils.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;;;GAKG;AACH,MAAM,CAAC,MAAM,yBAAyB,GAAG,KAAK,CAAA;AAE9C;;;;;;;;GAQG;AACH,MAAM,UAAU,aAAa,CAC3B,OAAe,EACf,KAAa,EACb,YAAoB,yBAAyB;IAE7C,2DAA2D;IAC3D,MAAM,SAAS,GAAG,KAAK,CAAC,MAAM,GAAG,SAAS,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC,CAAC,CAAC,KAAK,CAAA;IAC9E,OAAO,SAAS,CAAC,KAAK,CAAC,OAAO,CAAC,CAAA;AACjC,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,cAAc,CAC5B,OAAe,EACf,KAAa,EACb,YAAoB,yBAAyB;IAE7C,2DAA2D;IAC3D,MAAM,SAAS,GAAG,KAAK,CAAC,MAAM,GAAG,SAAS,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC,CAAC,CAAC,KAAK,CAAA;IAC9E,OAAO,OAAO,CAAC,IAAI,CAAC,SAAS,CAAC,CAAA;AAChC,CAAC"}
+{"version":3,"file":"regex-utils.js","sourceRoot":"","sources":["../../../../src/security/scanner/regex-utils.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;;;GAKG;AACH,MAAM,CAAC,MAAM,yBAAyB,GAAG,KAAK,CAAA;AAE9C;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,CAAC,MAAM,4BAA4B,GAAG,yBAAyB,CAAA;AAErE;;;;;;;;GAQG;AACH,MAAM,UAAU,aAAa,CAC3B,OAAe,EACf,KAAa,EACb,YAAoB,yBAAyB;IAE7C,2DAA2D;IAC3D,MAAM,SAAS,GAAG,KAAK,CAAC,MAAM,GAAG,SAAS,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC,CAAC,CAAC,KAAK,CAAA;IAC9E,OAAO,SAAS,CAAC,KAAK,CAAC,OAAO,CAAC,CAAA;AACjC,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,cAAc,CAC5B,OAAe,EACf,KAAa,EACb,YAAoB,yBAAyB;IAE7C,2DAA2D;IAC3D,MAAM,SAAS,GAAG,KAAK,CAAC,MAAM,GAAG,SAAS,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC,CAAC,CAAC,KAAK,CAAA;IAC9E,OAAO,OAAO,CAAC,IAAI,CAAC,SAAS,CAAC,CAAA;AAChC,CAAC"}

package/dist/src/security/scanner/types.d.ts

@@ -18,6 +18,37 @@ export type SecuritySeverity = 'low' | 'medium' | 'high' | 'critical';
  * - low: Likely false positive (e.g., in documentation/examples)
  */
 export type FindingConfidence = 'high' | 'medium' | 'low';
+/**
+ * SMI-5876: evidence tier behind a jailbreak/ai_defence finding. A pattern is
+ * `mention`-tier iff its matched text, read in isolation, instructs nothing
+ * (a bare noun/name/label/structural marker/payload-free obfuscation
+ * artifact). Anything with a verb+object pairing or a second-person
+ * predicate is directive-tier.
+ *
+ * - `mention`                — payload-free vocabulary (e.g. bare `jailbreak`,
+ *   `DAN`, `developer mode`, a bare role marker with no body).
+ * - `role_turn_with_body`    — a fabricated conversation-turn boundary WITH an
+ *   instructing body (e.g. a role marker followed by a directive, or a
+ *   `<instruction>...</instruction>` block with content).
+ * - `imperative_instruction` — a second-person directive without an explicit
+ *   "override prior instructions" framing (e.g. "pretend you have no
+ *   restrictions").
+ * - `instruction_override`   — an explicit "ignore/disregard/override prior
+ *   instructions" directive.
+ * - `state_assertion`        — a DECLARATIVE assertion that a jailbroken/
+ *   unrestricted state is active, with no verb/frame aimed at the model
+ *   (e.g. "Jailbreak activated", "DAN mode enabled", "Developer mode: ON.
+ *   Restrictions: OFF"). Distinct machine-readable reason code from
+ *   `imperative_instruction` (the design REJECTED aimed-at-the-model framing
+ *   as a requirement here — a state assertion is evidence of an already-
+ *   completed jailbreak, not a request), but carries the SAME severity tuple
+ *   (critical non-doc / high doc) — see `EVIDENCE_SEVERITY_TABLE`.
+ *
+ * See `SecurityScanner.evidence.ts` for how this maps to severity/confidence,
+ * and `patterns.jailbreak.evidence.ts`'s `EVIDENCE_TYPE_BY_PATTERN` for the
+ * per-pattern classification.
+ */
+export type EvidenceType = 'mention' | 'role_turn_with_body' | 'imperative_instruction' | 'instruction_override' | 'state_assertion';
 /**
  * Individual security finding from a scan
  */
@@ -35,6 +66,10 @@ export interface SecurityFinding {
     confidence?: FindingConfidence;
     /** SMI-5436: Path of the skill bundle file that triggered this finding, relative to the skill root. Absent for SKILL.md-only findings. */
     filePath?: string;
+    /** SMI-5876: machine-readable evidence class behind this finding (jailbreak/ai_defence only). */
+    evidenceType?: EvidenceType;
+    /** SMI-5876: a mention-tier finding lifted by a co-occurring non-documentation high/critical signal. */
+    corroborated?: boolean;
 }
 /**
  * Risk score breakdown by category

package/dist/src/security/scanner/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/security/scanner/types.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;GAEG;AACH,MAAM,MAAM,mBAAmB,GAC3B,KAAK,GACL,gBAAgB,GAChB,WAAW,GACX,oBAAoB,GACpB,oBAAoB,GACpB,gBAAgB,GAChB,mBAAmB,GACnB,sBAAsB,GACtB,YAAY,GACZ,MAAM,GACN,KAAK,GACL,gBAAgB,GAChB,sBAAsB,GACtB,WAAW,CAAA;AAEf;;GAEG;AACH,MAAM,MAAM,gBAAgB,GAAG,KAAK,GAAG,QAAQ,GAAG,MAAM,GAAG,UAAU,CAAA;AAErE;;;;;GAKG;AACH,MAAM,MAAM,iBAAiB,GAAG,MAAM,GAAG,QAAQ,GAAG,KAAK,CAAA;AAEzD;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,mBAAmB,CAAA;IACzB,QAAQ,EAAE,gBAAgB,CAAA;IAC1B,OAAO,EAAE,MAAM,CAAA;IACf,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,6CAA6C;IAC7C,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,iFAAiF;IACjF,sBAAsB,CAAC,EAAE,OAAO,CAAA;IAChC,qEAAqE;IACrE,UAAU,CAAC,EAAE,iBAAiB,CAAA;IAC9B,0IAA0I;IAC1I,QAAQ,CAAC,EAAE,MAAM,CAAA;CAClB;AAED;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,SAAS,EAAE,MAAM,CAAA;IACjB,iBAAiB,EAAE,MAAM,CAAA;IACzB,aAAa,EAAE,MAAM,CAAA;IACrB,gBAAgB,EAAE,MAAM,CAAA;IACxB,mBAAmB,EAAE,MAAM,CAAA;IAC3B,cAAc,EAAE,MAAM,CAAA;IACtB,cAAc,EAAE,MAAM,CAAA;IACtB,YAAY,EAAE,MAAM,CAAA;IACpB,SAAS,EAAE,MAAM,CAAA;IACjB,IAAI,EAAE,MAAM,CAAA;IACZ,GAAG,EAAE,MAAM,CAAA;IACX,aAAa,EAAE,MAAM,CAAA;IACrB,mBAAmB,EAAE,MAAM,CAAA;IAC3B,SAAS,EAAE,MAAM,CAAA;CAClB;AAED;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,OAAO,EAAE,MAAM,CAAA;IACf,MAAM,EAAE,OAAO,CAAA;IACf,QAAQ,EAAE,eAAe,EAAE,CAAA;IAC3B,SAAS,EAAE,IAAI,CAAA;IACf,cAAc,EAAE,MAAM,CAAA;IACtB,0EAA0E;IAC1E,SAAS,EAAE,MAAM,CAAA;IACjB,0CAA0C;IAC1C,aAAa,EAAE,kBAAkB,CAAA;CAClC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,oBAAoB;IACnC,OAAO,EAAE,QAAQ,GAAG,YAAY,GAAG,SAAS,CAAA;IAC5C,8EAA8E;IAC9E,WAAW,EAAE,eAAe,EAAE,CAAA;IAC9B,qEAAqE;IACrE,SAAS,EAAE,MAAM,CAAA;IACjB,uEAAuE;IACvE,MAAM,EAAE,MAAM,CAAA;CACf;AAED;;;;;;;;GAQG;AACH,MAAM,MAAM,wBAAwB,GAAG,KAAK,GAAG,MAAM,GAAG,OAAO,CAAA;AAE/D;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,cAAc,CAAC,EAAE,MAAM,EAAE,CAAA;IACzB,eAAe,CAAC,EAAE,MAAM,EAAE,CAAA;IAC1B,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB,4DAA4D;IAC5D,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,sEAAsE;IACtE,wBAAwB,CAAC,EAAE,wBAAwB,CAAA;CACpD"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/security/scanner/types.ts"],"names":[],"mappings":"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"}

package/dist/src/services/recommend-guard.d.ts

@@ -0,0 +1,28 @@
+/**
+ * @fileoverview Shared empty-derived-stack guard for skill recommendations.
+ * @module @skillsmith/core/services/recommend-guard
+ * @see SMI-5896 (Wave 3, discovery-tool consistency): CLI `recommend` and MCP
+ *   `skill_recommend` each derive a technology "stack" client-side — CLI from
+ *   codebase analysis (`buildStackFromAnalysis`), MCP from installed skills +
+ *   project context keywords — and either can legitimately derive `[]` (a
+ *   non-Node stack, an all-devDeps project, or an unsupported language). The
+ *   `skills-recommend` edge function hard-rejects an empty `stack` with a 400
+ *   (defense in depth, intentionally unchanged by this fix — see the plan's
+ *   Wave 3 Step 2 "decided contract").
+ *
+ *   Both callers now detect the empty-stack case BEFORE calling the API
+ *   instead of letting the guaranteed-400 round trip happen and reacting to
+ *   the failure after the fact — this is the one guidance string they both
+ *   surface, so it can't drift between CLI and MCP wording the way the two
+ *   tools' pre-fix behavior already had (a hard `process.exit(1)` crash on
+ *   CLI vs a silently-swallowed warning on MCP for the exact same input
+ *   shape).
+ */
+/**
+ * Guidance shown when no technology stack could be derived for
+ * recommendations. Written to read naturally from both a terminal (CLI) and
+ * an MCP tool response consumed by a calling agent — neither surface names
+ * its own flag here, since the same string serves both.
+ */
+export declare function buildEmptyStackGuidance(): string;
+//# sourceMappingURL=recommend-guard.d.ts.map

package/dist/src/services/recommend-guard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recommend-guard.d.ts","sourceRoot":"","sources":["../../../src/services/recommend-guard.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH;;;;;GAKG;AACH,wBAAgB,uBAAuB,IAAI,MAAM,CAQhD"}

package/dist/src/services/recommend-guard.js

@@ -0,0 +1,34 @@
+/**
+ * @fileoverview Shared empty-derived-stack guard for skill recommendations.
+ * @module @skillsmith/core/services/recommend-guard
+ * @see SMI-5896 (Wave 3, discovery-tool consistency): CLI `recommend` and MCP
+ *   `skill_recommend` each derive a technology "stack" client-side — CLI from
+ *   codebase analysis (`buildStackFromAnalysis`), MCP from installed skills +
+ *   project context keywords — and either can legitimately derive `[]` (a
+ *   non-Node stack, an all-devDeps project, or an unsupported language). The
+ *   `skills-recommend` edge function hard-rejects an empty `stack` with a 400
+ *   (defense in depth, intentionally unchanged by this fix — see the plan's
+ *   Wave 3 Step 2 "decided contract").
+ *
+ *   Both callers now detect the empty-stack case BEFORE calling the API
+ *   instead of letting the guaranteed-400 round trip happen and reacting to
+ *   the failure after the fact — this is the one guidance string they both
+ *   surface, so it can't drift between CLI and MCP wording the way the two
+ *   tools' pre-fix behavior already had (a hard `process.exit(1)` crash on
+ *   CLI vs a silently-swallowed warning on MCP for the exact same input
+ *   shape).
+ */
+/**
+ * Guidance shown when no technology stack could be derived for
+ * recommendations. Written to read naturally from both a terminal (CLI) and
+ * an MCP tool response consumed by a calling agent — neither surface names
+ * its own flag here, since the same string serves both.
+ */
+export function buildEmptyStackGuidance() {
+    return ('No technology stack could be derived for recommendations — this usually ' +
+        'means a non-Node project, a stack with no production dependencies, or an ' +
+        'unsupported language, not a backend or registry problem. Provide project ' +
+        'context (a short description of the project or its tooling) or an ' +
+        'explicit list of installed/currently-used skills, then try again.');
+}
+//# sourceMappingURL=recommend-guard.js.map

package/dist/src/services/recommend-guard.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"recommend-guard.js","sourceRoot":"","sources":["../../../src/services/recommend-guard.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH;;;;;GAKG;AACH,MAAM,UAAU,uBAAuB;IACrC,OAAO,CACL,0EAA0E;QAC1E,2EAA2E;QAC3E,2EAA2E;QAC3E,oEAAoE;QACpE,mEAAmE,CACpE,CAAA;AACH,CAAC"}

package/dist/src/services/recommend-guard.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=recommend-guard.test.d.ts.map

package/dist/src/services/recommend-guard.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recommend-guard.test.d.ts","sourceRoot":"","sources":["../../../src/services/recommend-guard.test.ts"],"names":[],"mappings":""}

package/dist/src/services/recommend-guard.test.js

@@ -0,0 +1,28 @@
+/**
+ * @fileoverview Unit tests for the shared empty-derived-stack guidance string
+ *   (SMI-5896 Wave 3 Step 2). Both CLI `recommend` and MCP `skill_recommend`
+ *   surface this exact string so their empty-stack messaging can't drift.
+ * @module @skillsmith/core/services/recommend-guard.test
+ */
+import { describe, expect, it } from 'vitest';
+import { buildEmptyStackGuidance } from './recommend-guard.js';
+describe('buildEmptyStackGuidance (SMI-5896 Wave 3 Step 2)', () => {
+    it('returns a non-empty string', () => {
+        const guidance = buildEmptyStackGuidance();
+        expect(typeof guidance).toBe('string');
+        expect(guidance.length).toBeGreaterThan(0);
+    });
+    it('explains the empty stack is a legitimate under-detection, not a backend fault', () => {
+        const guidance = buildEmptyStackGuidance();
+        expect(guidance).toContain('No technology stack could be derived');
+    });
+    it('guides the caller toward providing context or an installed-skills list', () => {
+        const guidance = buildEmptyStackGuidance();
+        expect(guidance.toLowerCase()).toContain('project context');
+        expect(guidance.toLowerCase()).toContain('installed');
+    });
+    it('is deterministic (identical wording every call) so CLI and MCP never drift apart', () => {
+        expect(buildEmptyStackGuidance()).toBe(buildEmptyStackGuidance());
+    });
+});
+//# sourceMappingURL=recommend-guard.test.js.map

package/dist/src/services/recommend-guard.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"recommend-guard.test.js","sourceRoot":"","sources":["../../../src/services/recommend-guard.test.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,QAAQ,CAAA;AAE7C,OAAO,EAAE,uBAAuB,EAAE,MAAM,sBAAsB,CAAA;AAE9D,QAAQ,CAAC,kDAAkD,EAAE,GAAG,EAAE;IAChE,EAAE,CAAC,4BAA4B,EAAE,GAAG,EAAE;QACpC,MAAM,QAAQ,GAAG,uBAAuB,EAAE,CAAA;QAC1C,MAAM,CAAC,OAAO,QAAQ,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAA;QACtC,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,eAAe,CAAC,CAAC,CAAC,CAAA;IAC5C,CAAC,CAAC,CAAA;IAEF,EAAE,CAAC,+EAA+E,EAAE,GAAG,EAAE;QACvF,MAAM,QAAQ,GAAG,uBAAuB,EAAE,CAAA;QAC1C,MAAM,CAAC,QAAQ,CAAC,CAAC,SAAS,CAAC,sCAAsC,CAAC,CAAA;IACpE,CAAC,CAAC,CAAA;IAEF,EAAE,CAAC,wEAAwE,EAAE,GAAG,EAAE;QAChF,MAAM,QAAQ,GAAG,uBAAuB,EAAE,CAAA;QAC1C,MAAM,CAAC,QAAQ,CAAC,WAAW,EAAE,CAAC,CAAC,SAAS,CAAC,iBAAiB,CAAC,CAAA;QAC3D,MAAM,CAAC,QAAQ,CAAC,WAAW,EAAE,CAAC,CAAC,SAAS,CAAC,WAAW,CAAC,CAAA;IACvD,CAAC,CAAC,CAAA;IAEF,EAAE,CAAC,kFAAkF,EAAE,GAAG,EAAE;QAC1F,MAAM,CAAC,uBAAuB,EAAE,CAAC,CAAC,IAAI,CAAC,uBAAuB,EAAE,CAAC,CAAA;IACnE,CAAC,CAAC,CAAA;AACJ,CAAC,CAAC,CAAA"}