@boyingliu01/xp-gate 0.35.23 → 0.36.0

package/principles/adapters/csharp.ts

@@ -0,0 +1,309 @@
+import { BaseAdapter } from './base';
+import { Adapter } from '../types';
+
+/**
+ * Lexical state for the C# block scanner: which comment/quote the scan is
+ * currently inside. Braces seen in any of these states are data, not structure.
+ *
+ * C# needs one more state than C++: verbatim strings (`@"..."`) terminate on a
+ * doubled quote rather than a backslash escape, and raw string literals
+ * (`"""..."""`) have no escape character at all. Treating either as a normal
+ * literal would mis-judge where the body ends.
+ */
+interface CSharpLexState {
+  inString: boolean;
+  /** Which quote character opened the string (`'` or `"`). */
+  stringChar: string;
+  inBlockComment: boolean;
+  /** `@"..."`: `""` is an escaped quote, backslash is literal. */
+  inVerbatimString: boolean;
+  /** `"""..."""`: delimited by a run of >= 3 quotes. */
+  inRawString: boolean;
+  rawStringQuoteCount: number;
+}
+
+/**
+ * C# language adapter for the principles checker (Gate 4).
+ *
+ * Why this file exists: `analyzer.ts`'s `adapterMap` had no `.cs` entry, so
+ * `getAdapterForFile('A.cs')` returned `null`. `gate-4.sh` DID pass `.cs` paths
+ * to the checker (its extension filter includes `cs`), so the file was accepted
+ * and then dropped — a gate that printed "checking" and checked nothing. The
+ * AC that claimed Gate 4 covered C# by testing the *filter* alone was therefore
+ * wrong, which is what this adapter and its tests fix.
+ *
+ * Regex-based rather than AST-based, following `cpp.ts`: no C# parser is
+ * available in this zero-dependency package, and the same lexical-blindness
+ * problem (braces inside literals/comments) applies verbatim.
+ */
+export class CSharpAdapter extends BaseAdapter implements Adapter {
+  detectLanguage(): string {
+    const lower = this.filePath.toLowerCase();
+    if (lower.endsWith('.cs') || lower.endsWith('.csx')) {
+      return 'csharp';
+    }
+    return super.detectLanguage();
+  }
+
+  parseAST(): unknown {
+    return this.createParseResult('csharp');
+  }
+
+  extractFunctions(): unknown[] {
+    const matches: unknown[] = [];
+
+    // C# method declaration: optional modifiers, return type, name, params,
+    // then either a block `{`, an expression body `=>`, or `;` (abstract /
+    // interface members). `async` and generics (`Task<int>`) must be tolerated
+    // or every async method in a modern codebase is invisible.
+    const methodRegex =
+      /(?:^|\n)[ \t]*(?:(?:public|private|protected|internal|static|async|override|virtual|sealed|abstract|extern|unsafe|new|partial)\s+)*(?:[\w.<>\[\],?]+\s+)?([A-Za-z_]\w*)\s*(?:<[^>]*>)?\s*\(([^)]*)\)\s*(?:where\s[^{;]*)?(?:=>|\{|;)/g;
+
+    let match: RegExpExecArray | null;
+    while ((match = methodRegex.exec(this.fileContent)) !== null) {
+      const name = match[1];
+      // Constructors and `new` expressions look like the pattern above; the
+      // reserved words are not method names as far as the rules care.
+      if (CSharpAdapter.RESERVED.has(name)) continue;
+
+      const params = match[2].trim();
+      const paramCount = params === '' ? 0 : params.split(',').length;
+
+      matches.push(this.createCodeMatch(name, 'function', match.index));
+      const fnMatch = matches[matches.length - 1];
+      this.annotate(fnMatch, 'paramCount', paramCount);
+      this.annotateBodyMetrics(fnMatch);
+    }
+
+    // Constructors: `public Foo(...)` has no return type, so the regex above
+    // can miss it when the modifier list is empty or minimal.
+    const ctorRegex = /(?:^|\n)[ \t]*(?:(?:public|private|protected|internal|static)\s+)*([A-Za-z_]\w*)\s*\(([^)]*)\)\s*(?::\s*(?:base|this)\s*\([^)]*\)\s*)?\{/g;
+    while ((match = ctorRegex.exec(this.fileContent)) !== null) {
+      const name = match[1];
+      if (CSharpAdapter.RESERVED.has(name)) continue;
+      const params = match[2].trim();
+      const paramCount = params === '' ? 0 : params.split(',').length;
+      matches.push(this.createCodeMatch(name, 'constructor', match.index));
+      const ctorMatch = matches[matches.length - 1];
+      this.annotate(ctorMatch, 'paramCount', paramCount);
+      this.annotateBodyMetrics(ctorMatch);
+    }
+
+    return matches;
+  }
+
+  extractClasses(): unknown[] {
+    const matches: unknown[] = [];
+    // The trailing group accepts BOTH shapes a type declaration takes: a body
+    // (`{`) and a body-less primary-constructor record (`record Delta(int X);`,
+    // C# 9+). Requiring `{` made every such record invisible to the god-class /
+    // large-file rules.
+    const classRegex =
+      /\b(?:(?:public|private|protected|internal|static|sealed|abstract|partial|readonly|unsafe|new)\s+)*(class|interface|struct|record|enum)\s+([A-Za-z_]\w*)\s*(?:<[^>]*>)?\s*(?:\([^)]*\))?\s*(?::\s*[^{\n;]+)?\s*(?:\{|;)/g;
+
+    let match: RegExpExecArray | null;
+    while ((match = classRegex.exec(this.fileContent)) !== null) {
+      matches.push(this.createCodeMatch(match[2], match[1], match.index));
+      const body = this.extractCodeBlock(match.index);
+      // methodCount feeds the god-class rule; counting declarations in the body
+      // is the only signal available without a real parser.
+      const methodCount = (body.match(/\b(?:public|private|protected|internal)\s+[^;{}]*\([^)]*\)\s*(?:=>|\{)/g) || []).length;
+      this.annotate(matches[matches.length - 1], 'methodCount', methodCount);
+    }
+
+    return matches;
+  }
+
+  /**
+   * Attach a computed metric to a match returned by `createCodeMatch`.
+   *
+   * The base helper builds `{name, type, line, code}`; the 14 rules read extra
+   * fields (length / paramCount / nestingDepth / methodCount / hasTryCatch), and
+   * a missing field is why 12 of those rules were structurally unable to fire on
+   * TypeScript before #446. This keeps the same lesson from repeating here.
+   */
+  private annotate(target: unknown, key: string, value: number): void {
+    (target as Record<string, unknown>)[key] = value;
+  }
+
+  /**
+   * Compute the body-derived metrics the rules read, from this match's own
+   * `code` (which `createCodeMatch` already cut with the literal-aware scanner).
+   *
+   * length / nestingDepth / hasTryCatch all come from the body, so computing
+   * them anywhere else would re-implement the brace scan and drift from it.
+   */
+  private annotateBodyMetrics(target: unknown): void {
+    const m = target as Record<string, unknown>;
+    const body = typeof m.code === 'string' ? m.code : '';
+
+    // Lines of the body, minus the declaration line itself.
+    const lineCount = body === '' ? 0 : body.split(/\r?\n/).length;
+    m.length = lineCount;
+
+    // Nesting depth = the deepest run of `{` that the scanner saw. Literals and
+    // comments were already removed by the scanner before this string was cut.
+    let depth = 0;
+    let maxDepth = 0;
+    for (const ch of body) {
+      if (ch === '{') { depth++; if (depth > maxDepth) maxDepth = depth; }
+      else if (ch === '}') depth--;
+    }
+    // A method body contributes its own level, so a flat body reads 1.
+    m.nestingDepth = maxDepth > 0 ? maxDepth : 0;
+
+    m.hasTryCatch = /\btry\s*\{/.test(body) && /\bcatch\s*[({]/.test(body);
+  }
+
+  /** Words that the C# grammar allows where a method name appears. */
+  private static readonly RESERVED = new Set([
+    'if', 'for', 'foreach', 'while', 'switch', 'catch', 'using', 'lock', 'return',
+    'new', 'throw', 'case', 'do', 'else', 'fixed', 'try', 'finally', 'yield',
+    'await', 'typeof', 'sizeof', 'nameof', 'default', 'checked', 'unchecked',
+  ]);
+
+  override extractCodeBlock(startPos: number, maxFallback: number = 200): string {
+    const state = { inBlock: false, braceCount: 0 };
+    const lex: CSharpLexState = {
+      inString: false,
+      stringChar: '',
+      inBlockComment: false,
+      inVerbatimString: false,
+      inRawString: false,
+      rawStringQuoteCount: 0,
+    };
+    let endPos = startPos;
+
+    for (let i = startPos; i < this.fileContent.length;) {
+      const skip = this.lexSkip(i, lex);
+      if (skip > 0) { i += skip; continue; }
+
+      const result = this.advanceBraceTracker(this.fileContent[i], i, state);
+      if (result.closed) {
+        endPos = result.endPos;
+        break;
+      }
+      i++;
+    }
+
+    if (endPos > startPos) {
+      return this.fileContent.substring(startPos, endPos);
+    }
+
+    return this.fallbackCodeBlock(startPos, maxFallback);
+  }
+
+  /**
+   * Report how far the lexer can skip from `i`, updating `lex` as it goes.
+   *
+   * Same contract as `cpp.ts`'s `lexSkip`: returning 0 means the caller must
+   * inspect the character itself, which is what lets a `{` both end a
+   * literal-free run and open the block.
+   */
+  private lexSkip(i: number, lex: CSharpLexState): number {
+    const char = this.fileContent[i];
+    const nextChar = this.fileContent[i + 1] || '';
+
+    if (lex.inRawString) return this.skipRawStringBody(i, lex);
+    if (lex.inBlockComment) return this.skipBlockCommentBody(i, char, nextChar, lex);
+    if (lex.inString) return this.skipStringBody(i, char, lex);
+
+    if (char === '/' && nextChar === '/') return this.skipLineComment(i);
+    if (char === '/' && nextChar === '*') {
+      lex.inBlockComment = true;
+      return 2;
+    }
+
+    // `@"` opens a verbatim string; `"` alone opens a normal one.
+    if (char === '@' && nextChar === '"') {
+      lex.inString = true;
+      lex.inVerbatimString = true;
+      lex.stringChar = '"';
+      return 2;
+    }
+
+    // A run of 3+ quotes is a raw string literal.
+    if (char === '"') {
+      let run = 0;
+      let k = i;
+      while (this.fileContent[k] === '"') { run++; k++; }
+      if (run >= 3) {
+        lex.inRawString = true;
+        lex.rawStringQuoteCount = run;
+        return run;
+      }
+      lex.inString = true;
+      lex.inVerbatimString = false;
+      lex.stringChar = '"';
+      return 1;
+    }
+
+    if (char === "'") {
+      lex.inString = true;
+      lex.inVerbatimString = false;
+      lex.stringChar = "'";
+      return 1;
+    }
+
+    return 0;
+  }
+
+  /** Skip a `//` comment through, but not including, the newline. */
+  private skipLineComment(start: number): number {
+    let i = start;
+    while (i < this.fileContent.length && this.fileContent[i] !== '\n') i++;
+    return i - start;
+  }
+
+  private skipBlockCommentBody(
+    i: number,
+    char: string,
+    nextChar: string,
+    lex: CSharpLexState,
+  ): number {
+    if (char === '*' && nextChar === '/') {
+      lex.inBlockComment = false;
+      return 2;
+    }
+    return 1;
+  }
+
+  private skipStringBody(i: number, char: string, lex: CSharpLexState): number {
+    if (char !== lex.stringChar) return 1;
+
+    // Verbatim strings escape a quote by DOUBLING it: `@"a""b"` is `a"b`.
+    if (lex.inVerbatimString) {
+      if (this.fileContent[i + 1] === '"') return 2;
+      lex.inString = false;
+      lex.inVerbatimString = false;
+      return 1;
+    }
+
+    // A quote closes the literal only after an EVEN number of backslashes:
+    // `"\\"` is a backslash then a terminator, `"\""` is a quote as data.
+    let backslashCount = 0;
+    let j = i - 1;
+    while (j >= 0 && this.fileContent[j] === '\\') {
+      backslashCount++;
+      j--;
+    }
+    if (backslashCount % 2 === 0) lex.inString = false;
+    return 1;
+  }
+
+  /** A raw string closes on a quote run of the same length that opened it. */
+  private skipRawStringBody(i: number, lex: CSharpLexState): number {
+    if (this.fileContent[i] !== '"') return 1;
+
+    let run = 0;
+    let k = i;
+    while (this.fileContent[k] === '"') { run++; k++; }
+
+    if (run >= lex.rawStringQuoteCount) {
+      lex.inRawString = false;
+      lex.rawStringQuoteCount = 0;
+      return run;
+    }
+    return run;
+  }
+}

package/principles/analyzer.ts

@@ -9,6 +9,7 @@ import { DartAdapter } from './adapters/dart';
 import { SwiftAdapter } from './adapters/swift';
 import { ObjectiveCAdapter } from './adapters/objectivec';
 import { CppAdapter } from './adapters/cpp';
+import { CSharpAdapter } from './adapters/csharp';
 import { extname } from 'path';
 
 export type { Violation } from './types';
@@ -63,6 +64,10 @@ export function getAdapterForFile(filePath: string): Adapter | null {
     '.swift': SwiftAdapter,
     '.m': ObjectiveCAdapter,
     '.mm': ObjectiveCAdapter,
+    // #717: without this entry `getAdapterForFile('A.cs')` returned null while
+    // gate-4.sh had already accepted the file, so Gate 4 inspected no C# at all.
+    '.cs': CSharpAdapter,
+    '.csx': CSharpAdapter,
     '.cpp': CppAdapter,
     '.cxx': CppAdapter,
     '.cc': CppAdapter,

package/scripts/delphi-external-review.cjs

@@ -659,10 +659,129 @@ async function callExpertWithSchemaRetry({ provider, model, systemPrompt, userPr
 }
 
 // ── API call ───────────────────────────────────────────────────────────
-async function callModelAPI(providerConfig, model, systemPrompt, userPrompt, options = {}) {
-  const url = `${providerConfig.base_url.replace(/\/$/, '')}/chat/completions`;
 
-  const body = {
+/**
+ * Map a 429 to a verdict. Not every 429 is a transient rate limit — WhaleCloud
+ * returns `type: "budget_exceeded"` in two distinct non-retryable cases, and a
+ * blind retry cannot clear either and would burn two round-trips before failing:
+ *   - `error.param === "category_quota"`: the account has no ECONOMY/STANDARD
+ *     quota configured for the model ("需要专项额度...尚未配置") — needs an admin.
+ *   - `error.param === "cost_quota"`: the account's daily spending cap is
+ *     exhausted ("今日额度已耗尽...限额: 100.00元") — resets the next day.
+ * Surface which kind it is so the caller knows whether to wait or to ask for an
+ * admin change, rather than treating both as a generic rate limit.
+ *
+ * Extracted from `callModelAPI` so the branch reads as one rule (#722 follow-up:
+ * the enclosing function was CCN 33 against a block threshold of 10).
+ */
+async function classifyRateLimitResponse(response) {
+  let quotaType = '';
+  try {
+    const body = await response.json();
+    if (body && body.error && body.error.type === 'budget_exceeded') {
+      quotaType = body.error.param === 'cost_quota' ? 'daily budget exhausted' : 'quota not configured';
+    }
+  } catch {
+    // body is not JSON; fall through to the generic rate-limit handling
+  }
+  if (quotaType) {
+    return { error: true, retryable: false, message: `WhaleCloud budget_exceeded: ${quotaType} for this model.` };
+  }
+  return { error: true, retryable: true, message: 'Rate limit exceeded (429).' };
+}
+
+/**
+ * Map a 5xx to a verdict, reading the provider's structured error body the same
+ * way the 429 branch does instead of discarding it (#705).
+ *
+ * Measured on the whalecloud gateway: a prompt containing
+ * `new ProcessBuilder(args).start()` makes the gateway fail in its
+ * response-processing stage and return 500 with
+ *   {"error":{"type":"response_processing_error",
+ *             "param":"non_stream_chat_response","code":"500"}}
+ * The old code threw that away and reported "Server error (500).", which reads
+ * as a transient outage. `type`/`param` are what tell an operator apart gateway
+ * flapping vs. upstream timeout vs. content-triggered processing failure —
+ * three problems with three different responses.
+ *
+ * Retryability is the other half: a content-dependent failure cannot clear by
+ * retrying (the content did not change), so marking it retryable burns the
+ * orchestrator's retry budget on a guaranteed repeat. Only an explicitly
+ * recognised response_processing_error is demoted; every other 5xx keeps the
+ * previous retryable=true, and an unparseable body keeps the previous behaviour
+ * entirely — reading the body must not change the verdict on its own.
+ */
+async function classifyServerErrorResponse(response) {
+  let detail = '';
+  let processingError = false;
+  try {
+    const body = await response.json();
+    if (body && body.error && typeof body.error === 'object') {
+      const type = typeof body.error.type === 'string' ? body.error.type : '';
+      const param = typeof body.error.param === 'string' ? body.error.param : '';
+      if (type === 'response_processing_error') {
+        processingError = true;
+      }
+      const parts = [type, param].filter(Boolean);
+      if (parts.length > 0) {
+        detail = ` Provider reported: ${parts.join('/')}.`;
+      }
+    }
+  } catch {
+    // body is not JSON; keep the previous behaviour untouched
+  }
+  if (processingError) {
+    return {
+      error: true,
+      retryable: false,
+      message: `Server error (${response.status}).${detail} This is a content-dependent upstream processing failure, so retrying the same prompt will fail the same way.`,
+    };
+  }
+  return { error: true, retryable: true, message: `Server error (${response.status}).${detail}` };
+}
+
+/**
+ * Map a 2xx response body to a verdict.
+ *
+ * The gateway must echo which model actually served the request. Writing `null`
+ * here used to be tolerated downstream, which let a run that never resolved a
+ * model count as a successful expert call (#423). Fail at the source instead,
+ * so the evidence never records an unverifiable expert.
+ */
+async function readSuccessfulResponse(response) {
+  const data = await response.json();
+  if (!isPlainObject(data) || !Array.isArray(data.choices)) {
+    return { error: true, message: 'Invalid response from model.' };
+  }
+  const firstChoice = data.choices[0];
+  const message = isPlainObject(firstChoice) ? firstChoice.message : null;
+  const content = isPlainObject(message) ? message.content : null;
+  if (typeof content !== 'string' || content.trim() === '') {
+    return { error: true, message: 'Invalid response from model.' };
+  }
+
+  const resolvedModel = typeof data.model === 'string' ? data.model.trim() : '';
+  if (resolvedModel === '') {
+    return {
+      error: true,
+      message: 'Gateway response did not include a resolved model id; cannot prove which model ran.',
+    };
+  }
+
+  return {
+    success: true,
+    content: content.trim(),
+    resolved_model: resolvedModel,
+  };
+}
+
+/**
+ * Build the request body. `temperature: 0.3` is a Delphi-review choice: low
+ * enough to keep verdicts reproducible, non-zero so three experts on the same
+ * model are not literally identical runs.
+ */
+function buildChatBody(model, systemPrompt, userPrompt) {
+  return {
     model: model,
     messages: [
       { role: 'system', content: systemPrompt },
@@ -671,6 +790,11 @@ async function callModelAPI(providerConfig, model, systemPrompt, userPrompt, opt
     temperature: 0.3,
     response_format: { type: 'json_object' },
   };
+}
+
+async function callModelAPI(providerConfig, model, systemPrompt, userPrompt, options = {}) {
+  const url = `${providerConfig.base_url.replace(/\/$/, '')}/chat/completions`;
+  const body = buildChatBody(model, systemPrompt, userPrompt);
 
   // Same constant as the runner default: a second literal here silently
   // diverges whenever the default is retuned (#429).
@@ -696,113 +820,18 @@ async function callModelAPI(providerConfig, model, systemPrompt, userPrompt, opt
     }
 
     if (response.status === 429) {
-      // A 429 is not always a transient rate limit. WhaleCloud returns 429 with
-      // `type: "budget_exceeded"` in two distinct non-retryable cases, which a
-      // blind retry cannot clear and would otherwise burn two round-trips before
-      // failing:
-      //   - `error.param === "category_quota"`: the account has no ECONOMY/STANDARD
-      //     quota configured for the model ("需要专项额度...尚未配置") — needs an
-      //     admin to add it.
-      //   - `error.param === "cost_quota"`: the account's daily spending cap is
-      //     exhausted ("今日额度已耗尽...限额: 100.00元") — resets the next day.
-      // Surface which kind it is so the caller knows whether to wait or to request
-      // an admin change, rather than treating both as a generic rate limit.
-      let quotaType = '';
-      try {
-        const body = await response.json();
-        if (body && body.error && body.error.type === 'budget_exceeded') {
-          quotaType = body.error.param === 'cost_quota' ? 'daily budget exhausted' : 'quota not configured';
-        }
-      } catch {
-        // body is not JSON; fall through to the generic rate-limit handling
-      }
-      if (quotaType) {
-        return { error: true, retryable: false, message: `WhaleCloud budget_exceeded: ${quotaType} for this model.` };
-      }
-      return { error: true, retryable: true, message: 'Rate limit exceeded (429).' };
+      return await classifyRateLimitResponse(response);
     }
 
     if (response.status >= 500) {
-      // (#705) Read the provider's structured error body, the same way the 429
-      // branch above does, instead of discarding it.
-      //
-      // Measured on the whalecloud gateway: a prompt containing
-      // `new ProcessBuilder(args).start()` makes the gateway fail in its
-      // response-processing stage and return 500 with
-      //   {"error":{"type":"response_processing_error",
-      //             "param":"non_stream_chat_response","code":"500"}}
-      // The old code threw that away and reported "Server error (500).", which
-      // reads as a transient outage. `type`/`param` are what tell an operator
-      // apart gateway flapping vs. upstream timeout vs. content-triggered
-      // processing failure — three problems with three different responses.
-      //
-      // Retryability is the other half: a content-dependent failure cannot clear
-      // by retrying (the content did not change), so marking it retryable burns
-      // the orchestrator's retry budget on a guaranteed repeat. Only an
-      // explicitly recognised response_processing_error is demoted; every other
-      // 5xx keeps the previous retryable=true, and an unparseable body keeps the
-      // previous behaviour entirely — reading the body must not change the
-      // verdict on its own.
-      let detail = '';
-      let processingError = false;
-      try {
-        const body = await response.json();
-        if (body && body.error && typeof body.error === 'object') {
-          const type = typeof body.error.type === 'string' ? body.error.type : '';
-          const param = typeof body.error.param === 'string' ? body.error.param : '';
-          if (type === 'response_processing_error') {
-            processingError = true;
-          }
-          const parts = [type, param].filter(Boolean);
-          if (parts.length > 0) {
-            detail = ` Provider reported: ${parts.join('/')}.`;
-          }
-        }
-      } catch {
-        // body is not JSON; keep the previous behaviour untouched
-      }
-      if (processingError) {
-        return {
-          error: true,
-          retryable: false,
-          message: `Server error (${response.status}).${detail} This is a content-dependent upstream processing failure, so retrying the same prompt will fail the same way.`,
-        };
-      }
-      return { error: true, retryable: true, message: `Server error (${response.status}).${detail}` };
+      return await classifyServerErrorResponse(response);
     }
 
     if (!response.ok) {
       return { error: true, message: `API request failed (${response.status}). Provider response was not included.` };
     }
 
-    const data = await response.json();
-    if (!isPlainObject(data) || !Array.isArray(data.choices)) {
-      return { error: true, message: 'Invalid response from model.' };
-    }
-    const firstChoice = data.choices[0];
-    const message = isPlainObject(firstChoice) ? firstChoice.message : null;
-    const content = isPlainObject(message) ? message.content : null;
-    if (typeof content !== 'string' || content.trim() === '') {
-      return { error: true, message: 'Invalid response from model.' };
-    }
-
-    // The gateway must echo which model actually served the request. Writing
-    // `null` here used to be tolerated downstream, which let a run that never
-    // resolved a model count as a successful expert call (#423). Fail at the
-    // source instead, so the evidence never records an unverifiable expert.
-    const resolvedModel = typeof data.model === 'string' ? data.model.trim() : '';
-    if (resolvedModel === '') {
-      return {
-        error: true,
-        message: 'Gateway response did not include a resolved model id; cannot prove which model ran.',
-      };
-    }
-
-    return {
-      success: true,
-      content: content.trim(),
-      resolved_model: resolvedModel,
-    };
+    return await readSuccessfulResponse(response);
   } catch (err) {
     if (err instanceof Error && err.name === 'AbortError') {
       return { error: true, retryable: true, message: `Request timed out (${timeoutMs}ms). Raise --timeout-ms or the provider's timeout_ms.` };

package/skills/delphi-review/AGENTS.md

@@ -1,9 +1,9 @@
 # SKILLS/DELPHI-REVIEW KNOWLEDGE BASE
 
-**Generated:** 2026-11-02
-**Commit:** 8a968080
-**Branch:** main
-**Version:** 0.35.23.0
+**Generated:** 2026-11-04
+**Commit:** eb2097b0
+**Branch:** sprint/2026-11-03-02
+**Version:** 0.36.0.0
 
 ## OVERVIEW
 Delphi Consensus Review — multi-round anonymous expert review (≥90% threshold, exactly 3 experts with distinct executable model IDs). Supports design, requirements, and code-walkthrough modes.

package/skills/sprint-flow/AGENTS.md

@@ -1,9 +1,9 @@
 # SKILLS/SPRINT-FLOW KNOWLEDGE BASE
 
-**Generated:** 2026-11-02
-**Commit:** 8a968080
-**Branch:** main
-**Version:** 0.35.23.0
+**Generated:** 2026-11-04
+**Commit:** eb2097b0
+**Branch:** sprint/2026-11-03-02
+**Version:** 0.36.0.0
 
 ## OVERVIEW
 **6-phase** development pipeline (v2.0 compact redesign, Issue #290): PREP → DESIGN → BUILD → VERIFY → SHIP → CLOSE. Phase 3/6 BUILD default build mode is **ralph-loop** (REQ-level iteration, 40-67% token savings vs parallel). HARD-GATE between DESIGN (2/6) and BUILD (3/6): design must pass Delphi review (≥90% consensus) before any coding.

package/skills/test-specification-alignment/AGENTS.md

@@ -1,9 +1,9 @@
 # SKILLS/TEST-SPECIFICATION-ALIGNMENT KNOWLEDGE BASE
 
-**Generated:** 2026-11-02
-**Commit:** 8a968080
-**Branch:** main
-**Version:** 0.35.23.0
+**Generated:** 2026-11-04
+**Commit:** eb2097b0
+**Branch:** sprint/2026-11-03-02
+**Version:** 0.36.0.0
 
 ## OVERVIEW
 Test-Specification Alignment Engine — two-stage validation ensuring tests accurately reflect requirements and design specs.