@shiftleftpt/sbd-toe-mcp 0.20.0-beta.5 → 0.20.0-beta.6

package/dist/tools/prepare-codegen-context.d.ts

@@ -80,7 +80,7 @@ export interface PrepareCodegenContextInput {
 export type PrepareCodegenStatus = "ready_for_codegen" | "needs_clarification" | "needs_decomposition" | "unsupported_scope";
 export interface ActivationTraceEntry {
     /** Triggered by: explicit concern, task term, changed file, framework hint, semantic alias, compound term, or intent keyword. */
-    source: "explicit_concern" | "task_term" | "compound_term" | "alias_expansion" | "intent_keyword" | "changed_file" | "regulatory_framework" | "risk_level" | "scope_gate";
+    source: "explicit_concern" | "task_term" | "compound_term" | "alias_expansion" | "intent_keyword" | "changed_file" | "regulatory_framework" | "risk_level" | "exposure" | "data_sensitivity" | "context_chapter" | "scope_gate";
     /** What the activation produced (concern, slice_family, framework_id, decision). */
     produced: string;
     /** The literal token or input that triggered the activation. */
@@ -237,6 +237,22 @@ export interface CompletenessReport {
     evidence_patterns_capped: number;
     /** Cap value applied during this resolution. */
     evidence_pattern_cap: number;
+    /**
+     * MP1 selection summary (G-mp1a O2, 2026-08-31): the requirement set comes from
+     * the selection engine (baseline ∪ context-activated chapters, narrowed by the
+     * task's declared signals). Never-silent: what the narrowing excluded is counted
+     * here and fully listed by the executable ref. Additive key.
+     */
+    selection?: {
+        eligible: number;
+        selected: number;
+        narrowed_out_categories: number;
+        narrowed_out_requirements: number;
+        narrowed_out_ref: {
+            tool: "select_sbd_toe_requirements";
+            note: string;
+        };
+    };
 }
 export interface SecurityRationaleTemplate {
     task: string;
@@ -744,6 +760,44 @@ export interface PrepareCodegenContextResultReadyDieted {
 export type PrepareCodegenContextResult = PrepareCodegenContextResultReady | PrepareCodegenContextResultReadyDieted | PrepareCodegenContextResultBlocked;
 declare const VALID_CONCERNS: readonly ["auth", "logging", "validation", "api", "config", "integrity", "distribution", "ide", "requirements", "architecture", "iac", "encryption", "secrets", "build", "supply_chain", "testing", "threat_modeling", "monitoring", "release", "deployment", "integration", "agents"];
 export type Concern = (typeof VALID_CONCERNS)[number];
+export interface NormalizedInput {
+    task: string;
+    taskTrimmed: string;
+    taskLower: string;
+    tokenCount: number;
+    mode: CodegenMode;
+    risk_level?: RiskLevel;
+    stack?: string;
+    exposure?: PrepareCodegenContextInput["exposure"];
+    data_sensitivity?: PrepareCodegenContextInput["data_sensitivity"];
+    concerns: Concern[];
+    unknownConcerns: string[];
+    changed_files: string[];
+    regulatory_frameworks: string[];
+    include_regulatory_overlay: boolean;
+    debug: boolean;
+}
+export declare function normalizeInput(raw: unknown): NormalizedInput;
+export interface ActivationResult {
+    concerns: Concern[];
+    sliceFamilies: string[];
+    /** P3 do ciclo MP1 (2026-08-31): famílias contadas para o gate de decomposição —
+     * UM SINAL = UMA SUPERFÍCIE. Só o concern PRIMÁRIO de cada sinal (posição 0 do
+     * mapeamento do termo/frase; explícitos/intents/ficheiros contam por si) contribui
+     * a sua família; concerns de suporte (posições secundárias, ex.: mtls→secrets,
+     * message queue→logging) activam categorias mas não são superfícies novas.
+     * `sliceFamilies` (grounding) fica intocado. */
+    decompositionFamilies: string[];
+    trace: ActivationTraceEntry[];
+    rejected: ActivationTraceEntry[];
+    notes: string[];
+    /** Per-concern aggregated score (max over contributing trace entries). */
+    concernScores: Map<Concern, number>;
+    /** Per-slice-family aggregated score. */
+    sliceFamilyScores: Map<string, number>;
+}
+export declare function activate(input: NormalizedInput): ActivationResult;
+export declare function categoriesForConcerns(concerns: Concern[]): Set<string>;
 /**
  * Conditions under which a conditional instruction slot is included inline at
  * `detail: "full"`. The dieted `codegen_instructions_ref.active_conditions`

package/dist/tools/prepare-codegen-context.js

@@ -32,6 +32,7 @@ import { getRegulatoryOverlay, resolveRegulatoryFramework } from "./regulatory-o
 import { expandQueryWithAliases } from "../backend/semantic-index-gateway.js";
 import { requirementCategoryOf } from "../serving/requirement-id.js";
 import { prepareCodegenAffordances } from "../serving/affordances.js";
+import { runSelectionWithActivation } from "../serving/selection.js";
 const EVIDENCE_PATTERN_CAP = 25;
 /**
  * v2 token diet, s3 — evidence-pattern cap applied at `detail: "standard" |
@@ -177,7 +178,7 @@ const TASK_TERM_TO_CONCERNS = [
     ["auth", ["auth"]],
     ["authentication", ["auth"]],
     ["authorization", ["auth"]],
-    ["login", ["auth"]],
+    ["login", ["auth", "encryption"]],
     ["session", ["auth"]],
     ["jwt", ["auth"]],
     ["oauth", ["auth"]],
@@ -213,8 +214,8 @@ const TASK_TERM_TO_CONCERNS = [
     ["release", ["release"]],
     ["deploy", ["deployment", "release"]],
     ["rollback", ["release"]],
-    ["terraform", ["iac", "deployment"]],
-    ["ansible", ["iac", "deployment"]],
+    ["terraform", ["iac"]],
+    ["ansible", ["iac"]],
     ["kubernetes", ["deployment", "config"]],
     ["docker", ["deployment", "config"]],
     ["container", ["deployment"]],
@@ -242,6 +243,15 @@ const TASK_TERM_TO_CONCERNS = [
     ["rpc", ["integration", "api"]],
     ["webhook", ["integration", "api"]],
     ["queue", ["integration"]],
+    // pós-P2 2026-08-31: integração por mensageria exige registo de eventos críticos → logging.
+    ["message queue", ["integration", "logging"]],
+    // pós-P2 2026-08-31: mTLS = gestão de material criptográfico → secrets (CFG/ENC).
+    ["mtls", ["encryption", "integration", "secrets"]],
+    ["signature", ["integrity", "encryption"]],
+    ["signing", ["integrity"]],
+    ["image", ["deployment", "distribution"]],
+    ["spa", ["validation", "api"]],
+    ["frontend", ["validation"]],
     ["pubsub", ["integration"]],
     ["monitoring", ["monitoring", "logging"]],
     ["metric", ["monitoring"]],
@@ -275,7 +285,9 @@ const CONCERN_TO_V0_CATEGORIES_SUPPLEMENT = {
     threat_modeling: ["THR"],
     monitoring: ["LOG", "OPS"],
     release: ["DPL", "OPS"],
-    deployment: ["DPL", "IAC", "CNT"],
+    // pós-P2 2026-08-31: deploy activa também a categoria base DST (cap. 02 — "Deploy
+    // apenas via pipeline validado" e afins); supplement do serving, loader inalterado.
+    deployment: ["DPL", "IAC", "CNT", "DST"],
     integration: ["API", "INT"],
     // `agents` → AGN comes from ontology.concernsMap (loader); nothing to supplement.
     agents: []
@@ -328,7 +340,17 @@ const CODEGEN_PT_ALIASES = [
     ["integração", ["integration"]],
     ["fronteira", ["boundary"]],
     ["arquitetura", ["architecture"]],
+    // R3 do ciclo MP1 (2026-08-31, crescimento por semântica do Manual — cap. 02
+    // categoria SES = sessões; nunca por caso do oráculo): sessão/sessões → session.
+    ["sessão", ["session"]],
+    ["sessões", ["session"]],
     ["chave de api", ["api key"]],
+    ["chave de cliente", ["api key"]],
+    ["chaves de cliente", ["api key"]],
+    ["mensageria", ["message queue"]],
+    ["fila de mensagens", ["message queue"]],
+    ["assinatura", ["signature"]],
+    ["imagem", ["image"]],
     ["variável de ambiente", ["environment variable"]]
 ];
 /**
@@ -350,6 +372,8 @@ const COMPOUND_TERM_TO_CONCERNS = [
     ["ci pipeline", ["build", "supply_chain"]],
     ["trust boundary", ["architecture"]],
     ["fronteira de confiança", ["architecture"]],
+    ["formulário de registo", ["auth", "validation"]],
+    ["registration form", ["auth", "validation"]],
     ["service to service", ["integration", "architecture"]],
     ["serviço a serviço", ["integration", "architecture"]],
     ["secret rotation", ["secrets"]],
@@ -390,7 +414,7 @@ function taskMatchesKeyword(taskLower, keyword) {
 }
 const VAGUE_PATTERNS = [
     {
-        pattern: /\b(torna|make).{0,40}\b(seguro|secure)\b/i,
+        pattern: /\b(torna|make).{0,40}\b(segur[ao]|secure)\b/i,
         reason: "Pedido excessivamente abrangente ('make secure' / 'tornar seguro')"
     },
     {
@@ -424,7 +448,7 @@ const VAGUE_PATTERNS = [
  * these, so the request is unsupported rather than decomposable.
  */
 const UNSUPPORTED_TECH_PATTERN = /\b(homomorphic|quantum[- ]?(resistant|safe)?|post[- ]?quantum|blockchain|smart contract|zero[- ]?knowledge|zk[- ]?(snark|stark|proof)s?|secure multiparty|federated learning)\b/i;
-function normalizeInput(raw) {
+export function normalizeInput(raw) {
     const data = (typeof raw === "object" && raw !== null ? raw : {});
     const task = typeof data.task === "string" ? data.task : "";
     const taskTrimmed = task.trim();
@@ -536,7 +560,7 @@ function recordActivation(trace, concerns, scores, rejected, entry, targetConcer
         trace.push(entry);
     }
 }
-function activate(input) {
+export function activate(input) {
     const trace = [];
     const rejected = [];
     const notes = [];
@@ -670,6 +694,45 @@ function activate(input) {
             reason: `Concern '${concern}' maps to AppSec Core slice family '${family}'.`
         });
     }
+    // 4b) Declared context activators (G-mp1a / D3, 2026-08-31): exposure and
+    // data_sensitivity stop being decorative — they activate concerns by DECLARED
+    // rule (each with its own trace source), because the reference selection
+    // semantics says an authenticated/public surface must be auditable and a
+    // personal/regulated data context must carry crypto+masking+validation.
+    const EXPOSURE_CONCERNS = {
+        internal: ["auth", "logging"],
+        authenticated: ["auth", "logging"],
+        public: ["auth", "logging", "api", "validation", "architecture"]
+    };
+    if (input.exposure && EXPOSURE_CONCERNS[input.exposure]) {
+        for (const concern of EXPOSURE_CONCERNS[input.exposure] ?? []) {
+            recordActivation(trace, concerns, concernScores, rejected, {
+                source: "exposure",
+                produced: concern,
+                trigger: input.exposure,
+                score: 0.9,
+                confidence: "deterministic",
+                reason: `exposure='${input.exposure}' activates ${concern} by declared rule (auditable exposed surface).`
+            }, concern, { capDuplicates: true });
+        }
+    }
+    const SENSITIVITY_CONCERNS = {
+        personal: ["encryption", "validation", "logging"],
+        regulated: ["encryption", "validation", "logging"],
+        secrets: ["secrets"]
+    };
+    if (input.data_sensitivity && SENSITIVITY_CONCERNS[input.data_sensitivity]) {
+        for (const concern of SENSITIVITY_CONCERNS[input.data_sensitivity] ?? []) {
+            recordActivation(trace, concerns, concernScores, rejected, {
+                source: "data_sensitivity",
+                produced: concern,
+                trigger: input.data_sensitivity,
+                score: 0.9,
+                confidence: "deterministic",
+                reason: `data_sensitivity='${input.data_sensitivity}' activates ${concern} by declared rule (ENC/masking/validation for personal or regulated data).`
+            }, concern, { capDuplicates: true });
+        }
+    }
     // 5) Risk level (informational trace entry, no concern activation).
     if (input.risk_level) {
         trace.push({
@@ -681,8 +744,39 @@ function activate(input) {
             reason: `Risk level ${input.risk_level} filters runtime v0 requirements.`
         });
     }
+    // P3 (2026-08-31): primary-concern families for the decomposition gate.
+    const primaryOfSignal = new Map();
+    for (const [term, mapped] of TASK_TERM_TO_CONCERNS) {
+        if (mapped.length > 0)
+            primaryOfSignal.set(term, mapped[0]);
+    }
+    for (const [phrase, mapped] of COMPOUND_TERM_TO_CONCERNS) {
+        if (mapped.length > 0)
+            primaryOfSignal.set(phrase, mapped[0]);
+    }
+    const primaryConcerns = new Set();
+    for (const entry of trace) {
+        if (entry.source === "risk_level" ||
+            entry.source === "exposure" ||
+            entry.source === "data_sensitivity" ||
+            entry.source === "scope_gate") {
+            continue; // contexto/informativos — não são superfícies
+        }
+        if (!concerns.has(entry.produced))
+            continue;
+        const rowPrimary = primaryOfSignal.get(entry.trigger);
+        if (rowPrimary === undefined || rowPrimary === entry.produced) {
+            primaryConcerns.add(entry.produced);
+        }
+    }
+    const decompositionFamilies = [
+        ...new Set([...primaryConcerns]
+            .map((concern) => CONCERN_TO_SLICE_FAMILY[concern])
+            .filter((family) => typeof family === "string"))
+    ].sort();
     return {
         concerns: [...concerns],
+        decompositionFamilies,
         sliceFamilies: [...sliceFamilyScores.keys()].sort((a, b) => (sliceFamilyScores.get(b) ?? 0) - (sliceFamilyScores.get(a) ?? 0) ||
             a.localeCompare(b)),
         trace,
@@ -736,21 +830,24 @@ function gateAfterActivation(args) {
     const { input, activation, estimatedRequirements } = args;
     const reasons = [];
     const suggestions = [];
-    if (activation.sliceFamilies.length > 3) {
-        reasons.push(`Pedido activa ${activation.sliceFamilies.length} slice families (${activation.sliceFamilies.join(", ")}) — máximo recomendado: 3.`);
+    // P3 do ciclo MP1 (2026-08-31): o gate conta SUPERFÍCIES (famílias dos concerns
+    // primários de cada sinal), não o total de famílias activadas — concerns de
+    // suporte de um mesmo sinal (mtls→secrets, mensageria→logging) não pedem
+    // decomposição. GC-10 é o caso de referência: 1 integração legítima.
+    if (activation.decompositionFamilies.length > 3) {
+        reasons.push(`Pedido activa ${activation.decompositionFamilies.length} superfícies (famílias primárias: ${activation.decompositionFamilies.join(", ")}) — máximo recomendado: 3. Concerns de suporte do mesmo sinal não contam.`);
         suggestions.push("Reparte por slice family. Cada PR/PR-step deve ficar em 1–3 slices.");
     }
-    // Hard requirement cap: above ~50 requirements the LLM context becomes
-    // unfocused and asks should be decomposed. Slice-family count (max 3) is the
-    // primary decomposition signal; this cap catches multi-concern asks that
-    // sneak under the slice-family threshold.
-    if (estimatedRequirements > 50) {
-        reasons.push(`Pedido activaria ${estimatedRequirements} requisitos v0 — máximo permitido para codegen: 50.`);
-        suggestions.push("Reduz o âmbito (risk_level mais baixo, concerns mais específicos, ou divide o endpoint).");
-    }
-    if (activation.concerns.length === 0 &&
-        input.tokenCount >= 4 &&
-        activation.trace.length === 0) {
+    // G-mp1a decision 2 (2026-08-31, D1): the former hard cap "max 50 activated
+    // requirements" is GONE — a legitimate L2 task activates >50 by design (the
+    // cap 02 baseline is a real catalogue). The gate guards TASK scope (vague /
+    // multi-family asks above) and PAYLOAD (the detail diet + budgets), never a
+    // requirement count. estimatedRequirements stays as a debug figure only.
+    void estimatedRequirements;
+    // D1 (G-mp1a): with the requirement-count cap gone, the no-signal guard is the
+    // vagueness catch-all. The informational risk_level trace entry must not defeat
+    // it — only real signals (concerns) count.
+    if (activation.concerns.length === 0 && input.tokenCount >= 4) {
         return {
             status: "needs_clarification",
             reasons: [
@@ -804,7 +901,7 @@ function projectRelation(relation) {
         source: "runtime_v1"
     };
 }
-function categoriesForConcerns(concerns) {
+export function categoriesForConcerns(concerns) {
     const ontology = getOntologyData();
     const categories = new Set();
     for (const concern of concerns) {
@@ -820,12 +917,20 @@ function categoriesForConcerns(concerns) {
 function resolveRuntimeV0(args) {
     const ontology = getOntologyData();
     const concernCategories = categoriesForConcerns(args.concerns);
-    let filteredRequirements = ontology.requirements;
-    if (args.riskLevel) {
-        filteredRequirements = filteredRequirements.filter((requirement) => requirement.applicable_levels?.[args.riskLevel] === true);
+    let filteredRequirements;
+    if (args.selectedRequirements) {
+        // MP1 engine (G-mp1a O2): the selection operation already produced the set
+        // (baseline ∪ context ⊕ narrowing, all declared) — use it verbatim.
+        filteredRequirements = args.selectedRequirements;
     }
-    if (concernCategories.size > 0) {
-        filteredRequirements = filteredRequirements.filter((requirement) => concernCategories.has(requirement.category));
+    else {
+        filteredRequirements = ontology.requirements;
+        if (args.riskLevel) {
+            filteredRequirements = filteredRequirements.filter((requirement) => requirement.applicable_levels?.[args.riskLevel] === true);
+        }
+        if (concernCategories.size > 0) {
+            filteredRequirements = filteredRequirements.filter((requirement) => concernCategories.has(requirement.category));
+        }
     }
     const links = ontology.requirementControlLinks ?? [];
     const requirementIds = new Set(filteredRequirements.map((r) => r.requirement_id));
@@ -2009,7 +2114,11 @@ function prepareCodegenContextCore(raw) {
         : deterministicConcerns.length > 0
             ? deterministicConcerns
             : activation.concerns;
-    const estimatedRequirements = estimateV0RequirementCount(input.risk_level, focusConcerns);
+    void focusConcerns; // kept for the debug notes below; the gate no longer counts requirements
+    // MP1 selection (G-mp1a O2): the engine composes baseline ∪ context and narrows
+    // by the task's declared signals — this is the requirement set served.
+    const selection = runSelectionWithActivation(input, activation);
+    const estimatedRequirements = selection.selected.length;
     const postGate = gateAfterActivation({
         input,
         activation,
@@ -2041,9 +2150,12 @@ function prepareCodegenContextCore(raw) {
         ], activation.trace, { rejected: activation.rejected, notes: activation.notes });
     }
     // ----- Resolve activated scope ----------------------------------------
+    const ontologyForSelection = getOntologyData();
+    const selectedIds = new Set(selection.selected.map((r) => r.requirement_id));
     const v0 = resolveRuntimeV0({
         riskLevel: input.risk_level,
-        concerns: activation.concerns
+        concerns: activation.concerns,
+        selectedRequirements: ontologyForSelection.requirements.filter((r) => selectedIds.has(r.requirement_id))
     });
     const activatedSlices = resolveActivatedSlices(g2Data, activation.sliceFamilies);
     const activatedSliceIds = new Set(activatedSlices.map((slice) => slice.slice_id));
@@ -2252,6 +2364,17 @@ function prepareCodegenContextCore(raw) {
         returned_artifacts: activatedArtifacts.length,
         named_v1_entities: namedV1,
         unnamed_v1_entities: totalV1 - namedV1,
+        selection: {
+            eligible: selection.eligible_count,
+            selected: selection.selected.length,
+            narrowed_out_categories: selection.narrowed_out.length,
+            narrowed_out_requirements: selection.narrowed_out.reduce((n, g) => n + g.count, 0),
+            narrowed_out_ref: {
+                tool: "select_sbd_toe_requirements",
+                note: "Categorias elegíveis sem sinal na tarefa foram excluídas pelo narrowing MP1 — " +
+                    "a lista completa (por categoria, com razão) vem de select_sbd_toe_requirements com o mesmo contexto."
+            }
+        },
         v1_consistency_mismatches: g2Data.consistency.mismatches,
         v1_manifest_warnings: g2Data.consistency.warnings,
         evidence_patterns_total: scoredEvidencePatterns.length,