@skillsmith/core 0.11.7 → 0.12.0

package/dist/src/security/scanner/SecurityScanner.exec.js

@@ -7,10 +7,16 @@
  * Unicode-concealment attacks the prod edge gate currently scores at ~1 point:
  *
  *  • code_execution     — a skill instructing a remote fetch piped into an
- *    interpreter (curl|bash and friends). Emits ONE medium finding (score 12,
- *    sub-threshold) on its own; escalated to critical (score 40, quarantines)
- *    only when it co-occurs with a NON-documentation exfiltration / privilege /
- *    credential-path / obfuscation signal. The non-doc gate keeps legitimate
+ *    interpreter (curl|bash and friends), or — SMI-6033 Wave 4, Gap 1 — the
+ *    same instruction written as free-text prose with no shell syntax at all
+ *    ("download the installer from thisurl.com and run it",
+ *    `IMPERATIVE_FETCH_EXEC_PROSE` in patterns.exec.ts). Emits ONE medium
+ *    finding (score 12, sub-threshold) on its own, whichever pattern set
+ *    fired; escalated to critical (score 40, quarantines) only when it
+ *    co-occurs with a NON-documentation exfiltration / privilege /
+ *    credential-path / obfuscation signal, OR — SMI-6033 Wave 4, Gap 6 — with
+ *    TWO DISTINCT high-confidence advisory-tier signals
+ *    (`CO_SIGNAL_MIN_SEVERITY` below). The non-doc gate keeps legitimate
  *    security-research skills (which document these techniques inside fenced
  *    examples) below the threshold.
  *
@@ -30,7 +36,10 @@
  *    representation) is an attack even inside a fenced block — there is no
  *    legitimate reason to ship invisible/homoglyph-spliced directives.
  */
-import { CODE_EXECUTION_PATTERNS } from './patterns.js';
+// SMI-6033 Wave 4 (Gap 1): both code_execution pattern sets now live in the
+// patterns.exec.ts sibling (patterns.ts re-exports them unchanged); imported
+// from their source of truth here.
+import { CODE_EXECUTION_PATTERNS, IMPERATIVE_FETCH_EXEC_PROSE } from './patterns.exec.js';
 import { safeRegexTest, safeRegexCheck } from './regex-utils.js';
 import { analyzeMarkdownContext, isDocumentationContext } from './SecurityScanner.helpers.js';
 // SMI-595: confusable/homoglyph primitives extracted to a standalone module
@@ -81,32 +90,53 @@ const OBFUSCATION_DIRECTIVE_PATTERN = /(?:ignore|disregard|forget)\s+(?:all\s+|t
 // Detectors
 // ============================================================================
 /**
- * code_execution: remote fetch piped into an interpreter. Single-emission — at
- * most one MEDIUM finding per skill (the first match). escalateCodeExecution()
+ * code_execution: remote fetch piped into an interpreter (literal shell
+ * syntax), OR — SMI-6033 Wave 4, Gap 1 — the same instruction expressed as a
+ * natural-language install-and-run imperative with no shell syntax at all.
+ *
+ * Single-emission — at most one MEDIUM finding per skill (the first match, in
+ * line order), whichever pattern set produced it. escalateCodeExecution()
  * promotes it to CRITICAL on co-occurrence.
+ *
+ * Ordering is deliberately line-major (each line is tested against the literal
+ * syntax set first, then the prose set, before moving to the next line), so a
+ * document containing only literal-syntax matches produces byte-identical
+ * output to the pre-Gap-1 detector — same line, same message, same severity.
+ * The message names WHICH set fired so a reviewer can tell a prose-triggered
+ * finding from a syntax-triggered one at a glance.
  */
 export function scanCodeExecution(content, lineContexts) {
     const lines = content.split('\n');
     const contexts = lineContexts ?? analyzeMarkdownContext(content);
+    const emit = (i, line, matched, prefix) => {
+        const ctx = contexts[i];
+        const inDocContext = ctx ? isDocumentationContext(ctx) : false;
+        return [
+            {
+                type: 'code_execution',
+                severity: 'medium',
+                message: `${prefix}: "${matched.slice(0, 60)}${matched.length > 60 ? '...' : ''}"`,
+                location: line.trim().slice(0, 100),
+                lineNumber: i + 1,
+                category: 'code_execution',
+                inDocumentationContext: inDocContext,
+                confidence: 'high',
+            },
+        ];
+    };
     for (let i = 0; i < lines.length; i++) {
         const line = lines[i];
         for (const pattern of CODE_EXECUTION_PATTERNS) {
+            const match = safeRegexTest(pattern, line);
+            if (match)
+                return emit(i, line, match[0], 'Remote fetch piped to an interpreter');
+        }
+        // SMI-6033 Wave 4 (Gap 1): same finding type, same medium/advisory tier —
+        // only the evidence shape differs (free-text imperative, no shell syntax).
+        for (const pattern of IMPERATIVE_FETCH_EXEC_PROSE) {
             const match = safeRegexTest(pattern, line);
             if (match) {
-                const ctx = contexts[i];
-                const inDocContext = ctx ? isDocumentationContext(ctx) : false;
-                return [
-                    {
-                        type: 'code_execution',
-                        severity: 'medium',
-                        message: `Remote fetch piped to an interpreter: "${match[0].slice(0, 60)}${match[0].length > 60 ? '...' : ''}"`,
-                        location: line.trim().slice(0, 100),
-                        lineNumber: i + 1,
-                        category: 'code_execution',
-                        inDocumentationContext: inDocContext,
-                        confidence: 'high',
-                    },
-                ];
+                return emit(i, line, match[0], 'Natural-language instruction to fetch a remote file and execute it');
             }
         }
     }
@@ -159,35 +189,69 @@ export function scanObfuscatedDirective(content) {
     return [];
 }
 /**
- * Co-occurrence types that turn a remote-fetch-to-interpreter from "suspicious"
- * (medium) into "supply-chain execution" (critical).
+ * SMI-6033 Wave 4 (Gap 6): per-type MINIMUM co-signal severity, replacing the
+ * flat `CODE_EXECUTION_CO_OCCURRENCE` set. Equality-parity-pinned against its
+ * edge twin (security-scanner-edge.exec.ts) — identical keys AND identical
+ * values, not a superset; see the co-signal parity test in
+ * scripts/tests/indexer/security-scanner-edge.co-signal-escalation.test.ts.
+ *
+ * A `'high'` minimum means "one such co-signal escalates on its own" (path a
+ * below — today's behavior, byte-identical for the original four types). A
+ * `'medium'` minimum means "advisory tier: never sufficient alone, but two
+ * DISTINCT such types together escalate" (path b). A type absent from this
+ * map is not a co-signal at all.
  */
-const CODE_EXECUTION_CO_OCCURRENCE = new Set([
-    'data_exfiltration',
-    'privilege_escalation',
-    'sensitive_path',
-    'obfuscated_directive',
-]);
+const CO_SIGNAL_MIN_SEVERITY = {
+    // Existing four — behavior byte-identical to today, min 'high'.
+    data_exfiltration: 'high',
+    privilege_escalation: 'high',
+    sensitive_path: 'high',
+    obfuscated_directive: 'high',
+    // New ClawHavoc advisory-tier categories — eligible at 'medium'.
+    decoy_misdirection: 'medium',
+    archive_evasion: 'medium',
+    paste_host_fetch: 'medium',
+    gatekeeper_bypass: 'medium', // its correlated/critical form already quarantines on its own
+};
+/** Ordinal ranking so "at or above its type's minimum" is a single comparison. */
+const SEVERITY_RANK = { low: 0, medium: 1, high: 2, critical: 3 };
 /**
  * Maximum line distance between the `code_execution` finding and the co-signal
  * that escalates it (SMI-5880). Before this bound, a co-signal ANYWHERE in the
  * document — any distance, any unrelated section — escalated the single
  * `code_execution` finding to critical.
  *
- * Why a bounded window is NOT a bypass vector: every eligible co-signal is
- * already `high` or `critical`, and `scan()` (SecurityScanner.ts) computes
- * `passed = !hasCritical && !hasHigh && !exceedsThreshold` across ALL findings
- * with no locality filter and no documentation filter. A qualifying co-signal
- * anywhere therefore forces `passed === false` on its own, BEFORE this function
- * runs. Splitting the two signals to duck this window cannot turn a failing scan
- * into a passing one; it changes only this finding's own label (medium vs
- * critical) and the risk-score magnitude of a scan that already blocks.
+ * Why a bounded window is NOT a bypass vector FOR PATH (a): every `'high'`-
+ * minimum co-signal is itself `high` or `critical`, and `scan()`
+ * (SecurityScanner.ts) computes `passed = !hasCritical && !hasHigh &&
+ * !exceedsThreshold` across ALL findings with no locality filter and no
+ * documentation filter. A qualifying path-(a) co-signal anywhere therefore
+ * forces `passed === false` on its own, BEFORE this function runs. Splitting
+ * the two signals to duck this window cannot turn a failing scan into a
+ * passing one; it changes only this finding's own label (medium vs critical)
+ * and the risk-score magnitude of a scan that already blocks.
  * Hostile-update detection is likewise untouched: `detectSupplyChain()`
  * (SecurityScanner.hostile-update.ts) pairs a NEW non-doc `code_execution` of ANY
  * severity with a NEW non-doc high/critical co-signal at ANY distance, so a
  * far-apart rug-pull still returns the `hostile` verdict and its supply-chain
  * reason string.
  *
+ * SMI-6033 Wave 4 (Gap 6) — that argument does NOT carry over to path (b),
+ * and the difference is deliberate, not an oversight. Path (b)'s co-signals
+ * are `medium` advisory findings that do NOT independently trip `passed`, so
+ * an attacker who spreads the weak `code_execution` finding and its two
+ * advisory co-signals more than 40 lines apart genuinely does keep a scan
+ * under the bar (12 + 12 + 12 = 36 < the 40 threshold) that would otherwise
+ * have escalated to critical. This is the accepted cost of bounding locality
+ * at all: the alternative — an unbounded window for fuzzy heuristic signals —
+ * re-creates the exact SMI-5880 defect (an unrelated advisory finding in a
+ * different section escalating an unrelated `code_execution` finding) with a
+ * far higher false-positive rate than the high-tier co-signals ever had,
+ * because these signals are approximate by construction. The residual is
+ * bounded: the attack still requires the two advisory signals to be real
+ * detections in the same document, and `detectSupplyChain()`'s
+ * distance-independent rug-pull check above is unaffected.
+ *
  * Deliberately the same 40 as the sibling corroboration mechanism's locality
  * constant (SecurityScanner.evidence.ts) so the scanner has ONE locality model
  * — but kept as its own constant, not imported: the two mechanisms are
@@ -205,11 +269,13 @@ const MAX_CODE_EXECUTION_CO_SIGNAL_LINE_DISTANCE = 40;
  * that pair rather than suppressing the co-signal.
  *
  * Unreachable through `scan()` today: `scanCodeExecution` above and every emitter
- * of the four CODE_EXECUTION_CO_OCCURRENCE types set `lineNumber` unconditionally
+ * of the eight `CO_SIGNAL_MIN_SEVERITY` types set `lineNumber` unconditionally
  * (the sensitive-path/data-exfiltration/privilege-escalation scanners in the
- * scanners module, the chmod-compound detector, and `scanObfuscatedDirective`
- * above). Kept as an explicit, directly-tested branch so a future detector that
- * forgets `lineNumber` degrades safe instead of silently ceasing to escalate.
+ * scanners module, the chmod-compound and Gatekeeper-bypass detectors,
+ * `scanObfuscatedDirective` above, and — SMI-6033 — the archive-evasion,
+ * paste-host and decoy-misdirection detectors). Kept as an explicit,
+ * directly-tested branch so a future detector that forgets `lineNumber`
+ * degrades safe instead of silently ceasing to escalate.
  */
 function isWithinCoSignalWindow(codeExecLine, coSignalLine) {
     if (typeof codeExecLine !== 'number' || typeof coSignalLine !== 'number')
@@ -217,31 +283,120 @@ function isWithinCoSignalWindow(codeExecLine, coSignalLine) {
     return Math.abs(codeExecLine - coSignalLine) <= MAX_CODE_EXECUTION_CO_SIGNAL_LINE_DISTANCE;
 }
 /**
- * Escalate the code_execution finding to CRITICAL when a NON-documentation
- * high/critical exfiltration / privilege / credential-path / obfuscation signal
- * is also present WITHIN `MAX_CODE_EXECUTION_CO_SIGNAL_LINE_DISTANCE` lines
- * (SMI-5880 — previously any distance qualified, so an unrelated finding in a
- * different section of a long document escalated an unrelated code_execution
- * finding). Mutates the finding in place. Requiring the co-signal to be
- * non-documentation keeps legitimate security-research skills (whose examples
- * live in fenced blocks) at MEDIUM.
+ * Escalate the code_execution finding (literal `curl|bash` syntax OR a Gap-1
+ * `IMPERATIVE_FETCH_EXEC_PROSE` match — same finding type either way) to
+ * CRITICAL, on either of two paths. Both require: the `code_execution`
+ * finding ITSELF to be non-documentation (see the adversarial-review fix
+ * note below), the co-signal to be NON-documentation, and the co-signal to be
+ * WITHIN `MAX_CODE_EXECUTION_CO_SIGNAL_LINE_DISTANCE` lines (SMI-5880 —
+ * previously any distance qualified, so an unrelated finding in a different
+ * section of a long document escalated an unrelated code_execution finding).
+ * Mutates the finding in place.
+ *
+ * Path (a) — ONE co-signal whose type's `CO_SIGNAL_MIN_SEVERITY` minimum is
+ * `'high'`, at `high` or `critical`. Byte-identical to the pre-SMI-6033
+ * behavior for the original four types (`data_exfiltration`,
+ * `privilege_escalation`, `sensitive_path`, `obfuscated_directive`) EXCEPT
+ * for the `codeExec`-own-doc-context fix below (see that note — the
+ * pre-existing behavior there was a real gap, not an intentional design):
+ * same co-signal membership test, same severity test, same locality gate,
+ * same message. Deliberately NO confidence requirement on the CO-SIGNAL here
+ * — adding one would change existing behavior, which the Gap 6 design
+ * explicitly forbids.
+ *
+ * Path (b) — SMI-6033 Wave 4 (Gap 6), only evaluated when path (a) did not
+ * fire: at least TWO DISTINCT `'medium'`-minimum types (two findings of the
+ * SAME type do not count), each at or above its own minimum. A single fuzzy
+ * medium signal (one decoy mismatch alone, one transfer.sh link alone) can
+ * therefore never flip a legitimate vendor `curl|bash` to critical.
+ *
+ * Confidence requirement (revised after adversarial review, 2026-08-16 —
+ * see `docs/internal/code_review/2026-08-15-smi6033-wave4-escalation-model.md`
+ * for the full account): the plan's literal text requires `confidence:
+ * 'high'` on both path-(b) co-signals. An earlier revision of this file
+ * relaxed that to `confidence !== 'low'` GLOBALLY, reasoning that
+ * `paste_host_fetch`'s ANON/TRANSIENT medium form is ALWAYS
+ * `confidence: 'medium'` by construction (`SecurityScanner.paste-host.ts`)
+ * and would otherwise be permanently unable to satisfy path (b) despite
+ * being a registered-eligible type. That reasoning was correct for
+ * `paste_host_fetch` specifically, but the GLOBAL relaxation was wrong: it
+ * also admitted `archive_evasion`'s prose-only co-occurrence sub-signal
+ * (explicitly documented in that file's own header as "the fuzzy, FP-prone
+ * case" and capped at `confidence: 'medium'` for exactly that reason) and
+ * `decoy_misdirection`'s no-authority-affix form (also `confidence:
+ * 'medium'`) — an adversarial review constructed a working false-positive
+ * example combining exactly those two fuzzy medium-confidence signals (a
+ * mundane "distributed from our company site" skill blurb plus an unrelated
+ * "supplied as a zip archive... ask your administrator for the password"
+ * sentence) with a real vendor `curl|bash`, and it escalated to a hard
+ * quarantine. Fixed by narrowing the confidence carve-out to ONLY
+ * `paste_host_fetch` (`CO_SIGNAL_MEDIUM_CONFIDENCE_EXCEPTION` below) — every
+ * other medium-minimum type reverts to requiring `confidence: 'high'`,
+ * matching the plan's literal text. `gatekeeper_bypass` loses nothing by
+ * this (its own detector always emits `confidence: 'high'` regardless of
+ * severity); `archive_evasion` and `decoy_misdirection` now only participate
+ * via their own higher-confidence forms (CLI-syntax inline-secret-adjacent
+ * password mentions; an authority-affix-boosted brand claim), which is
+ * exactly the "not noise" signal path (b) was meant to require. See the
+ * co-signal escalation tests for the pinned behavior of this decision.
+ *
+ * `codeExec`-own-doc-context fix (same adversarial review): neither path
+ * previously checked `codeExec.inDocumentationContext` itself — only the
+ * CO-SIGNAL's doc-context was checked. A `code_execution` finding inside a
+ * fenced security-research example could therefore still be escalated by
+ * two genuine (non-doc) co-signals elsewhere in the document, contradicting
+ * this function's own historical doc comments claiming fenced examples stay
+ * at MEDIUM. This gap predates Wave 4 (path (a) had it too) but Wave 4's new
+ * path (b) co-signal types meaningfully widen how often it's reachable, so
+ * it's fixed here for both paths rather than left in place for path (a)
+ * alone.
  *
  * Runs BEFORE the sibling corroboration mechanism in `scan()` — see that
  * function's doc comment (SecurityScanner.evidence.ts) for why the ordering is
  * safe in both directions.
  */
+const CO_SIGNAL_MEDIUM_CONFIDENCE_EXCEPTION = new Set([
+    'paste_host_fetch',
+]);
 export function escalateCodeExecution(findings) {
     const codeExec = findings.find((f) => f.type === 'code_execution');
     if (!codeExec)
         return;
-    const hasDangerousCoSignal = findings.some((f) => f !== codeExec &&
-        CODE_EXECUTION_CO_OCCURRENCE.has(f.type) &&
+    if (codeExec.inDocumentationContext === true)
+        return;
+    const eligible = findings.filter((f) => f !== codeExec &&
+        CO_SIGNAL_MIN_SEVERITY[f.type] !== undefined &&
         f.inDocumentationContext !== true &&
-        (f.severity === 'high' || f.severity === 'critical') &&
         isWithinCoSignalWindow(codeExec.lineNumber, f.lineNumber));
+    // Path (a): one high-minimum co-signal at high/critical.
+    const hasDangerousCoSignal = eligible.some((f) => CO_SIGNAL_MIN_SEVERITY[f.type] === 'high' &&
+        (f.severity === 'high' || f.severity === 'critical'));
     if (hasDangerousCoSignal) {
         codeExec.severity = 'critical';
         codeExec.message = `Remote fetch piped to an interpreter, co-occurring with exfiltration/privilege/credential signals — likely supply-chain execution. ${codeExec.message}`;
+        return;
+    }
+    // Path (b): two DISTINCT medium-minimum types, each confidence 'high' —
+    // except paste_host_fetch, whose medium form is always confidence:'medium'
+    // by construction (see this function's doc comment for the full rationale
+    // and the adversarial-review finding that narrowed this from a blanket
+    // `!== 'low'` relaxation).
+    const advisoryTypes = new Set(eligible
+        .filter((f) => {
+        const min = CO_SIGNAL_MIN_SEVERITY[f.type];
+        const confidenceOk = CO_SIGNAL_MEDIUM_CONFIDENCE_EXCEPTION.has(f.type)
+            ? f.confidence !== 'low'
+            : f.confidence === 'high';
+        return min === 'medium' && SEVERITY_RANK[f.severity] >= SEVERITY_RANK[min] && confidenceOk;
+    })
+        .map((f) => f.type));
+    if (advisoryTypes.size >= 2) {
+        codeExec.severity = 'critical';
+        codeExec.message = `Remote fetch/execute instruction corroborated by two independent advisory-tier signals (${[
+            ...advisoryTypes,
+        ]
+            .sort()
+            .join(', ')}) — likely supply-chain execution. ${codeExec.message}`;
     }
 }
 //# sourceMappingURL=SecurityScanner.exec.js.map

package/dist/src/security/scanner/SecurityScanner.exec.js.map

@@ -1 +1 @@
-{"version":3,"file":"SecurityScanner.exec.js","sourceRoot":"","sources":["../../../../src/security/scanner/SecurityScanner.exec.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"SecurityScanner.exec.js","sourceRoot":"","sources":["../../../../src/security/scanner/SecurityScanner.exec.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AAGH,4EAA4E;AAC5E,6EAA6E;AAC7E,mCAAmC;AACnC,OAAO,EAAE,uBAAuB,EAAE,2BAA2B,EAAE,MAAM,oBAAoB,CAAA;AACzF,OAAO,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAA;AAEhE,OAAO,EAAE,sBAAsB,EAAE,sBAAsB,EAAE,MAAM,8BAA8B,CAAA;AAC7F,4EAA4E;AAC5E,6EAA6E;AAC7E,qEAAqE;AACrE,mCAAmC;AACnC,OAAO,EACL,WAAW,EACX,gBAAgB,EAChB,kBAAkB,EAClB,kBAAkB,GACnB,MAAM,kBAAkB,CAAA;AAEzB,+EAA+E;AAC/E,yBAAyB;AACzB,+EAA+E;AAE/E;;;;;GAKG;AACH,MAAM,eAAe,GACnB,yGAAyG,CAAA;AAC3G,MAAM,cAAc,GAAG,IAAI,MAAM,CAAC,GAAG,GAAG,eAAe,GAAG,2BAA2B,EAAE,GAAG,CAAC,CAAA;AAC3F,MAAM,eAAe,GAAG,IAAI,MAAM,CAAC,GAAG,GAAG,eAAe,GAAG,2BAA2B,EAAE,IAAI,CAAC,CAAA;AAE7F;;;;;GAKG;AACH,MAAM,UAAU,cAAc,CAAC,CAAS;IACtC,OAAO,CAAC,CAAC,OAAO,CAAC,eAAe,EAAE,EAAE,CAAC,CAAA;AACvC,CAAC;AAED,6FAA6F;AAC7F,SAAS,aAAa,CAAC,CAAS;IAC9B,KAAK,MAAM,EAAE,IAAI,CAAC,EAAE,CAAC;QACnB,MAAM,EAAE,GAAG,EAAE,CAAC,WAAW,CAAC,CAAC,CAAC,IAAI,CAAC,CAAA;QACjC,IAAI,gBAAgB,CAAC,EAAE,CAAC,IAAI,kBAAkB,CAAC,EAAE,CAAC,IAAI,WAAW,CAAC,EAAE,CAAC;YAAE,OAAO,IAAI,CAAA;IACpF,CAAC;IACD,OAAO,KAAK,CAAA;AACd,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,6BAA6B,GACjC,0ZAA0Z,CAAA;AAE5Z,+EAA+E;AAC/E,YAAY;AACZ,+EAA+E;AAE/E;;;;;;;;;;;;;;;GAeG;AACH,MAAM,UAAU,iBAAiB,CAC/B,OAAe,EACf,YAA4B;IAE5B,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,CAAA;IACjC,MAAM,QAAQ,GAAG,YAAY,IAAI,sBAAsB,CAAC,OAAO,CAAC,CAAA;IAEhE,MAAM,IAAI,GAAG,CAAC,CAAS,EAAE,IAAY,EAAE,OAAe,EAAE,MAAc,EAAqB,EAAE;QAC3F,MAAM,GAAG,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAA;QACvB,MAAM,YAAY,GAAG,GAAG,CAAC,CAAC,CAAC,sBAAsB,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,KAAK,CAAA;QAC9D,OAAO;YACL;gBACE,IAAI,EAAE,gBAAgB;gBACtB,QAAQ,EAAE,QAAQ;gBAClB,OAAO,EAAE,GAAG,MAAM,MAAM,OAAO,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,GAAG,OAAO,CAAC,MAAM,GAAG,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,GAAG;gBAClF,QAAQ,EAAE,IAAI,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,CAAC,EAAE,GAAG,CAAC;gBACnC,UAAU,EAAE,CAAC,GAAG,CAAC;gBACjB,QAAQ,EAAE,gBAAgB;gBAC1B,sBAAsB,EAAE,YAAY;gBACpC,UAAU,EAAE,MAAM;aACnB;SACF,CAAA;IACH,CAAC,CAAA;IAED,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACtC,MAAM,IAAI,GAAG,KAAK,CAAC,CAAC,CAAC,CAAA;QACrB,KAAK,MAAM,OAAO,IAAI,uBAAuB,EAAE,CAAC;YAC9C,MAAM,KAAK,GAAG,aAAa,CAAC,OAAO,EAAE,IAAI,CAAC,CAAA;YAC1C,IAAI,KAAK;gBAAE,OAAO,IAAI,CAAC,CAAC,EAAE,IAAI,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,sCAAsC,CAAC,CAAA;QACnF,CAAC;QACD,0EAA0E;QAC1E,2EAA2E;QAC3E,KAAK,MAAM,OAAO,IAAI,2BAA2B,EAAE,CAAC;YAClD,MAAM,KAAK,GAAG,aAAa,CAAC,OAAO,EAAE,IAAI,CAAC,CAAA;YAC1C,IAAI,KAAK,EAAE,CAAC;gBACV,OAAO,IAAI,CACT,CAAC,EACD,IAAI,EACJ,KAAK,CAAC,CAAC,CAAC,EACR,oEAAoE,CACrE,CAAA;YACH,CAAC;QACH,CAAC;IACH,CAAC;IACD,OAAO,EAAE,CAAA;AACX,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,uBAAuB,CAAC,OAAe;IACrD,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,CAAA;IAEjC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACtC,MAAM,GAAG,GAAG,KAAK,CAAC,CAAC,CAAC,CAAA;QACpB,MAAM,YAAY,GAAG,cAAc,CAAC,IAAI,CAAC,GAAG,CAAC,CAAA;QAC7C,MAAM,OAAO,GAAG,aAAa,CAAC,GAAG,CAAC,CAAA;QAClC,IAAI,CAAC,YAAY,IAAI,CAAC,OAAO;YAAE,SAAQ;QACvC,8DAA8D;QAC9D,IAAI,cAAc,CAAC,6BAA6B,EAAE,GAAG,CAAC;YAAE,SAAQ;QAEhE,MAAM,UAAU,GAAa,EAAE,CAAA;QAC/B,IAAI,YAAY;YAAE,UAAU,CAAC,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,CAAC,CAAA;QACtD,IAAI,OAAO;YAAE,UAAU,CAAC,IAAI,CAAC,kBAAkB,CAAC,GAAG,CAAC,CAAC,CAAA;QACrD,IAAI,YAAY,IAAI,OAAO;YAAE,UAAU,CAAC,IAAI,CAAC,kBAAkB,CAAC,cAAc,CAAC,GAAG,CAAC,CAAC,CAAC,CAAA;QAErF,KAAK,MAAM,WAAW,IAAI,UAAU,EAAE,CAAC;YACrC,IAAI,WAAW,KAAK,GAAG;gBAAE,SAAQ;YACjC,MAAM,KAAK,GAAG,aAAa,CAAC,6BAA6B,EAAE,WAAW,CAAC,CAAA;YACvE,IAAI,KAAK,EAAE,CAAC;gBACV,OAAO;oBACL;wBACE,IAAI,EAAE,sBAAsB;wBAC5B,QAAQ,EAAE,UAAU;wBACpB,OAAO,EAAE,yFAAyF,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAC9G,CAAC,EACD,EAAE,CACH,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,MAAM,GAAG,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,GAAG;wBACxC,QAAQ,EAAE,GAAG,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,CAAC,EAAE,GAAG,CAAC;wBAClC,UAAU,EAAE,CAAC,GAAG,CAAC;wBACjB,QAAQ,EAAE,sBAAsB;wBAChC,sBAAsB,EAAE,KAAK;wBAC7B,UAAU,EAAE,MAAM;qBACnB;iBACF,CAAA;YACH,CAAC;QACH,CAAC;IACH,CAAC;IACD,OAAO,EAAE,CAAA;AACX,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,sBAAsB,GAA2D;IACrF,gEAAgE;IAChE,iBAAiB,EAAE,MAAM;IACzB,oBAAoB,EAAE,MAAM;IAC5B,cAAc,EAAE,MAAM;IACtB,oBAAoB,EAAE,MAAM;IAC5B,iEAAiE;IACjE,kBAAkB,EAAE,QAAQ;IAC5B,eAAe,EAAE,QAAQ;IACzB,gBAAgB,EAAE,QAAQ;IAC1B,iBAAiB,EAAE,QAAQ,EAAE,8DAA8D;CAC5F,CAAA;AAED,kFAAkF;AAClF,MAAM,aAAa,GAAqC,EAAE,GAAG,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,CAAA;AAEnG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,MAAM,0CAA0C,GAAG,EAAE,CAAA;AAErD;;;;;;;;;;;;;;;;;GAiBG;AACH,SAAS,sBAAsB,CAAC,YAAqB,EAAE,YAAqB;IAC1E,IAAI,OAAO,YAAY,KAAK,QAAQ,IAAI,OAAO,YAAY,KAAK,QAAQ;QAAE,OAAO,IAAI,CAAA;IACrF,OAAO,IAAI,CAAC,GAAG,CAAC,YAAY,GAAG,YAAY,CAAC,IAAI,0CAA0C,CAAA;AAC5F,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwEG;AACH,MAAM,qCAAqC,GAAqC,IAAI,GAAG,CAAC;IACtF,kBAAkB;CACnB,CAAC,CAAA;AAEF,MAAM,UAAU,qBAAqB,CAAC,QAA2B;IAC/D,MAAM,QAAQ,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,gBAAgB,CAAC,CAAA;IAClE,IAAI,CAAC,QAAQ;QAAE,OAAM;IACrB,IAAI,QAAQ,CAAC,sBAAsB,KAAK,IAAI;QAAE,OAAM;IAEpD,MAAM,QAAQ,GAAG,QAAQ,CAAC,MAAM,CAC9B,CAAC,CAAC,EAAE,EAAE,CACJ,CAAC,KAAK,QAAQ;QACd,sBAAsB,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,SAAS;QAC5C,CAAC,CAAC,sBAAsB,KAAK,IAAI;QACjC,sBAAsB,CAAC,QAAQ,CAAC,UAAU,EAAE,CAAC,CAAC,UAAU,CAAC,CAC5D,CAAA;IAED,yDAAyD;IACzD,MAAM,oBAAoB,GAAG,QAAQ,CAAC,IAAI,CACxC,CAAC,CAAC,EAAE,EAAE,CACJ,sBAAsB,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,MAAM;QACzC,CAAC,CAAC,CAAC,QAAQ,KAAK,MAAM,IAAI,CAAC,CAAC,QAAQ,KAAK,UAAU,CAAC,CACvD,CAAA;IACD,IAAI,oBAAoB,EAAE,CAAC;QACzB,QAAQ,CAAC,QAAQ,GAAG,UAAU,CAAA;QAC9B,QAAQ,CAAC,OAAO,GAAG,sIAAsI,QAAQ,CAAC,OAAO,EAAE,CAAA;QAC3K,OAAM;IACR,CAAC;IAED,wEAAwE;IACxE,2EAA2E;IAC3E,0EAA0E;IAC1E,uEAAuE;IACvE,2BAA2B;IAC3B,MAAM,aAAa,GAAG,IAAI,GAAG,CAC3B,QAAQ;SACL,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE;QACZ,MAAM,GAAG,GAAG,sBAAsB,CAAC,CAAC,CAAC,IAAI,CAAC,CAAA;QAC1C,MAAM,YAAY,GAAG,qCAAqC,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC;YACpE,CAAC,CAAC,CAAC,CAAC,UAAU,KAAK,KAAK;YACxB,CAAC,CAAC,CAAC,CAAC,UAAU,KAAK,MAAM,CAAA;QAC3B,OAAO,GAAG,KAAK,QAAQ,IAAI,aAAa,CAAC,CAAC,CAAC,QAAQ,CAAC,IAAI,aAAa,CAAC,GAAG,CAAC,IAAI,YAAY,CAAA;IAC5F,CAAC,CAAC;SACD,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CACtB,CAAA;IACD,IAAI,aAAa,CAAC,IAAI,IAAI,CAAC,EAAE,CAAC;QAC5B,QAAQ,CAAC,QAAQ,GAAG,UAAU,CAAA;QAC9B,QAAQ,CAAC,OAAO,GAAG,2FAA2F;YAC5G,GAAG,aAAa;SACjB;aACE,IAAI,EAAE;aACN,IAAI,CAAC,IAAI,CAAC,sCAAsC,QAAQ,CAAC,OAAO,EAAE,CAAA;IACvE,CAAC;AACH,CAAC"}

package/dist/src/security/scanner/SecurityScanner.fetch-correlation.d.ts

@@ -0,0 +1,115 @@
+/**
+ * Security Scanner — shared fetch-correlation utilities
+ * @module @skillsmith/core/security/scanner/SecurityScanner.fetch-correlation
+ *
+ * SMI-6033 Wave 2: extracted out of SecurityScanner.compound.ts so every
+ * provenance-conditioned detector (chmod, xattr/gatekeeper_bypass,
+ * archive_evasion, paste_host_fetch) correlates a target file against a fetch
+ * command's download destination using the SAME fetch-verb regex and the SAME
+ * distance-independent matching logic, instead of drifting copies. Pure
+ * functions of their arguments — no scanner instance state. Byte-identical
+ * structure is mirrored in the edge twin
+ * (security-scanner-edge.fetch-correlation.ts) — see that file's header for
+ * the parity-test pointer.
+ *
+ * SMI-6033 Wave 3 (adversarial-review fix): correlation is now
+ * DIRECTORY-PATH-AWARE. It previously matched on the final path segment
+ * (basename) alone, with zero directory awareness — so two entirely unrelated
+ * files that merely shared a filename registered as "correlated": a
+ * legitimate `curl -o /tmp/install.sh <url>` fetch alongside a separate,
+ * pre-existing `./vendor/other-tool/install.sh` that gets `chmod +x`'d
+ * elsewhere in the same skill. Because this utility IS the shared provenance
+ * gate behind the xattr / archive / paste-host "correlated ->
+ * standalone-critical" escalations, that false positive is a
+ * quarantine-level one, not a cosmetic one.
+ *
+ * The rule, in one sentence: when BOTH sides carry directory information the
+ * normalized directories must be EQUAL; when EITHER side is a bare filename
+ * (no directory information at all — `wget https://x/install.sh` writes into
+ * the CWD, `chmod +x install.sh` names no directory) fall back to
+ * final-segment matching, because there is then no path information to
+ * distinguish the two by. Normalization (`normalizeCorrelationPath`) strips
+ * quotes, collapses empty segments, drops `.` and resolves `..`, so
+ * `./vendor/tool/x` and `vendor/tool/x` are the same directory while `/tmp`
+ * and `vendor/tool` are not. An absolute path with no intermediate directory
+ * (`/install.sh`) normalizes to the real directory `/` — NOT to "no
+ * directory information" — so it does not silently fall back.
+ */
+/**
+ * Matches an actual fetch COMMAND (curl/wget/git-clone, or npx immediately
+ * followed by a URL) — not bare prose tokens (`# downloaded`, `See
+ * https://…`, `npx tool init`) which false-fire when used as a correlation
+ * gate on their own. Generic name (not chmod-specific, formerly
+ * `CHMOD_FETCH_CONTEXT`): every provenance-conditioned detector that needs to
+ * know whether a line issues a fetch reuses this single pattern.
+ */
+export declare const FETCH_COMMAND_PATTERN: RegExp;
+/**
+ * Escape a string for safe interpolation into a `new RegExp(...)` pattern.
+ */
+export declare function escapeRegExp(s: string): string;
+/**
+ * A path split into its normalized directory component and its final segment.
+ * `dir` is the empty string ONLY when the raw path carried no directory
+ * information at all (a bare filename, or a `./`-prefixed one, which names
+ * the same CWD-relative location) — that empty string is what triggers the
+ * basename-only fallback in `isCorrelatedWithFetchDestination`.
+ */
+export interface NormalizedCorrelationPath {
+    dir: string;
+    base: string;
+}
+/**
+ * Normalize a raw path captured out of a shell command into
+ * `{ dir, base }`: strip quotes, drop empty (`//`) and `.` segments, resolve
+ * `..` lexically, and preserve absolute-vs-relative as a real distinction
+ * (`/tmp/x` and `tmp/x` are different locations, so they must not correlate).
+ * Lexical only — the scanner never touches the filesystem, so there is no
+ * symlink/realpath resolution to do and none is implied.
+ */
+export declare function normalizeCorrelationPath(raw: string): NormalizedCorrelationPath;
+/**
+ * The normalized final segment of `rawPath`. Callers use this for their own
+ * minimum-length gate (every current caller requires >= 3 chars) before
+ * handing the FULL path to `isCorrelatedWithFetchDestination` — the length
+ * policy stays a caller decision, exactly as it was before this file became
+ * path-aware.
+ */
+export declare function correlationTargetBasename(rawPath: string): string;
+/**
+ * SMI-5431: the IMPLICIT download destination of a fetch command — the file
+ * written with NO explicit -o/-O/--output<space>/> redirect: `wget <url>` (no
+ * -O/-o) → URL last segment; `git clone <url>` → repo dir (minus `.git`);
+ * `curl --output=<file>` (equals form, missed by the explicit regex). A bare
+ * `curl <url>` GET writes to STDOUT → '' (never correlates). ReDoS-safe.
+ *
+ * SMI-6033 Wave 3: returns the destination PATH, not a bare basename — the
+ * `curl --output=/tmp/p` form carries a real directory the correlation check
+ * now compares against. The wget / git-clone forms genuinely have no
+ * directory component (both write into the CWD), so they still yield a bare
+ * final segment; that is a property of those commands, not discarded
+ * information.
+ */
+export declare function implicitDownloadDestination(line: string): string;
+/**
+ * Distance-independent correlation: is `targetPath` (the raw path captured
+ * from the caller's own command — quotes and directory prefix INCLUDED; this
+ * function normalizes) the DOWNLOAD DESTINATION of any fetch command line,
+ * anywhere in the document (not just physically adjacent)? Covers explicit
+ * destinations (-o/-O/--output<space>/>, with an optional leading path) via
+ * regex, and implicit destinations (wget/git-clone/curl --output=) via
+ * `implicitDownloadDestination`. Anchored on the destination, NOT
+ * basename-anywhere, so a URL path/query/header value (a known FP class) and
+ * a bare `curl <url>` GET (writes to stdout) never correlate.
+ *
+ * Final segments must always match; directories must additionally match
+ * whenever BOTH sides carry one (see this file's header for the full rule and
+ * the FP class it closes).
+ *
+ * Callers gate the minimum basename length themselves before calling (every
+ * current caller requires >= 3 chars, via `correlationTargetBasename`) — this
+ * function imposes no minimum, so a future caller's own length policy stays a
+ * caller decision.
+ */
+export declare function isCorrelatedWithFetchDestination(targetPath: string, fetchLines: readonly string[]): boolean;
+//# sourceMappingURL=SecurityScanner.fetch-correlation.d.ts.map

package/dist/src/security/scanner/SecurityScanner.fetch-correlation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SecurityScanner.fetch-correlation.d.ts","sourceRoot":"","sources":["../../../../src/security/scanner/SecurityScanner.fetch-correlation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AAEH;;;;;;;GAOG;AACH,eAAO,MAAM,qBAAqB,QACkC,CAAA;AAEpE;;GAEG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAE9C;AAED;;;;;;GAMG;AACH,MAAM,WAAW,yBAAyB;IACxC,GAAG,EAAE,MAAM,CAAA;IACX,IAAI,EAAE,MAAM,CAAA;CACb;AAED;;;;;;;GAOG;AACH,wBAAgB,wBAAwB,CAAC,GAAG,EAAE,MAAM,GAAG,yBAAyB,CAgB/E;AAED;;;;;;GAMG;AACH,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAEjE;AAeD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAehE;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,gCAAgC,CAC9C,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,SAAS,MAAM,EAAE,GAC5B,OAAO,CAoBT"}