@mmerterden/multi-agent-pipeline 16.4.0 → 16.6.0

package/pipeline/schemas/prefs.schema.json

@@ -821,6 +821,47 @@
           "default": false,
           "description": "v6.1.0+ - Phase 4 Step 2.5 rebuttal round. When reviewers disagree (mixed blocker/approved verdict), each reviewer is re-prompted with the others' opposing arguments for one additional round before triage. Lifts signal quality on ambiguous findings at ~1\u00d7 Step 2 token cost. Off by default - flip for security-critical or release-branch reviews."
         },
+        "analysisProfiles": {
+          "type": "array",
+          "description": "v16.6+ - which analysis standards the /multi-agent:analysis Step 1b picker offers (Locked 32). Listing one value auto-resolves the step instead of asking a question whose answer is already settled. Omitted means both are offered.",
+          "items": {
+            "type": "string",
+            "enum": ["global", "corporate"]
+          },
+          "default": ["global", "corporate"],
+          "uniqueItems": true,
+          "minItems": 1
+        },
+        "analysisProfile": {
+          "type": "object",
+          "additionalProperties": false,
+          "description": "v16.6+ - per-profile deployment bindings. These are site configuration, not part of the shipped template: an unconfigured run still renders the full document and asks for its destination at Phase 3.5 like any other run. Keys are deliberately generic so no organisation's space, page or tooling names live in the repo.",
+          "properties": {
+            "corporate": {
+              "type": "object",
+              "additionalProperties": false,
+              "description": "Bindings for the corporate profile: where its documents are published and which house terms they use.",
+              "properties": {
+                "confluenceSpaceKey": {
+                  "type": "string",
+                  "description": "Space the analysis page is created in when the Phase 3.5 picker chooses Confluence."
+                },
+                "confluenceParentPageId": {
+                  "type": "string",
+                  "description": "Parent page the analysis is filed under."
+                },
+                "titleFormat": {
+                  "type": "string",
+                  "description": "Page-title pattern, e.g. \"{prefix}{module}_{flow}_{suffix}\". Placeholders are resolved at emit time."
+                },
+                "titlePrefix": {
+                  "type": "string",
+                  "description": "Prefix that marks pipeline-authored pages so they stay distinguishable from hand-written ones."
+                }
+              }
+            }
+          }
+        },
         "updateCheck": {
           "type": "object",
           "additionalProperties": false,
@@ -840,8 +881,8 @@
             },
             "autoUpdate": {
               "type": "boolean",
-              "default": false,
-              "description": "When true, skip the question and run the update flow automatically before the run starts (interactive AND autopilot). Off by default - self-modifying ~/.claude without asking is a surprise."
+              "default": true,
+              "description": "Run the update flow automatically before the run starts, in interactive modes and autopilot alike, instead of asking. ON by default since v16.5.0: the alternative was telling every user to run a command, and the Supported Version Gate already halts an install below the required floor - so the real choice was never 'update or not', it was 'update, or stop and be told to update'. Set false to be asked once per ttlHours instead; updateCheck.enabled: false silences the check entirely (it does not disable the required floor). Already-loaded phase docs finish the current run on the old version either way; the update takes full effect on the next run."
             }
           }
         },

package/pipeline/scripts/build-references.mjs

@@ -0,0 +1,368 @@
+#!/usr/bin/env node
+// build-references.mjs  -  deterministic Section 21 References table for an
+// /multi-agent:analysis document (Locked 34).
+//
+// The references table used to be prose the model filled in. That lists what an
+// author remembers consulting, which is a different set from what the run
+// actually fetched: sources that failed to load vanish silently, scope decisions
+// made in conversation never appear, and a Figma link with no node id points at
+// whatever the file looks like today. This turns the table into a projection of
+// `state.analysisSpec.evidence.*` so the two cannot disagree.
+//
+// Zero deps. Two modes:
+//
+//   build   (default)  state JSON  -> markdown table on stdout
+//   --check <doc.md>   state JSON + emitted doc -> coverage gate, exit 1 on drift
+//
+// Usage:
+//   node build-references.mjs state.json [--lang tr|en]
+//   node build-references.mjs state.json --check analysis/Feature-ios.md
+//   cat state.json | node build-references.mjs - --lang en
+//
+// Exit codes: 0 ok, 1 coverage failure, 2 usage / parse error.
+
+import { readFileSync } from "node:fs";
+
+const HEADERS = {
+  tr: ["Tür", "Kaynak", "URL / Yol", "Sürüm / Ref", "Rol", "Erişim", "Notlar"],
+  en: ["Type", "Source", "URL / Path", "Version / Ref", "Role", "Access", "Notes"],
+};
+
+const OK = { tr: "ok", en: "ok" };
+const FAILED = { tr: "erişilemedi", en: "not reachable" };
+const NONE = "-";
+
+function argOf(argv, flag) {
+  const i = argv.indexOf(flag);
+  return i === -1 ? null : argv[i + 1] ?? null;
+}
+
+function readState(path) {
+  const raw = path === "-" ? readFileSync(0, "utf8") : readFileSync(path, "utf8");
+  const parsed = JSON.parse(raw);
+  // Accept either the full task state or the analysisSpec alone.
+  return parsed.analysisSpec ?? parsed;
+}
+
+// A cell that would break the pipe table, or read as an empty column, is worse
+// than a visibly absent value: the reader cannot tell a missing cell from a
+// cell that was never meant to have content.
+function cell(value) {
+  if (value === null || value === undefined) return NONE;
+  const text = String(value).replace(/\|/g, "\\|").replace(/\r?\n/g, " ").trim();
+  return text === "" ? NONE : text;
+}
+
+function accessCell(ok, reason, lang) {
+  if (ok) return OK[lang];
+  return reason ? `${FAILED[lang]} (${cell(reason)})` : FAILED[lang];
+}
+
+// The identity of a source for coverage purposes. Two rows describing the same
+// URL are the same source; a row with no locator falls back to its label so a
+// free-text note still has something to match on.
+function keyOf(url, fallback) {
+  const value = url && String(url).trim() !== "" && url !== NONE ? url : fallback;
+  return value ? String(value).trim() : null;
+}
+
+function rowsFrom(spec, lang) {
+  const ev = spec.evidence ?? {};
+  const rows = [];
+  const push = (type, source, url, ref, role, access, notes) => {
+    rows.push({
+      type,
+      cells: [cell(type), cell(source), cell(url), cell(ref), cell(role), access, cell(notes)],
+      key: keyOf(url, source),
+    });
+  };
+
+  for (const f of ev.figma ?? []) {
+    const ref = f.nodeId ? `node-id=${f.nodeId}` : f.fileKey ? `fileKey=${f.fileKey}` : NONE;
+    const frames = Array.isArray(f.frames) ? f.frames.length : 0;
+    const tier = f.tier ? ` (Tier ${f.tier})` : "";
+    push(
+      "Figma",
+      f.frames?.[0]?.name ?? f.fileKey ?? "design",
+      f.url,
+      ref,
+      lang === "tr" ? "UI tasarım" : "UI design",
+      OK[lang] + tier,
+      frames ? (lang === "tr" ? `${frames} frame` : `${frames} frames`) : NONE,
+    );
+  }
+
+  for (const c of ev.confluence ?? []) {
+    const ref = [c.pageId ? `pageId=${c.pageId}` : null, c.version ? `v${c.version}` : null]
+      .filter(Boolean)
+      .join(" ");
+    push(
+      "Confluence",
+      c.title ?? c.pageId,
+      c.url,
+      ref || NONE,
+      c.embeddedApiTable
+        ? lang === "tr" ? "API kontratı" : "API contract"
+        : lang === "tr" ? "özellik spesifikasyonu" : "feature spec",
+      OK[lang],
+      NONE,
+    );
+  }
+
+  for (const j of ev.jira ?? []) {
+    push("Jira", j.id, j.url ?? NONE, NONE, lang === "tr" ? "ticket" : "ticket", OK[lang], j.summary);
+  }
+
+  for (const s of ev.swagger ?? []) {
+    const n = Array.isArray(s.endpoints) ? s.endpoints.length : 0;
+    push(
+      "Swagger",
+      s.title ?? s.url,
+      s.url,
+      s.version ?? NONE,
+      lang === "tr" ? "API kontratı" : "API contract",
+      OK[lang],
+      n ? (lang === "tr" ? `${n} endpoint` : `${n} endpoints`) : NONE,
+    );
+  }
+
+  for (const r of ev.repo ?? []) {
+    push(
+      "Repo",
+      r.repoName,
+      r.path ?? r.repoName,
+      r.commit ?? r.sha ?? NONE,
+      lang === "tr" ? "mevcut kod" : "existing implementation",
+      OK[lang],
+      r.reuseSummary,
+    );
+  }
+
+  for (const s of ev.standards ?? []) {
+    push(
+      "Standards",
+      s.title ?? s.source,
+      s.source,
+      s.version ?? NONE,
+      s.binding ? "binding" : lang === "tr" ? "referans" : "reference",
+      OK[lang],
+      s.kind,
+    );
+  }
+
+  for (const f of ev.firebase ?? []) {
+    const n = Array.isArray(f.events) ? f.events.length : 0;
+    push(
+      "Firebase",
+      f.kind ?? "events",
+      f.source,
+      NONE,
+      lang === "tr" ? "referans" : "reference only",
+      OK[lang],
+      n ? (lang === "tr" ? `${n} event` : `${n} events`) : NONE,
+    );
+  }
+
+  for (const d of ev.documents ?? []) {
+    push(
+      lang === "tr" ? "Doküman" : "Document",
+      d.title ?? d.path,
+      d.path,
+      d.format ?? NONE,
+      d.binding ? "binding" : lang === "tr" ? "kapsam dokümanı" : "scope document",
+      accessCell(d.fetched !== false, d.fetched === false ? d.reason : null, lang),
+      NONE,
+    );
+  }
+
+  for (const o of ev.outside ?? []) {
+    push(
+      lang === "tr" ? "Dış kaynak" : "External",
+      o.source,
+      o.url ?? NONE,
+      o.citation ?? NONE,
+      lang === "tr" ? "referans" : "reference",
+      OK[lang],
+      o.claim,
+    );
+  }
+
+  for (const s of ev.signals ?? []) {
+    push(
+      lang === "tr" ? "Sinyal" : "Signal",
+      s.source,
+      s.url ?? NONE,
+      s.observedAt ?? NONE,
+      lang === "tr" ? "referans" : "reference",
+      OK[lang],
+      s.claim,
+    );
+  }
+
+  // Statements the user made in conversation that no fetched source carries.
+  // These settle scope as often as a document does, and a document that drops
+  // them loses the reason it excluded something.
+  for (const t of ev.freeText ?? []) {
+    push(
+      lang === "tr" ? "Serbest metin" : "Free text",
+      t.label ?? (lang === "tr" ? "kullanıcı notu" : "user note"),
+      NONE,
+      NONE,
+      t.role ?? (lang === "tr" ? "kapsam kararı" : "scope decision"),
+      NONE,
+      t.text ? `"${t.text}"` : NONE,
+    );
+  }
+
+  // A declared source that could not be fetched still gets a row. Dropping it
+  // reads to the next person as a source that never existed, which is the
+  // opposite of what happened.
+  for (const e of ev.fetchErrors ?? []) {
+    push(
+      e.type ?? (lang === "tr" ? "Kaynak" : "Source"),
+      e.title ?? e.url,
+      e.url,
+      NONE,
+      lang === "tr" ? "getirilemedi" : "not fetched",
+      accessCell(false, e.reason, lang),
+      NONE,
+    );
+  }
+
+  return rows;
+}
+
+function renderTable(rows, lang) {
+  const head = HEADERS[lang];
+  const lines = [`| ${head.join(" | ")} |`, `|${head.map(() => "---").join("|")}|`];
+  for (const r of rows) lines.push(`| ${r.cells.join(" | ")} |`);
+  return lines.join("\n");
+}
+
+// The References table in an emitted document: from the Section 21 heading to
+// the next heading of the same level or the end of the file.
+function extractReferencesBlock(doc) {
+  const lines = doc.split(/\r?\n/);
+  const start = lines.findIndex((l) => /^##\s+\d+\.\s+(Referanslar|References)\b/.test(l));
+  if (start === -1) return null;
+  const out = [];
+  for (let i = start + 1; i < lines.length; i++) {
+    if (/^##\s+\d+\./.test(lines[i])) break;
+    out.push(lines[i]);
+  }
+  return out.join("\n");
+}
+
+// The header row and the separator row carry no source to verify. Matching them
+// against the evidence record is how a correct table gets reported as carrying
+// an invented reference.
+const HEADER_CELLS = new Set(
+  Object.values(HEADERS)
+    .flat()
+    .map((h) => h.toLowerCase()),
+);
+
+function tableLocators(block) {
+  const found = [];
+  for (const line of block.split(/\r?\n/)) {
+    if (!line.trim().startsWith("|")) continue;
+    const cells = line.split("|").slice(1, -1).map((c) => c.trim());
+    if (cells.length < 3) continue;
+    if (/^:?-{3,}:?$/.test(cells[0])) continue;
+    const locator = cells[2];
+    const source = cells[1];
+    if (!locator) continue;
+    if (HEADER_CELLS.has(locator.toLowerCase()) && HEADER_CELLS.has(cells[0].toLowerCase())) continue;
+    found.push({ locator, source, raw: line });
+  }
+  return found;
+}
+
+function check(spec, docPath, lang) {
+  const doc = readFileSync(docPath, "utf8");
+  const block = extractReferencesBlock(doc);
+  const problems = [];
+
+  if (block === null) {
+    problems.push("ERROR: no References section found; Section 21 is never omitted (Locked 21)");
+    return problems;
+  }
+
+  const expected = rowsFrom(spec, lang).filter((r) => r.key !== null);
+  const rendered = tableLocators(block);
+  const renderedText = block;
+
+  for (const row of expected) {
+    if (!renderedText.includes(row.key)) {
+      problems.push(
+        `ERROR: ${row.type} source consumed by the run but absent from References: ${row.key}`,
+      );
+    }
+  }
+
+  const expectedKeys = new Set(expected.map((r) => r.key));
+  for (const r of rendered) {
+    // Header rows and placeholder cells carry no locator to verify.
+    if (r.locator === NONE || r.locator === "" || /^<.*>$/.test(r.locator)) continue;
+    const known = [...expectedKeys].some((k) => r.locator.includes(k) || k.includes(r.locator));
+    if (!known) {
+      problems.push(
+        `ERROR: References row has no matching evidence entry (invented reference): ${r.locator}`,
+      );
+    }
+  }
+
+  return problems;
+}
+
+function main() {
+  const argv = process.argv.slice(2);
+  const statePath = argv[0];
+  if (!statePath || statePath.startsWith("--")) {
+    process.stderr.write(
+      "usage: build-references.mjs <state.json|-> [--lang tr|en] [--check <doc.md>]\n",
+    );
+    process.exit(2);
+  }
+
+  let spec;
+  try {
+    spec = readState(statePath);
+  } catch (err) {
+    process.stderr.write(`ERROR: cannot read state: ${err.message}\n`);
+    process.exit(2);
+  }
+
+  const lang = argOf(argv, "--lang") ?? spec.language ?? "tr";
+  if (!HEADERS[lang]) {
+    process.stderr.write(`ERROR: unknown language "${lang}"; expected tr or en\n`);
+    process.exit(2);
+  }
+
+  const docPath = argOf(argv, "--check");
+  if (docPath) {
+    const problems = check(spec, docPath, lang);
+    if (problems.length) {
+      for (const p of problems) process.stderr.write(`${p}\n`);
+      process.stderr.write(`\n${problems.length} references coverage failure(s)\n`);
+      process.exit(1);
+    }
+    process.stdout.write("references coverage ok\n");
+    process.exit(0);
+  }
+
+  const rows = rowsFrom(spec, lang);
+  if (rows.length === 0) {
+    // An analysis with no sources at all is possible (a pure free-text run) but
+    // it should say so rather than emit an empty table with a header.
+    process.stdout.write(
+      lang === "tr"
+        ? "Bu koşuda getirilen kaynak yok.\n"
+        : "No sources were fetched for this run.\n",
+    );
+    process.exit(0);
+  }
+  process.stdout.write(`${renderTable(rows, lang)}\n`);
+}
+
+main();

package/pipeline/scripts/validate-analysis-doc.mjs

@@ -42,7 +42,9 @@
 
 import { readFileSync } from "node:fs";
 
-const KNOWN_PLATFORMS = new Set(["ios", "android", "backend", "frontend"]);
+// "none" is the stack-optional render (Locked 35): a document produced before
+// any repo was chosen. It is a real platform value, not a missing one.
+const KNOWN_PLATFORMS = new Set(["ios", "android", "backend", "frontend", "none"]);
 const REQUIRED_FM = ["feature", "platform", "language", "mode", "template_version"];
 
 // Never-omitted sections (Locked 2), matched by bilingual title keyword so the
@@ -58,6 +60,26 @@ const REQUIRED_SECTIONS = [
   { key: "references", any: ["References", "Referanslar"] },
 ];
 
+// Corporate profile backbone (Locked 33). These render even with zero evidence,
+// carrying N/A or EKLENECEK, so their absence is a structural failure rather
+// than a legitimate omission.
+const CORPORATE_SECTIONS = [
+  { key: "purpose and scope", any: ["Amaç ve Kapsam", "Amac ve Kapsam", "Purpose and Scope"] },
+  { key: "business analysis", any: ["İş Analizi", "Is Analizi", "Business Analysis"] },
+  { key: "business requirements", any: ["İş Gereksinimleri", "Is Gereksinimleri", "Business Requirements"] },
+  { key: "ai requirements", any: ["Yapay Zeka", "AI Requirements"] },
+  { key: "use cases", any: ["Kullanım Senaryoları", "Kullanim Senaryolari", "Use Cases"] },
+  { key: "hardware and infrastructure", any: ["Donanım", "Donanim", "Hardware"] },
+  { key: "quality requirements", any: ["Kalite Gereksinimleri", "Quality Requirements"] },
+  { key: "regulatory requirements", any: ["Regülasyonel", "Regulasyonel", "Regulatory"] },
+  { key: "content requirements", any: ["İçerik Gereksinimleri", "Icerik Gereksinimleri", "Content Requirements"] },
+  { key: "risks", any: ["Riskler", "Risks"] },
+  { key: "references", any: ["Referanslar", "References"] },
+];
+
+// Sections that need a target repository. Dropped by the stack-optional render.
+const REPO_DEPENDENT_KEYS = new Set(["architecture", "files to add"]);
+
 // Humanizer punctuation policy (Locked 7) - banned codepoints.
 const BANNED_PUNCT = [
   { ch: "—", name: "em-dash" },
@@ -163,6 +185,11 @@ function main() {
     }
   }
   const mode = parsed?.fm?.mode || "full";
+  const profile = (parsed?.fm?.profile || "global").toLowerCase();
+  if (profile !== "global" && profile !== "corporate") {
+    errors.push(`front-matter profile must be global|corporate, got: ${profile}`);
+  }
+  const noPlatform = (parsed?.fm?.platform || "") === "none";
 
   // 2. Never-omitted sections (by heading keyword)
   // Numbered section headings only. Layer headings (`# Bölüm B - Teknik Analiz`)
@@ -173,9 +200,94 @@ function main() {
     .filter((l) => /^#{2,3}\s+\d+(\.\d+)*\.?\s/.test(l))
     .map((l) => l.replace(/^#{2,3}\s/, "").trim());
   const headingBlob = headings.join("\n");
-  for (const sec of REQUIRED_SECTIONS) {
+  const requiredSections = (profile === "corporate" ? CORPORATE_SECTIONS : REQUIRED_SECTIONS)
+    // The development layer is legitimately absent when no repo was selected,
+    // so requiring it there would fail every stack-optional document.
+    .filter((sec) => !(noPlatform && REPO_DEPENDENT_KEYS.has(sec.key)));
+  const rule = profile === "corporate" ? "Locked 33" : "Locked 2";
+  for (const sec of requiredSections) {
     if (!sec.any.some((kw) => headingBlob.includes(kw))) {
-      errors.push(`missing required section (Locked 2): ${sec.key}`);
+      errors.push(`missing required section (${rule}): ${sec.key}`);
+    }
+  }
+
+  // 2a. Corporate profile: every EKLENECEK owes an open question.
+  //
+  // A placeholder with nobody assigned to resolve it is how "to be filled in"
+  // reaches production. The pairing is what makes the backbone guarantee worth
+  // having: the section renders, AND the gap it admits to is tracked.
+  if (profile === "corporate") {
+    const lines = text.split("\n");
+    const risksStart = lines.findIndex((l) =>
+      /^#{2,3}\s+\d+/.test(l) && /(Riskler|Risks)/.test(l),
+    );
+    let risksBlock = "";
+    if (risksStart !== -1) {
+      for (let i = risksStart + 1; i < lines.length; i++) {
+        if (/^#{2,3}\s+\d+/.test(lines[i])) break;
+        risksBlock += `${lines[i]}\n`;
+      }
+    }
+    let currentSection = null;
+    const unpaired = new Set();
+    for (let i = 0; i < lines.length; i++) {
+      const m = lines[i].match(/^#{2,4}\s+(\d+(?:\.\d+)*)\.?\s/);
+      if (m) currentSection = m[1];
+      if (!lines[i].includes("EKLENECEK")) continue;
+      if (risksStart !== -1 && i > risksStart) continue;
+      if (!currentSection) continue;
+      // The number has to stand alone: substring matching would let section "2"
+      // be satisfied by a "2.3" in some other row, and "9" by a "19". The
+      // trailing guard rejects a following digit and a following ".<digit>",
+      // but NOT a sentence-ending period - "etkilediği bölüm 9." is a real
+      // pairing, and rejecting it would block a correct document.
+      const token = new RegExp(
+        `(^|[^\\d.])${currentSection.replace(/\./g, "\\.")}(?!\\d|\\.\\d)`,
+        "m",
+      );
+      if (!token.test(risksBlock)) unpaired.add(currentSection);
+    }
+    for (const sec of unpaired) {
+      errors.push(
+        `section ${sec} carries EKLENECEK but no Risks and Open Questions row references it (Locked 33)`,
+      );
+    }
+
+    // The traceability matrix is the most expensive thing in the document to get
+    // wrong, because every downstream reader trusts it instead of re-deriving
+    // the IG -> UC -> FG chain themselves. A matrix that merely exists is not
+    // the claim worth making; a matrix that agrees with the sections is.
+    const MATRIX_HEADING = /(İzlenebilirlik Matrisi|Izlenebilirlik Matrisi|Traceability Matrix)/;
+    if (mode === "full") {
+      const matrixStart = lines.findIndex((l) => /^#{2,4}\s/.test(l) && MATRIX_HEADING.test(l));
+      if (matrixStart === -1) {
+        errors.push("corporate Full mode requires the requirement traceability matrix (Locked 33)");
+      } else {
+        let matrixBlock = "";
+        for (let i = matrixStart + 1; i < lines.length; i++) {
+          if (/^#{2,4}\s/.test(lines[i])) break;
+          matrixBlock += `${lines[i]}\n`;
+        }
+        // Everything outside the matrix is where ids are defined and used.
+        const outside = lines.slice(0, matrixStart).join("\n");
+
+        for (const prefix of ["IG", "UC", "FG"]) {
+          const idRe = new RegExp(`\\b${prefix}-\\d{2,3}\\b`, "g");
+          const defined = new Set(outside.match(idRe) || []);
+          const inMatrix = new Set(matrixBlock.match(idRe) || []);
+
+          for (const id of defined) {
+            if (!inMatrix.has(id)) {
+              errors.push(`${id} is defined in the document but missing from the traceability matrix`);
+            }
+          }
+          for (const id of inMatrix) {
+            if (!defined.has(id)) {
+              errors.push(`${id} appears in the traceability matrix but is defined nowhere else`);
+            }
+          }
+        }
+      }
     }
   }
 
@@ -206,9 +318,13 @@ function main() {
     }
   }
 
-  // 2c. Section 15 is Phase 3's RED input (phase-3-dev.md step 5b): the tests
+  // 2c. The Test Plan is Phase 3's RED input (phase-3-dev.md step 5b): the tests
   // written first come from it. Full mode without it hands dev an empty matrix.
-  if (mode === "full") {
+  // It is Section 15 in the global profile and Section 19 in the corporate one;
+  // the check matches on the title, so only the stack-optional case needs an
+  // exemption - there the whole development layer is legitimately absent
+  // (Locked 35) and there is no repo for a test to run against yet.
+  if (mode === "full" && !noPlatform) {
     const hasTestPlan = ["Test Planı", "Test Plani", "Test Plan"].some((kw) =>
       headingBlob.includes(kw),
     );
@@ -244,7 +360,9 @@ function main() {
   const hasMermaid = /^\s*```mermaid/m.test(text);
   if (hasFlowSection && !hasMermaid) {
     errors.push("Section 3 is rendered but carries no mermaid block");
-  } else if (!hasFlowSection && mode === "full") {
+  } else if (!hasFlowSection && mode === "full" && profile === "global") {
+    // The corporate profile numbers Section 3 as Business Requirements and puts
+    // its diagrams under 5.(N+1), so "no Section 3 flow chart" is meaningless there.
     warns.push(
       "no Section 3 flow chart; legitimate only for a single screen with a single service and a simple rule",
     );
@@ -319,8 +437,11 @@ function main() {
     }
   }
 
-  // 4. Placeholder whole-section bodies (Locked 2)
-  if (/^\s*(TBD|Not applicable|N\/A)\s*$/im.test(text)) {
+  // 4. Placeholder whole-section bodies (Locked 2).
+  // Not a defect in the corporate profile: there N/A and EKLENECEK are how a
+  // backbone section reports "considered, nothing to state" (Locked 33), and the
+  // EKLENECEK-to-open-question pairing above is what keeps them honest.
+  if (profile === "global" && /^\s*(TBD|Not applicable|N\/A)\s*$/im.test(text)) {
     warns.push(
       'a line is a bare "TBD"/"Not applicable"/"N/A" body; omit the section instead (Locked 2)',
     );
@@ -335,7 +456,7 @@ function main() {
       const key = id.toUpperCase();
       counts.set(key, (counts.get(key) || 0) + 1);
     }
-    if (counts.size === 0) {
+    if (counts.size === 0 && profile === "global") {
       warns.push("Full mode but no BR-<slug>-NN business-rule ids found (Section 4.4 / Locked 31)");
     }
     for (const [id, n] of counts) {