@sun-asterisk/sungen 3.2.21-beta.2 → 3.2.21-beta.4

package/src/harness/flow-contract.ts

@@ -40,6 +40,11 @@ export interface FlowContract {
   /** The mutated collection (cart, order, application …) — enables regression dims. */
   stateful?: string;
   budgets?: Record<string, number>;
+  /** External-system legs (owned by another team/vendor) — ISTQB System INTEGRATION Testing
+   *  scope (#580 P10). Scenarios touching these namespaces are classified SIT. */
+  external?: Array<{ name: string; owner?: string; screens: string[] }>;
+  /** This flow is release-critical: Final Inspection expects a @golden scenario here (P9). */
+  golden?: boolean;
 }
 
 export interface FlowQualityResult {
@@ -60,6 +65,9 @@ export interface FlowQualityResult {
   phaseRatio: number;
   /** Cross-namespace transitions followed by an assertion / all transitions. */
   handoffs: { total: number; asserted: number; ratio: number };
+  /** ISTQB SIT classification (#580 P10): scenarios whose steps touch an external-system
+   *  namespace declared in the contract's `external:` block. */
+  sit: Array<{ name: string; external: string; mockOnly: boolean }>;
 }
 
 const DEFAULT_PHASES = ['HP', 'ER', 'EH'];
@@ -100,6 +108,16 @@ export function loadFlowContract(unitDir: string): { contract: FlowContract | nu
       phases,
       stateful: raw.stateful !== undefined ? String(raw.stateful).toLowerCase() : undefined,
       budgets: (raw.budgets && typeof raw.budgets === 'object') ? raw.budgets as Record<string, number> : undefined,
+      external: Array.isArray(raw.external)
+        ? (raw.external as Array<Record<string, unknown>>)
+            .filter((e) => e && typeof e === 'object' && e.name)
+            .map((e) => ({
+              name: String(e.name),
+              owner: e.owner !== undefined ? String(e.owner) : undefined,
+              screens: Array.isArray(e.screens) ? (e.screens as unknown[]).map((x) => String(x).toLowerCase()) : [],
+            }))
+        : undefined,
+      golden: raw.golden === true,
     },
     errors: [],
   };
@@ -139,7 +157,7 @@ export function flowQuality(unitDir: string, scenarios: ScenarioInfo[]): FlowQua
   const neutral: FlowQualityResult = {
     hasContract: false, errors, outcomeProven: false, outcomeManualOnly: false,
     offGoal: [], offGoalRatio: 0, offGoalCategories: [],
-    phases: [], phaseRatio: 1, handoffs: { total: 0, asserted: 0, ratio: 1 },
+    phases: [], phaseRatio: 1, handoffs: { total: 0, asserted: 0, ratio: 1 }, sit: [],
   };
   if (!contract) return neutral;
 
@@ -202,12 +220,26 @@ export function flowQuality(unitDir: string, scenarios: ScenarioInfo[]): FlowQua
   }
   const handoffs = { total, asserted, ratio: total ? asserted / total : 1 };
 
+  // --- SIT classification (#580 P10): a scenario whose steps touch an external-system
+  // namespace belongs to the System INTEGRATION group the QA matrix keeps separate. When
+  // that scenario is also verified only against mocks, its pass says nothing about the
+  // real vendor behaviour — the exit criteria the QA doc holds open (Pass (Mocked)).
+  const MOCK_STEP = /\[[^\]]+\]\s+mock\s+(?:is\s+active|called)\b/i;
+  const sit: FlowQualityResult['sit'] = [];
+  for (const leg of contract.external ?? []) {
+    const legScreens = new Set(leg.screens);
+    for (const s of scenarios) {
+      if (!namespacesInOrder(s).some((ns) => legScreens.has(ns))) continue;
+      sit.push({ name: s.name.slice(0, 80), external: leg.name, mockOnly: MOCK_STEP.test(s.stepsText) });
+    }
+  }
+
   return {
     hasContract: true, contract, errors: [],
     outcomeProven, outcomeManualOnly,
     offGoal: offGoalScenarios.map((s) => s.name.slice(0, 80)),
     offGoalRatio, offGoalCategories,
-    phases, phaseRatio, handoffs,
+    phases, phaseRatio, handoffs, sit,
   };
 }
 

package/src/orchestrator/templates/ai-src/commands/add-flow.md

@@ -132,6 +132,11 @@ outcome:
 value: "The customer has paid; the shop has a new order"
 phases: [HP, ER, EH]          # journey phases (default); add UI only if the flow owns UI states
 stateful: cart                # the mutated collection, if any — enables regression-depth dims
+golden: true                  # optional — release-critical: Final Inspection expects @golden scenarios here
+external:                     # optional — legs owned by another team/vendor (System INTEGRATION Testing)
+  - name: payment-gateway
+    owner: vendor-x
+    screens: [payment]        # the flow namespaces that leg passes through
 ```
 
 **A filled contract is an INPUT to generation — never an output.** Like `test-viewpoint.md`,

package/src/orchestrator/templates/ai-src/commands/run-test.md

@@ -7,6 +7,29 @@ claude-tools: "Read, Grep, Bash, Glob, Edit, Write, AskUserQuestion, mcp__playwr
 copilot-tools: "[read, execute, edit, vscode/askQuestions, playwright/*, appium/*]"
 codex-trigger: "Run when the user asks to RUN, execute, or compile tests, generate selectors.yaml, or run tests. Step 4. Do NOT use for authoring/creating new test cases."
 ---
+## ⛔ HARD RULE — the transition INTO this run is a tool call, never prose
+
+A QA field report: the user picked "Run test" from create-test's hand-back, and the session
+answered with a BRIEFING — missing selector, expected reds, "run under Node 22" — written as
+"Before you do…", then stopped. Correct facts, wrong role: those are conditions YOU handle
+inside the run, not reasons to stop and hand the work back.
+
+- The first thing this command produces is a **tool call** (platform detection, preflight,
+  compile — whatever comes first). Never open with a plan and end the turn.
+- A **missing selector** goes to the selector-generation/fix step — that is what this command
+  is FOR.
+- **Expected-red scenarios** (@known-defect asserting a live defect) stay red; note them in
+  the results summary, never "fix" them and never stop for them.
+- **Runtime selection is yours**: check `node -v` first. If the major version is ≥ 23 and
+  Playwright browser runs are known-broken on it, select Node 22 yourself when available —
+  `export PATH="$HOME/.nvm/versions/node/$(ls $HOME/.nvm/versions/node | grep '^v22' | tail -1)/bin:$PATH"`
+  — and say so in one line. Only if NO compatible Node exists do you stop, with the exact
+  install command as the hand-back.
+- Ending this run follows the same law as create-test: the LAST action is the next-step
+  hand-back (the AskUserQuestion in "After showing results"), no matter how the run went.
+
+---
+
 ## Role
 
 You are a **Senior Developer**.

package/src/orchestrator/templates/ai-src/skills/sungen-tc-generation/SKILL.md

@@ -619,6 +619,14 @@ scenarios differ only in data. **Mocked dependencies**: a flow scenario using `@
 delivered as *Pass (Mocked)* — verified handling logic, not the real dependency; the delivery's
 External Dependency Tracking table lists it until re-verified real.
 
+**Release selection & external legs**: when the contract declares `golden: true`, tag the
+happy-path scenario(s) that prove the outcome with **`@golden`** — that is the set
+`sungen inspect` (Final Inspection, Go/No-Go) runs before a release; `GOLDEN-MISSING` fires
+until it exists, and a @golden scenario that passes only against mocks BLOCKS the release.
+When the contract declares `external:` legs (another team/vendor's system), scenarios touching
+those namespaces are the **System INTEGRATION** group — keep their oracles about the boundary
+(contract/format/handoff), and expect `SIT-MOCK-ONLY` until they are re-verified real.
+
 
 > **Auto-detect**: if path is `qa/flows/<name>/` → use this section. Skip Steps 1–4 above.