codegate-ai 0.8.0 → 0.9.1

package/README.md

@@ -120,21 +120,26 @@ See the [Configuration](#configuration) section for full settings and examples.
 
 ## `scan` Command Flags
 
-| Flag                   | Purpose                                                                                                   |
-| ---------------------- | --------------------------------------------------------------------------------------------------------- |
-| `--deep`               | Enable Layer 3 dynamic analysis.                                                                          |
-| `--remediate`          | Enter remediation mode after scan.                                                                        |
-| `--fix-safe`           | Auto-fix unambiguous critical findings.                                                                   |
-| `--dry-run`            | Show proposed fixes but write nothing.                                                                    |
-| `--patch`              | Generate a patch file for review workflows.                                                               |
-| `--no-tui`             | Disable TUI and interactive prompts.                                                                      |
-| `--format <type>`      | Output format: `terminal`, `json`, `sarif`, `markdown`, `html`.                                           |
-| `--output <path>`      | Write report to file instead of stdout.                                                                   |
-| `--verbose`            | Show extended output in terminal format.                                                                  |
-| `--config <path>`      | Use a specific global config file path.                                                                   |
-| `--force`              | Skip interactive confirmations.                                                                           |
-| `--include-user-scope` | Force-enable user/home AI tool config paths for this run (useful if config disables user-scope scanning). |
-| `--reset-state`        | Clear persisted scan-state history and exit.                                                              |
+| Flag                    | Purpose                                                                                                   |
+| ----------------------- | --------------------------------------------------------------------------------------------------------- |
+| `--deep`                | Enable Layer 3 dynamic analysis.                                                                          |
+| `--remediate`           | Enter remediation mode after scan.                                                                        |
+| `--fix-safe`            | Auto-fix unambiguous critical findings.                                                                   |
+| `--dry-run`             | Show proposed fixes but write nothing.                                                                    |
+| `--patch`               | Generate a patch file for review workflows.                                                               |
+| `--no-tui`              | Disable TUI and interactive prompts.                                                                      |
+| `--format <type>`       | Output format: `terminal`, `json`, `sarif`, `markdown`, `html`.                                           |
+| `--output <path>`       | Write report to file instead of stdout.                                                                   |
+| `--verbose`             | Show extended output in terminal format.                                                                  |
+| `--config <path>`       | Use a specific global config file path.                                                                   |
+| `--force`               | Skip interactive confirmations.                                                                           |
+| `--include-user-scope`  | Force-enable user/home AI tool config paths for this run (useful if config disables user-scope scanning). |
+| `--collect <mode>`      | Collection scope mode (`default`, `project`, `user`, `explicit`, `all`). Repeatable.                      |
+| `--strict-collection`   | Treat parse failures in collected inputs as high-severity findings.                                       |
+| `--persona <type>`      | Audit sensitivity (`regular`, `pedantic`, `auditor`).                                                     |
+| `--runtime-mode <mode>` | Runtime mode for optional online audits (`offline`, `online`, `online-no-audits`).                        |
+| `--workflow-audits`     | Enable CI/CD audit pack for GitHub workflow, action, and Dependabot inputs.                               |
+| `--reset-state`         | Clear persisted scan-state history and exit.                                                              |
 
 Examples:
 
@@ -148,9 +153,37 @@ codegate scan . --deep --force
 codegate scan . --remediate
 codegate scan . --fix-safe
 codegate scan . --remediate --dry-run --patch
+codegate scan . --workflow-audits --collect project --persona auditor --runtime-mode online
+codegate scan . --workflow-audits --strict-collection
 codegate scan . --reset-state
 ```
 
+## Workflow Audit Pack
+
+CodeGate can audit GitHub Actions workflows when `--workflow-audits` is enabled.
+
+Current checks include:
+
+- Unpinned external action references (`uses: owner/repo@tag` instead of commit SHA)
+- High-risk triggers (`pull_request_target`, `workflow_run`)
+- Overly broad permissions (`write-all` and explicit write grants)
+- Template expression injection patterns in run steps and known sink inputs
+- Known vulnerable action references (online runtime mode)
+- Dependabot cooldown and execution-risk checks
+- Workflow hygiene checks (concurrency gates, obfuscation, unsafe conditional trust)
+
+Track the current workflow-audit coverage and backlog in the [workflow audit parity checklist](docs/workflow-audit-parity-checklist.md).
+Real public validation fixtures and source provenance are documented in [workflow audit real-case corpus](docs/workflow-audit-real-cases.md).
+
+Examples:
+
+```bash
+codegate scan . --workflow-audits
+codegate scan . --workflow-audits --collect project --persona auditor
+codegate scan . --workflow-audits --runtime-mode online
+codegate scan . --workflow-audits --collect-kind dependabot
+```
+
 ## `scan-content` Command
 
 `codegate scan-content <content...>` scans inline content directly from the command line. It is useful when you want to inspect JSON, YAML, TOML, Markdown, or plain text before writing it to disk or installing it into a tool configuration.

package/dist/cli.js

@@ -6,7 +6,7 @@ import { dirname, resolve } from "node:path";
 import { createInterface } from "node:readline/promises";
 import { pathToFileURL } from "node:url";
 import { Command, Option } from "commander";
-import { DEFAULT_CONFIG, OUTPUT_FORMATS, resolveEffectiveConfig, } from "./config.js";
+import { DEFAULT_CONFIG, OUTPUT_FORMATS, PERSONAS, RUNTIME_MODES, SCAN_COLLECTION_MODES, SCAN_COLLECTION_KINDS, resolveEffectiveConfig, } from "./config.js";
 import { APP_NAME } from "./index.js";
 import { runSandboxCommand } from "./layer3-dynamic/sandbox.js";
 import { loadKnowledgeBase } from "./layer1-discovery/knowledge-base.js";
@@ -127,6 +127,8 @@ const defaultCliDeps = {
     }),
     prepareScanDiscovery: (scanTarget, config, options) => createScanDiscoveryContext(scanTarget, undefined, {
         includeUserScope: config?.scan_user_scope === true,
+        collectModes: config?.scan_collection_modes,
+        collectKinds: config?.scan_collection_kinds,
         parseSelected: true,
         explicitCandidates: options?.explicitCandidates,
     }),
@@ -158,6 +160,8 @@ const defaultCliDeps = {
         ? discoverDeepScanResourcesFromContext(discoveryContext)
         : discoverDeepScanResources(scanTarget, undefined, {
             includeUserScope: config?.scan_user_scope === true,
+            collectModes: config?.scan_collection_modes,
+            collectKinds: config?.scan_collection_kinds,
         }),
     discoverLocalTextTargets: (_scanTarget, _config, discoveryContext) => discoveryContext ? discoverLocalTextAnalysisTargetsFromContext(discoveryContext) : [],
     // Deep resource execution never makes outbound network calls.
@@ -198,6 +202,20 @@ function addScanCommand(program, version, deps) {
         .option("--config <path>", "use a specific global config file")
         .option("--force", "skip interactive confirmations")
         .option("--include-user-scope", "include user/home AI tool config paths in scan")
+        .addOption(new Option("--collect <mode>", "collection mode (repeatable): default, project, user, explicit, all")
+        .choices([...SCAN_COLLECTION_MODES])
+        .argParser((value, previous = []) => [...previous, value]))
+        .addOption(new Option("--collect-kind <kind>", "collection kind (repeatable): workflows, actions, dependabot")
+        .choices([...SCAN_COLLECTION_KINDS])
+        .argParser((value, previous = []) => [...previous, value]))
+        .option("--strict-collection", "treat parse failures in collected inputs as high severity")
+        .addOption(new Option("--persona <type>", "audit sensitivity persona")
+        .choices([...PERSONAS])
+        .argParser((value) => value))
+        .addOption(new Option("--runtime-mode <mode>", "runtime network mode for optional online audits")
+        .choices([...RUNTIME_MODES])
+        .argParser((value) => value))
+        .option("--workflow-audits", "enable workflow security audit pack for .github/workflows")
         .option("--skill <name>", "select one skill directory when scanning a skills index repo URL")
         .option("--reset-state", "clear persisted scan-state history and exit")
         .addHelpText("after", renderExampleHelp([
@@ -205,6 +223,7 @@ function addScanCommand(program, version, deps) {
         "codegate scan ./skills/security-review/SKILL.md",
         "codegate scan https://github.com/owner/repo",
         "codegate scan https://github.com/owner/repo --skill security-review",
+        "codegate scan . --workflow-audits --collect project --persona auditor --runtime-mode online",
         "codegate scan https://github.com/owner/repo/blob/main/skills/security-review/SKILL.md",
         "codegate scan https://example.com/security-review/SKILL.md --format json",
     ]))
@@ -220,6 +239,7 @@ function addScanCommand(program, version, deps) {
         };
         let resolvedTarget;
         try {
+            const scanOptions = options;
             const resolveTarget = deps.resolveScanTarget ??
                 ((input) => resolveScanTarget(input));
             resolvedTarget = await resolveTarget({
@@ -237,12 +257,26 @@ function addScanCommand(program, version, deps) {
                 scanTarget,
                 cli: cliConfig,
             });
-            const config = options.includeUserScope === true
-                ? {
-                    ...baseConfig,
-                    scan_user_scope: true,
-                }
-                : baseConfig;
+            const config = {
+                ...baseConfig,
+                scan_collection_modes: options.collect && options.collect.length > 0
+                    ? options.collect
+                    : baseConfig.scan_collection_modes,
+                scan_collection_kinds: (scanOptions.collectKind && scanOptions.collectKind.length > 0
+                    ? scanOptions.collectKind
+                    : baseConfig.scan_collection_kinds),
+                strict_collection: options.strictCollection === true
+                    ? true
+                    : (baseConfig.strict_collection ?? DEFAULT_CONFIG.strict_collection),
+                persona: options.persona ?? baseConfig.persona,
+                runtime_mode: options.runtimeMode ?? baseConfig.runtime_mode,
+                workflow_audits: {
+                    enabled: options.workflowAudits === true
+                        ? true
+                        : (baseConfig.workflow_audits?.enabled ?? false),
+                },
+                scan_user_scope: options.includeUserScope === true ? true : (baseConfig.scan_user_scope ?? false),
+            };
             if (options.resetState) {
                 const reset = deps.resetScanState ?? ((path) => resetScanState(path));
                 await reset(config.scan_state_path);

package/dist/commands/scan-command.d.ts

@@ -1,4 +1,4 @@
-import { type CodeGateConfig, type OutputFormat } from "../config.js";
+import { type AuditPersona, type CodeGateConfig, type OutputFormat, type RuntimeMode, type ScanCollectionMode } from "../config.js";
 import { type MetaAgentCommand, type MetaAgentTool } from "../layer3-dynamic/command-builder.js";
 import type { LocalTextAnalysisTarget } from "../layer3-dynamic/local-text-analysis.js";
 import type { ResourceFetchResult } from "../layer3-dynamic/resource-fetcher.js";
@@ -21,6 +21,11 @@ export interface ScanCommandOptions {
     resetState?: boolean;
     includeUserScope?: boolean;
     skill?: string;
+    collect?: ScanCollectionMode[];
+    strictCollection?: boolean;
+    persona?: AuditPersona;
+    runtimeMode?: RuntimeMode;
+    workflowAudits?: boolean;
 }
 export interface ScanRunnerInput {
     version: string;

package/dist/commands/scan-command.js

@@ -1,5 +1,5 @@
 import { resolve } from "node:path";
-import { applyConfigPolicy } from "../config.js";
+import { applyConfigPolicy, } from "../config.js";
 import { buildMetaAgentCommand, } from "../layer3-dynamic/command-builder.js";
 import { supportsAgentLocalTextAnalysis } from "../layer3-dynamic/local-text-analysis.js";
 import { buildLocalTextAnalysisPrompt, buildSecurityAnalysisPrompt, } from "../layer3-dynamic/meta-agent.js";

package/dist/commands/scan-content-command.js

@@ -20,7 +20,7 @@ export async function executeScanContentCommand(input, deps) {
             throw new Error(parsed.error);
         }
         const kbVersion = loadKnowledgeBase().schemaVersion;
-        const report = applyConfigPolicy(runStaticPipeline({
+        const report = applyConfigPolicy(await runStaticPipeline({
             version: input.version,
             kbVersion,
             scanTarget: `scan-content:${input.type}`,
@@ -48,6 +48,10 @@ export async function executeScanContentCommand(input, deps) {
                 rulePackPaths: input.config.rule_pack_paths,
                 allowedRules: input.config.allowed_rules,
                 skipRules: input.config.skip_rules,
+                persona: input.config.persona,
+                runtimeMode: input.config.runtime_mode,
+                workflowAuditsEnabled: input.config.workflow_audits?.enabled === true,
+                rulePolicies: input.config.rules,
             },
         }), input.config);
         deps.stdout(renderByFormat(input.config.output_format, report));

package/dist/config/inline-ignore.d.ts

@@ -0,0 +1,11 @@
+import type { Finding } from "../types/finding.js";
+export interface InlineIgnoreDirectiveSet {
+    rules: Set<string>;
+    ruleLines: Map<string, Set<number>>;
+}
+export type InlineIgnoreMap = Map<string, InlineIgnoreDirectiveSet>;
+export declare function collectInlineIgnoreDirectives(files: Array<{
+    filePath: string;
+    textContent: string;
+}>): InlineIgnoreMap;
+export declare function applyInlineIgnoreDirectives<T extends Finding>(findings: T[], directives: InlineIgnoreMap): T[];

package/dist/config/inline-ignore.js

@@ -0,0 +1,57 @@
+function normalizeRuleId(value) {
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : null;
+}
+function addDirective(target, ruleId, line) {
+    target.rules.add(ruleId);
+    const lines = target.ruleLines.get(ruleId) ?? new Set();
+    lines.add(line);
+    target.ruleLines.set(ruleId, lines);
+}
+function parseDirectiveRules(raw) {
+    return raw
+        .split(",")
+        .map((entry) => normalizeRuleId(entry))
+        .filter((entry) => entry !== null);
+}
+export function collectInlineIgnoreDirectives(files) {
+    const directives = new Map();
+    const pattern = /codegate:\s*ignore\[([^\]]+)\]/giu;
+    for (const file of files) {
+        const lines = file.textContent.split(/\r?\n/u);
+        let directiveSet = directives.get(file.filePath);
+        for (let index = 0; index < lines.length; index += 1) {
+            const line = lines[index] ?? "";
+            pattern.lastIndex = 0;
+            for (const match of line.matchAll(pattern)) {
+                const ruleIds = parseDirectiveRules(match[1] ?? "");
+                if (ruleIds.length === 0) {
+                    continue;
+                }
+                if (!directiveSet) {
+                    directiveSet = {
+                        rules: new Set(),
+                        ruleLines: new Map(),
+                    };
+                    directives.set(file.filePath, directiveSet);
+                }
+                for (const ruleId of ruleIds) {
+                    addDirective(directiveSet, ruleId, index + 1);
+                }
+            }
+        }
+    }
+    return directives;
+}
+export function applyInlineIgnoreDirectives(findings, directives) {
+    return findings.map((finding) => {
+        const set = directives.get(finding.file_path);
+        if (!set || !set.rules.has(finding.rule_id)) {
+            return finding;
+        }
+        return {
+            ...finding,
+            suppressed: true,
+        };
+    });
+}

package/dist/config/suppression-policy.d.ts

@@ -2,13 +2,21 @@ import type { Finding } from "../types/finding.js";
 export interface SuppressionRule {
     rule_id?: string;
     file_path?: string;
+    location?: string;
     severity?: Finding["severity"];
     category?: Finding["category"];
     cwe?: string;
     fingerprint?: string;
 }
+export interface RulePolicyConfig {
+    disable?: boolean;
+    ignore?: readonly string[];
+    config?: Record<string, unknown>;
+}
+export type RulePolicyMap = Record<string, RulePolicyConfig>;
 export interface SuppressionPolicy {
     suppress_findings?: readonly string[];
     suppression_rules?: readonly SuppressionRule[];
+    rule_policies?: RulePolicyMap;
 }
 export declare function applySuppressionPolicy<T extends Finding>(findings: T[], policy: SuppressionPolicy): T[];

package/dist/config/suppression-policy.js

@@ -38,6 +38,33 @@ function globToRegExp(glob) {
 function matchesGlob(value, glob) {
     return globToRegExp(glob).test(value.replaceAll("\\", "/"));
 }
+function parseSuppressionLocation(value) {
+    const trimmed = normalizeString(value);
+    if (!trimmed) {
+        return null;
+    }
+    const pieces = trimmed.split(":");
+    if (pieces.length === 0 || pieces.length > 3) {
+        return null;
+    }
+    const [filePath, lineRaw, columnRaw] = pieces;
+    if (!filePath) {
+        return null;
+    }
+    const line = lineRaw !== undefined ? Number.parseInt(lineRaw, 10) : undefined;
+    const column = columnRaw !== undefined ? Number.parseInt(columnRaw, 10) : undefined;
+    if (lineRaw !== undefined && (!Number.isFinite(line) || (line ?? 0) < 1)) {
+        return null;
+    }
+    if (columnRaw !== undefined && (!Number.isFinite(column) || (column ?? 0) < 1)) {
+        return null;
+    }
+    return {
+        filePath: filePath.replaceAll("\\", "/"),
+        line,
+        column,
+    };
+}
 function matchesSuppressionRule(finding, rule) {
     const ruleId = normalizeString(rule.rule_id);
     if (ruleId && finding.rule_id !== ruleId) {
@@ -47,6 +74,21 @@ function matchesSuppressionRule(finding, rule) {
     if (filePath && !matchesGlob(finding.file_path, filePath)) {
         return false;
     }
+    const location = parseSuppressionLocation(rule.location ?? "");
+    if (location) {
+        const normalizedFindingPath = finding.file_path.replaceAll("\\", "/");
+        if (normalizedFindingPath !== location.filePath) {
+            return false;
+        }
+        if (typeof location.line === "number" &&
+            (typeof finding.location.line !== "number" || finding.location.line !== location.line)) {
+            return false;
+        }
+        if (typeof location.column === "number" &&
+            (typeof finding.location.column !== "number" || finding.location.column !== location.column)) {
+            return false;
+        }
+    }
     const severity = rule.severity;
     if (severity && finding.severity !== severity) {
         return false;
@@ -65,17 +107,40 @@ function matchesSuppressionRule(finding, rule) {
     }
     return true;
 }
+function matchesRulePolicyIgnore(finding, location) {
+    const parsed = parseSuppressionLocation(location);
+    if (!parsed) {
+        return false;
+    }
+    const normalizedFindingPath = finding.file_path.replaceAll("\\", "/");
+    if (normalizedFindingPath !== parsed.filePath) {
+        return false;
+    }
+    if (typeof parsed.line === "number" &&
+        (typeof finding.location.line !== "number" || finding.location.line !== parsed.line)) {
+        return false;
+    }
+    if (typeof parsed.column === "number" &&
+        (typeof finding.location.column !== "number" || finding.location.column !== parsed.column)) {
+        return false;
+    }
+    return true;
+}
 export function applySuppressionPolicy(findings, policy) {
     const legacySuppressions = new Set((policy.suppress_findings ?? [])
         .map((findingId) => normalizeString(findingId))
         .filter((findingId) => findingId !== undefined));
     const rules = policy.suppression_rules ?? [];
+    const rulePolicies = policy.rule_policies ?? {};
     return findings.map((finding) => {
         const ruleMatch = rules.some((rule) => matchesSuppressionRule(finding, rule));
         const legacyMatch = legacySuppressions.has(finding.finding_id);
+        const rulePolicy = rulePolicies[finding.rule_id];
+        const ruleDisabled = rulePolicy?.disable === true;
+        const ruleIgnoreMatch = rulePolicy?.ignore?.some((location) => matchesRulePolicyIgnore(finding, location)) ?? false;
         return {
             ...finding,
-            suppressed: finding.suppressed || legacyMatch || ruleMatch,
+            suppressed: finding.suppressed || legacyMatch || ruleMatch || ruleDisabled || ruleIgnoreMatch,
         };
     });
 }

package/dist/config.d.ts

@@ -1,8 +1,16 @@
 import type { Finding } from "./types/finding.js";
 import type { CodeGateReport } from "./types/report.js";
-import { type SuppressionRule } from "./config/suppression-policy.js";
+import { type RulePolicyMap, type SuppressionRule } from "./config/suppression-policy.js";
 export declare const OUTPUT_FORMATS: readonly ["terminal", "json", "sarif", "markdown", "html"];
 export type OutputFormat = (typeof OUTPUT_FORMATS)[number];
+export declare const SCAN_COLLECTION_MODES: readonly ["default", "project", "user", "explicit", "all"];
+export type ScanCollectionMode = (typeof SCAN_COLLECTION_MODES)[number];
+export declare const SCAN_COLLECTION_KINDS: readonly ["workflows", "actions", "dependabot"];
+export type ScanCollectionKind = (typeof SCAN_COLLECTION_KINDS)[number];
+export declare const PERSONAS: readonly ["regular", "pedantic", "auditor"];
+export type AuditPersona = (typeof PERSONAS)[number];
+export declare const RUNTIME_MODES: readonly ["offline", "online", "online-no-audits"];
+export type RuntimeMode = (typeof RUNTIME_MODES)[number];
 export declare const SEVERITY_THRESHOLDS: readonly ["critical", "high", "medium", "low", "info"];
 export type SeverityThreshold = (typeof SEVERITY_THRESHOLDS)[number];
 export interface TuiConfig {
@@ -15,6 +23,9 @@ export interface ToolDiscoveryConfig {
     agent_paths: Record<string, string>;
     skip_tools: string[];
 }
+export interface WorkflowAuditConfig {
+    enabled: boolean;
+}
 export interface CodeGateConfig {
     severity_threshold: SeverityThreshold;
     auto_proceed_below_threshold: boolean;
@@ -36,6 +47,13 @@ export interface CodeGateConfig {
     rule_pack_paths?: string[];
     allowed_rules?: string[];
     skip_rules?: string[];
+    strict_collection?: boolean;
+    scan_collection_modes?: ScanCollectionMode[];
+    scan_collection_kinds?: ScanCollectionKind[];
+    rules?: RulePolicyMap;
+    persona?: AuditPersona;
+    runtime_mode?: RuntimeMode;
+    workflow_audits?: WorkflowAuditConfig;
     suppress_findings: string[];
     suppression_rules?: SuppressionRule[];
 }

package/dist/config.js

@@ -3,8 +3,12 @@ import { homedir } from "node:os";
 import { join, resolve } from "node:path";
 import { parse as parseJsonc } from "jsonc-parser";
 import { applyReportSummary, computeExitCode as computeReportExitCode } from "./report-summary.js";
-import { applySuppressionPolicy } from "./config/suppression-policy.js";
+import { applySuppressionPolicy, } from "./config/suppression-policy.js";
 export const OUTPUT_FORMATS = ["terminal", "json", "sarif", "markdown", "html"];
+export const SCAN_COLLECTION_MODES = ["default", "project", "user", "explicit", "all"];
+export const SCAN_COLLECTION_KINDS = ["workflows", "actions", "dependabot"];
+export const PERSONAS = ["regular", "pedantic", "auditor"];
+export const RUNTIME_MODES = ["offline", "online", "online-no-audits"];
 export const SEVERITY_THRESHOLDS = ["critical", "high", "medium", "low", "info"];
 export const DEFAULT_CONFIG = {
     severity_threshold: "high",
@@ -38,6 +42,11 @@ export const DEFAULT_CONFIG = {
     rule_pack_paths: [],
     allowed_rules: [],
     skip_rules: [],
+    strict_collection: false,
+    scan_collection_modes: ["default"],
+    persona: "regular",
+    runtime_mode: "offline",
+    workflow_audits: { enabled: false },
     suppress_findings: [],
     suppression_rules: [],
 };
@@ -60,6 +69,146 @@ function normalizeOptionalPath(value) {
     const trimmed = value.trim();
     return trimmed.length > 0 ? trimmed : undefined;
 }
+function normalizeCollectionMode(value) {
+    if (!value) {
+        return undefined;
+    }
+    return SCAN_COLLECTION_MODES.find((mode) => mode === value) ?? undefined;
+}
+function normalizeCollectionModes(values) {
+    if (!values) {
+        return undefined;
+    }
+    const normalized = [];
+    for (const value of values) {
+        const mode = normalizeCollectionMode(value);
+        if (!mode || normalized.includes(mode)) {
+            continue;
+        }
+        normalized.push(mode);
+    }
+    return normalized.length > 0 ? normalized : undefined;
+}
+function normalizeCollectionKind(value) {
+    if (!value) {
+        return undefined;
+    }
+    return SCAN_COLLECTION_KINDS.find((kind) => kind === value) ?? undefined;
+}
+function normalizeCollectionKinds(values) {
+    if (!values) {
+        return undefined;
+    }
+    const normalized = [];
+    for (const value of values) {
+        const kind = normalizeCollectionKind(value);
+        if (!kind || normalized.includes(kind)) {
+            continue;
+        }
+        normalized.push(kind);
+    }
+    return normalized.length > 0 ? normalized : undefined;
+}
+function isPlainObject(value) {
+    return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function normalizeRulePolicyConfig(value) {
+    if (!isPlainObject(value)) {
+        return undefined;
+    }
+    const disable = typeof value.disable === "boolean" ? value.disable : undefined;
+    const ignoreRaw = value.ignore;
+    const ignore = Array.isArray(ignoreRaw) && ignoreRaw.length > 0
+        ? ignoreRaw
+            .filter((entry) => typeof entry === "string")
+            .map((entry) => entry.trim())
+            .filter((entry) => entry.length > 0)
+        : undefined;
+    const configRaw = value.config;
+    const config = isPlainObject(configRaw) ? { ...configRaw } : undefined;
+    if (disable === undefined && ignore === undefined && config === undefined) {
+        return undefined;
+    }
+    return {
+        disable,
+        ignore,
+        config,
+    };
+}
+function normalizeRulePolicyMap(rules) {
+    if (!rules || typeof rules !== "object") {
+        return undefined;
+    }
+    const normalized = {};
+    for (const [ruleId, value] of Object.entries(rules)) {
+        const key = ruleId.trim();
+        if (key.length === 0) {
+            continue;
+        }
+        const policy = normalizeRulePolicyConfig(value);
+        if (!policy) {
+            continue;
+        }
+        normalized[key] = policy;
+    }
+    return Object.keys(normalized).length > 0 ? normalized : undefined;
+}
+function mergeRulePolicyConfig(current, incoming) {
+    if (!current) {
+        if (!incoming) {
+            return undefined;
+        }
+        return {
+            disable: incoming.disable,
+            ignore: incoming.ignore ? [...incoming.ignore] : undefined,
+            config: incoming.config ? { ...incoming.config } : undefined,
+        };
+    }
+    if (!incoming) {
+        return {
+            disable: current.disable,
+            ignore: current.ignore ? [...current.ignore] : undefined,
+            config: current.config ? { ...current.config } : undefined,
+        };
+    }
+    return {
+        disable: incoming.disable ?? current.disable,
+        ignore: unique([
+            current.ignore,
+            incoming.ignore,
+        ]),
+        config: current.config || incoming.config
+            ? {
+                ...(current.config ?? {}),
+                ...(incoming.config ?? {}),
+            }
+            : undefined,
+    };
+}
+function mergeRulePolicyMaps(...maps) {
+    const merged = {};
+    for (const map of maps) {
+        if (!map) {
+            continue;
+        }
+        for (const [ruleId, policy] of Object.entries(map)) {
+            merged[ruleId] = mergeRulePolicyConfig(merged[ruleId], policy) ?? merged[ruleId];
+        }
+    }
+    return Object.keys(merged).length > 0 ? merged : undefined;
+}
+function normalizePersona(value) {
+    if (!value) {
+        return undefined;
+    }
+    return PERSONAS.find((persona) => persona === value) ?? undefined;
+}
+function normalizeRuntimeMode(value) {
+    if (!value) {
+        return undefined;
+    }
+    return RUNTIME_MODES.find((mode) => mode === value) ?? undefined;
+}
 function unique(values) {
     const merged = values.flatMap((entry) => entry ?? []);
     const seen = new Set();
@@ -183,6 +332,15 @@ export function resolveEffectiveConfig(options) {
             globalConfig.skip_rules,
             projectConfig.skip_rules,
         ]),
+        strict_collection: pickFirst(projectConfig.strict_collection, globalConfig.strict_collection, DEFAULT_CONFIG.strict_collection) ?? DEFAULT_CONFIG.strict_collection,
+        scan_collection_modes: pickFirst(normalizeCollectionModes(projectConfig.scan_collection_modes), normalizeCollectionModes(globalConfig.scan_collection_modes), DEFAULT_CONFIG.scan_collection_modes) ?? DEFAULT_CONFIG.scan_collection_modes,
+        scan_collection_kinds: pickFirst(normalizeCollectionKinds(projectConfig.scan_collection_kinds), normalizeCollectionKinds(globalConfig.scan_collection_kinds)) ?? undefined,
+        rules: mergeRulePolicyMaps(normalizeRulePolicyMap(globalConfig.rules), normalizeRulePolicyMap(projectConfig.rules)) ?? undefined,
+        persona: pickFirst(normalizePersona(projectConfig.persona), normalizePersona(globalConfig.persona), DEFAULT_CONFIG.persona) ?? DEFAULT_CONFIG.persona,
+        runtime_mode: pickFirst(normalizeRuntimeMode(projectConfig.runtime_mode), normalizeRuntimeMode(globalConfig.runtime_mode), DEFAULT_CONFIG.runtime_mode) ?? DEFAULT_CONFIG.runtime_mode,
+        workflow_audits: {
+            enabled: pickFirst(projectConfig.workflow_audits?.enabled, globalConfig.workflow_audits?.enabled, DEFAULT_CONFIG.workflow_audits?.enabled) ?? false,
+        },
         suppress_findings: unique([
             DEFAULT_CONFIG.suppress_findings,
             globalConfig.suppress_findings,
@@ -202,6 +360,7 @@ export function applyConfigPolicy(report, config) {
     const findings = applySuppressionPolicy(report.findings, {
         suppress_findings: config.suppress_findings,
         suppression_rules: config.suppression_rules,
+        rule_policies: config.rules,
     }).map((finding) => ({
         ...finding,
         owasp: config.owasp_mapping ? finding.owasp : [],

package/dist/layer2-static/action/parser.d.ts

@@ -0,0 +1,3 @@
+import type { ActionFacts } from "./types.js";
+export declare function isGitHubActionPath(path: string): boolean;
+export declare function extractActionFacts(parsed: unknown): ActionFacts | null;