sad-mcp 2.3.0 → 2.3.3

package/dist/tools.js

@@ -283,7 +283,7 @@ export function registerToolHandlers(server) {
             },
             {
                 name: "interview_stakeholder",
-                description: "Roleplay a stakeholder from the course's running campus-cafeteria case so a student can practise requirements-elicitation interviewing (asking 'why', 5-Whys, separating symptoms from root causes, spotting contradictions). Calling this turns YOU into the character: stay fully in character, in Hebrew first person, and reveal root causes only when the student asks good questions. Currently available: 'shimon' (שמעון, the cafeteria manager who initiated the project). The teacher steers with bracketed commands like [צא מהדמות]/[out of character] or [רמז]. Call once to summon the character, then answer every following message in character until released.",
+                description: "Roleplay a stakeholder from the course's running campus-cafeteria case so a student can practise requirements-elicitation interviewing (asking 'why', 5-Whys, separating symptoms from root causes, spotting contradictions). Calling this turns YOU into the character: stay fully in character, in Hebrew first person, and reveal root causes only when the student asks good questions. Currently available: 'shimon' (שמעון, the cafeteria manager who initiated the project). The teacher steers with bracketed commands like [צא מהדמות]/[out of character] or [רמז]. A student working alone ends by typing [סיכום] (or saying they're done) to get a formative, ungraded coaching debrief on their interview — coverage of the root causes, questioning technique, what they missed and how, with an option to go back in ([חזור לדמות]). Call once to summon the character, then answer every following message in character until released.",
                 inputSchema: {
                     type: "object",
                     properties: {

package/dist/usecase/validate.js

@@ -348,7 +348,7 @@ export function validateModel(model) {
                 const isHuman = !pa || pa.actorType !== "system";
                 const wfMissing = typeof wf !== "string" || wf.trim() === "";
                 if (isHuman && wfMissing) {
-                    err("wireframe-missing", `${path}.wireframe`, `UC "${id}" has a human primary actor ("${primaryActor}") but no wireframe. Every human-initiated UC requires a wireframe per §WF. Add one, or explicitly use a placeholder describing what info is missing.`);
+                    warn("wireframe-missing", `${path}.wireframe`, `UC "${id}" has a human primary actor ("${primaryActor}") but no wireframe. Wireframes are opt-in per §WF — add one only if the user requested wireframes.`);
                 }
             }
             if (typeof wf === "string" && wf.length > 0) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sad-mcp",
-  "version": "2.3.0",
+  "version": "2.3.3",
   "description": "MCP server for Software Analysis and Design course materials at BGU",
   "type": "module",
   "bin": {
@@ -8,7 +8,8 @@
   },
   "files": [
     "dist",
-    "skills"
+    "skills",
+    "!**/*conflicted copy*"
   ],
   "scripts": {
     "build": "tsc",

package/skills/interview-stakeholder/SKILL.md

@@ -13,8 +13,9 @@ you are**. This section tells you **how to play the role**. Follow both exactly.
 1. **Stay fully in character.** From now until the student explicitly releases you,
    you ARE this person. Speak in **first person, in Hebrew**, in the character's
    voice. Never speak as "Claude", never describe the character in third person,
-   never narrate stage directions. If the student writes in English, you may answer
-   in English, but stay in character.
+   never narrate stage directions, and never emit bracketed notes or any commentary
+   about your own answers (see "What leaves your mouth" below). If the student writes
+   in English, you may answer in English, but stay in character.
 
 2. **You are being interviewed — you do NOT run the interview.** Answer the question
    that was asked and then stop. Do **not** volunteer a tidy, organised summary of
@@ -49,6 +50,27 @@ you are**. This section tells you **how to play the role**. Follow both exactly.
 7. **Stay human and brief.** Two to five sentences per answer, usually. Use the
    character's register — colloquial, a little defensive, busy. Not a polished memo.
 
+## What leaves your mouth — nothing but the character
+
+Everything you output during the interview is **only the character's spoken words, in
+Hebrew**. Nothing else reaches the student:
+
+- **No brackets of your own.** Bracketed text `[...]` is **input only** — it is how the
+  teacher or student talks *to* you. You never *produce* a bracketed note. If you catch
+  yourself opening a `[` to write a stage direction, stop.
+- **No director's notes, no strategy narration.** Never tell the student what kind of
+  question they just asked, how much depth you're deciding to give, or what you're
+  choosing to reveal or hold back. That reasoning stays **silent**. For example, you must
+  NEVER emit anything like «[שאלת ה"למה" הראשונה. תן לו קצת עומק — אבל לא הכל בבת אחת,
+  ובלי לסכם לו יפה.]» — the student sees only Shimon's reply, never the thinking behind it.
+- **No labels or meta.** No "as Shimon:", no "(חושב)", no summary of the situation, no
+  coaching. Just say what the character would say, then stop.
+
+The rules in this file and the *italic bracketed notes* in the persona are for your eyes
+only — act on them, never voice them. The single exception is the debrief: when the
+student explicitly ends the interview (see below), you drop the role entirely and speak
+as the coach.
+
 ## How the teacher steers the session (out-of-character commands)
 
 The teacher may send bracketed meta-instructions. These are NOT part of the
@@ -71,6 +93,55 @@ On the very first turn, give a short, in-character greeting (1–2 sentences) th
 fits the persona — busy, a little impatient — and invite the first question. Do not
 dump information. Then wait.
 
+## Ending the interview — the debrief (student self-feedback)
+
+This tool is usually used by a student working **alone**, with no teacher in the
+room. When the student signals they are **done and want feedback** — either by
+typing `[סיכום]` (also accept `[משוב]` / `[debrief]`) or by clearly saying in plain
+language that they've finished and want to know how they did ("סיימתי, איך הלך?",
+"תן לי משוב על הראיון", "how did I do?") — **stop role-playing and answer as a SAD
+course coach** (as Claude, not the character). Trigger this ONLY on a clear, explicit
+end-and-feedback signal; an ordinary interview question is *not* a debrief request —
+answer it in character.
+
+The debrief is **formative and ungraded** — its only purpose is to help the student
+learn requirements-elicitation by reflecting on the interview they just ran. Never
+give a numeric grade or a pass/fail. Write it in **Hebrew**, addressed to the student
+(פנייה ישירה), warm, specific, and practical — a coach, not an examiner. Review the
+**entire conversation so far** — every question the student asked and every answer the
+character gave — and build the feedback from that transcript, quoting the student's
+own words. Cover, in this order:
+
+1. **מה חשפת (coverage).** Build a checklist from the persona's *DEEP* facts and its
+   *contradictions* — treat each as one root cause / insight the interview was meant to
+   surface. Mark which the student actually reached and which stayed buried. Frame it
+   as progress, not a score (e.g. "הגעת ל-4 מתוך 6 שורשי הבעיה"). For each one reached,
+   name the moment the student earned it.
+
+2. **איך תשאלת (technique).** Diagnose the elicitation skill with concrete examples
+   from the transcript: did they ask **"למה"** and follow up (5-Whys) or accept the
+   first answer? Did they **push on contradictions**? Did they **ask for evidence /
+   numbers** instead of taking claims at face value? Did they **separate symptom from
+   root**? Did they **filter noise** or chase the red herrings the character mixed in?
+   Praise what worked by quoting it; name what was missing by quoting where it slipped.
+
+3. **מה פספסת ואיך היית מגיע לזה (the teachable misses).** For each buried root cause,
+   do NOT just hand over the answer — show the **question that would have opened it**,
+   tied to the student's own words (e.g. «כשהוא אמר 'חסר לנו כוח אדם', שאלה כמו 'ומה
+   קרה כשהוספת עובד?' הייתה חושפת ש…»). Teach the move, not just the fact.
+
+4. **קדימה (forward link).** In a line or two, connect the root causes the student
+   uncovered to the next step of the analysis (the requirements / use-cases that follow
+   from them), so the interview feels like real analysis work.
+
+5. **רוצה לנסות שוב? (retry).** Because this is practice, end by inviting the student
+   to go back and probe what they missed: «רוצה לחזור ולתשאל אותו על מה שפספסת? כתוב
+   `[חזור לדמות]` ונמשיך מאותה נקודה.» If they do, resume the character in full, with
+   the whole prior interview still in mind.
+
+Keep the debrief tight and readable — it doubles as the artifact the student hands in,
+so make it clean enough to copy as-is.
+
 ---
 
 ## PERSONA

package/skills/uml-class-diagram/NOTATION.md

@@ -5,7 +5,7 @@ Source lectures: שיעורים 6-7 תרשים מחלקות.pptx, ניתוץ ש
 ## Elements Taught
 
 - **Classes** — three compartments: name, attributes, operations
-- **Enumerations** — `«enumeration»` stereotype; use when: closed list, textual values, ≤~20 items. Do NOT use for open-ended or numeric choices
+- **Enumerations** — `«enumeration»` stereotype; use when: closed list, textual values, ≤~20 items. Do NOT use for open-ended or numeric choices. Draw as an **unconnected box** next to the class that uses it — no dependency or association line to the class.
 - **Packages (חבילה)** — grouping mechanism for related classes; taught as an organizational concept
 - **Abstract classes / interfaces** — not explicitly covered in lectures; avoid adding unless user asks
 
@@ -69,7 +69,7 @@ Source lectures: שיעורים 6-7 תרשים מחלקות.pptx, ניתוץ ש
 - Strict LEFT/CENTER/RIGHT zone layout — lectures don't prescribe this
 - Interactive composition-toggle panel — not a teaching concept
 - Enumerations placed only in a "RIGHT zone" — not explicitly taught
-- No dependency lines from enums to classes — not mentioned; lectures use dependencies normally
+- Enumerations are drawn as **unconnected boxes** next to their using class — the course does **not** draw a dependency (or any) line from a class to an enum; the attribute type reference is the only link (instructor rule, 2026)
 - Association class connected to midpoint — taught in principle but not the dashed-line-to-midpoint rule specifically
 
 ### Rules lectures teach that SKILL.md omits or misrepresents

package/skills/uml-class-diagram/SKILL.md

@@ -66,6 +66,7 @@ Two common false positives:
 - Use enumerations when: closed list, textual values, ≤~20 items, will not change often
 - Do NOT use for open-ended, numeric, or frequently changing value sets
 - Place enumerations adjacent to the class that uses them, not in a fixed zone
+- **Do NOT connect an enumeration to a class with any line** (no dependency, no association). The attribute type reference (`status : RegistrationStatus`) is the only link. `type: 'dep'` in RELS is not used.
 
 ### Packages (חבילה)
 - Draw as a tabbed rectangle enclosing related classes
@@ -83,11 +84,11 @@ Two common false positives:
 | Aggregation | Solid | Hollow diamond at whole | "has-a", part can exist independently |
 | Composition | Solid | Filled diamond at whole | Part cannot exist without whole |
 | Generalization | Solid | Hollow triangle at parent | True is-a; subtypes have different attributes/ops |
-| Dependency | Dashed | Open arrow | **ONLY** when a class references an enumeration type as an attribute type. Never between two regular classes — use plain association instead |
+| Dependency | Dashed | Open arrow | **Not used in this course's class diagrams.** Enumerations are NOT connected to their using class by any line (see §2 / §3 CRITICAL). Never draw a dependency between two regular classes either — use a plain association. |
 
 > **CRITICAL — domain diagram association rules:**
 > - Plain association (──): the default for every class-to-class relationship. No arrowheads.
-> - Dependency (---→): only for enumeration usage. Never on class-to-class relationships.
+> - Dependency (---→): **not used at all.** Enumerations are drawn as unconnected boxes placed next to their using class — no line of any kind. The attribute type reference (`status : RegistrationStatus`) is the only link. Do not draw a dependency between two regular classes either.
 > - Directed association (──→): never in a domain or analysis diagram.
 
 **Multiplicity at both ends of every association**: `1`, `0..1`, `1..*`, `0..*`. Never leave one end unlabeled.
@@ -484,7 +485,7 @@ When in doubt, use the male form.
 - [ ] Hebrew names use male form
 - [ ] **No raw SVG class boxes** — class boxes are rendered by `svgBox()` from `CLASSES` data, not hand-written SVG
 - [ ] **No arrowheads on plain associations** — `type: 'assoc'` in RELS produces no marker; directed association never appears in domain/analysis diagrams
-- [ ] **Dependency (---→) only for enum usage** — `type: 'dep'` only when a class references an enum type; never between two regular classes
+- [ ] **No dependency lines at all** — enumerations are unconnected boxes placed near their using class (no `type: 'dep'`); dependency is not used in this course's class diagrams, and never between two regular classes
 - [ ] **`<html>` has no `dir="rtl"`** — SVG coordinates are LTR; page language does not affect SVG rendering
 - [ ] **`boxH()` / `boxW()` from §9d engine used** — never hardcode box dimensions in data or SVG
 - [ ] **Attribute/operation rows: `text-anchor="start"` at `x = box.x + 6`** — enforced by engine; do not override

package/skills/uml-use-case-diagram/SKILL.md

@@ -521,6 +521,7 @@ If neither trigger fires, produce a single tab. Do not split on gut feeling.
 - One tab per actor group or per functional area.
 - **Cross-tab connections:** draw the stub on each side with the partner's name and a `(→ Tab N)` label. Do NOT try to route a line across tabs.
 - Each tab has its own complete SVG (its own boundary, actors, ellipses, lines).
+- **Shared actors (an actor that owns UCs on more than one tab) MUST have their own `<g id="actor-group-{id}">` figure emitted inside EVERY tab's SVG where they appear — not only the first tab.** An actor's stick-figure group and its association line must live in the same SVG. If a tab contains a `data-conn-from="{actorId}"` line but no matching `actor-group-{actorId}` figure in that same SVG, `fixLayout` places the line correctly but there is nothing to draw at the actor end — the association renders as a line into empty space. (`fixLayout` scopes its DOM lookups per-SVG, so the same `actor-group-{id}` id may repeat across tab SVGs; each tab still needs its own figure element.)
 - Each tab has a visible **split-rationale line** below the tab bar. Use whichever trigger actually fired:
   - `"Split by UC count: 12 UCs > 8 threshold"` or
   - `"Split by actor groups: [group A] / [group B] — disjoint responsibilities"`.
@@ -942,4 +943,5 @@ Briefly report: actor count, use case count, include/extend count, whether split
 - [ ] `showDiagram(index)` is defined in every generated file, even single-tab diagrams (so tab switching is wired if splitting is ever added).
 - [ ] `fixLayout` uses adaptive column X (widens boundary if needed so left/center/right ellipses never overlap horizontally) AND expands viewBox width so right-side actors are not clipped.
 - [ ] If split: each tab has a split-rationale line citing the actual trigger that fired (count > 8, or 2+ disjoint actor groups); `showDiagram` and per-tab `fixLayout` wired per §11.
+- [ ] If split: every actor in a tab's `diagramLayouts[i].actors` has a matching `<g id="actor-group-{id}">` figure inside THAT tab's `<svg>`. A shared actor (owning UCs on multiple tabs) is duplicated into each tab's SVG — never emit its figure in only the first tab, or its association renders as a line into empty space.
 - [ ] `diagramModel` defined per `model-shape.md`; VP export button present and wired to `exportXMI()`.

package/dist/usecase/index (DESKTOP-GQHOSST's conflicted copy 2026-04-19).d.ts

@@ -1,15 +0,0 @@
-export interface ValidationIssue {
-    path: string;
-    code: string;
-    message: string;
-}
-export type ValidateResult = {
-    ok: true;
-    warnings: ValidationIssue[];
-} | {
-    ok: false;
-    issues: ValidationIssue[];
-    warnings: ValidationIssue[];
-};
-export declare function formatIssues(issues: ValidationIssue[]): string;
-export declare function parseAndValidate(jsonText: string): ValidateResult;

package/dist/usecase/index (DESKTOP-GQHOSST's conflicted copy 2026-04-19).js

@@ -1,218 +0,0 @@
-// Validator for use-case diagramModel JSON (kind: 'use-case').
-// Called by uml_usecase_validate_model MCP tool in tools.ts.
-// Returns all errors and warnings at once so an LLM can self-correct in one pass.
-export function formatIssues(issues) {
-    if (issues.length === 0)
-        return "(none)";
-    return issues.map(i => `- [${i.code}] ${i.path}: ${i.message}`).join("\n");
-}
-// ── Helpers ───────────────────────────────────────────────────────────────
-function hasHebrew(s) {
-    return /[\u0590-\u05FF\uFB1D-\uFB4F]/.test(s);
-}
-const SEND_ONLY_PREFIXES = [
-    /^שליחת /i, /^הודעה ל/i, /^הודעת /i, /^משלוח /i,
-    /^Send /i, /^Print /i, /^Notify /i,
-];
-const PHYSICAL_VERB_PREFIXES = [
-    /^ביצוע /i, /^הכנת /i, /^ספירת /i, /^מסירת /i,
-    /^תשלום ב/i, /^Perform /i, /^Execute /i,
-];
-const UNSAFE_WF = [
-    /<script\b/i, /\son\w+\s*=/i, /<iframe\b/i,
-    /src\s*=\s*["']https?:/i, /href\s*=\s*["']https?:/i,
-    /@import\b/i, /<style\b/i,
-];
-function wireframeSafe(html) {
-    return !UNSAFE_WF.some(rx => rx.test(html));
-}
-// ── Main validator ────────────────────────────────────────────────────────
-export function parseAndValidate(jsonText) {
-    let raw;
-    try {
-        raw = JSON.parse(jsonText);
-    }
-    catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        return { ok: false, warnings: [], issues: [{ path: "(root)", code: "invalid-json", message: `JSON parse failed: ${msg}` }] };
-    }
-    const errors = [];
-    const warnings = [];
-    const err = (path, code, message) => errors.push({ path, code, message });
-    const warn = (path, code, message) => warnings.push({ path, code, message });
-    const m = raw;
-    if (!m || typeof m !== "object") {
-        err("(root)", "not-object", "model must be an object");
-        return { ok: false, issues: errors, warnings };
-    }
-    if (m["kind"] !== "use-case")
-        err("kind", "wrong-kind", `expected "use-case", got "${m["kind"]}"`);
-    const parts = Array.isArray(m["parts"]) ? m["parts"] : [];
-    if (!Array.isArray(m["parts"]) || parts.length === 0)
-        err("parts", "missing-parts", "parts array is required and must be non-empty");
-    // Narrative field checks at model level
-    for (const [key, val] of [["assumptions", m["assumptions"]], ["openQuestions", m["openQuestions"]]]) {
-        if (Array.isArray(val)) {
-            val.forEach((item, i) => {
-                if (typeof item === "string" && item.length > 0 && !hasHebrew(item)) {
-                    err(`${key}[${i}]`, "narrative-non-hebrew", `${key}[${i}] contains no Hebrew characters`);
-                }
-            });
-        }
-    }
-    for (const [pi, part] of parts.entries()) {
-        const pp = `parts[${pi}]`;
-        const elements = Array.isArray(part["elements"]) ? part["elements"] : [];
-        const relationships = Array.isArray(part["relationships"]) ? part["relationships"] : [];
-        const actorIds = new Set();
-        const ucIds = new Set();
-        // Index actors and UCs
-        for (const el of elements) {
-            if (el["kind"] === "actor" && typeof el["id"] === "string")
-                actorIds.add(el["id"]);
-            if (el["kind"] === "useCase" && typeof el["id"] === "string")
-                ucIds.add(el["id"]);
-        }
-        // Build relationship indexes
-        const includesByTarget = new Map(); // targetUcId → [baseUcId...]
-        const assocsByUc = new Map(); // ucId → [actorId...]
-        const includeSet = new Set(); // "from:to"
-        let totalIncludeExtend = 0;
-        for (const rel of relationships) {
-            if (rel["kind"] === "include") {
-                const from = String(rel["from"] ?? ""), to = String(rel["to"] ?? "");
-                const list = includesByTarget.get(to) ?? [];
-                list.push(from);
-                includesByTarget.set(to, list);
-                includeSet.add(`${from}:${to}`);
-                totalIncludeExtend++;
-            }
-            if (rel["kind"] === "extend")
-                totalIncludeExtend++;
-            if (rel["kind"] === "actorAssoc") {
-                const ucId = String(rel["ucId"] ?? ""), actorId = String(rel["actorId"] ?? "");
-                const list = assocsByUc.get(ucId) ?? [];
-                list.push(actorId);
-                assocsByUc.set(ucId, list);
-            }
-        }
-        if (totalIncludeExtend > 2)
-            warn(`${pp}.relationships`, "too-many-include-extend", `${totalIncludeExtend} include+extend relationships found — more than 2 is almost always wrong`);
-        // Check «include» targets
-        for (const [targetId, bases] of includesByTarget) {
-            if (bases.length < 2) {
-                err(`${pp}.relationships[include→${targetId}]`, "single-incoming-include", `UC "${targetId}" has exactly one incoming «include» (from "${bases[0]}") — fold it into the parent instead`);
-            }
-            if (assocsByUc.has(targetId)) {
-                err(`${pp}.relationships[include→${targetId}]`, "include-target-has-assoc", `UC "${targetId}" is an «include» target but also has direct actor associations — it cannot be both`);
-            }
-        }
-        // Check UC elements
-        for (const el of elements) {
-            if (el["kind"] !== "useCase")
-                continue;
-            const id = String(el["id"] ?? "");
-            const name = String(el["name"] ?? "");
-            const ePath = `${pp}.elements[id=${id}]`;
-            // Send-only check
-            if (SEND_ONLY_PREFIXES.some(rx => rx.test(name))) {
-                err(ePath, "send-only-uc", `UC "${id}" name "${name}" appears to be send-only — fold the send step into the UC that decided to send`);
-            }
-            // Physical verb check
-            if (PHYSICAL_VERB_PREFIXES.some(rx => rx.test(name))) {
-                warn(ePath, "physical-verb", `UC "${id}" name "${name}" uses a physical verb — wrap with a system verb (רישום, הזנה, עדכון, סימון…)`);
-            }
-            // Primary actor
-            const primaryActor = el["primaryActor"];
-            if (!primaryActor) {
-                err(ePath, "missing-primary-actor", `UC "${id}" has no primaryActor`);
-            }
-            else {
-                if (!actorIds.has(primaryActor)) {
-                    err(ePath, "unknown-primary-actor", `UC "${id}" primaryActor "${primaryActor}" is not in actors list`);
-                }
-                // Check that an actorAssoc with role=initiator exists for this actor↔UC pair
-                const initiatorAssoc = relationships.find(r => r["kind"] === "actorAssoc" && r["ucId"] === id && r["actorId"] === primaryActor && r["role"] === "initiator");
-                if (!initiatorAssoc) {
-                    err(ePath, "primary-not-initiator", `UC "${id}" primaryActor "${primaryActor}" has no actorAssoc with role="initiator"`);
-                }
-            }
-            // Narrative fields — must contain Hebrew
-            for (const [key, val] of [["description", el["description"]]]) {
-                if (typeof val === "string" && val.length > 0 && !hasHebrew(val)) {
-                    err(`${ePath}.${key}`, "narrative-non-hebrew", `${key} contains no Hebrew characters`);
-                }
-            }
-            for (const [key, arr] of [["preconditions", el["preconditions"]], ["postconditions", el["postconditions"]]]) {
-                if (!Array.isArray(arr) || arr.length === 0) {
-                    warn(`${ePath}.${key}`, `missing-${key}`, `UC "${id}" has no ${key}`);
-                }
-                else {
-                    arr.forEach((item, i) => {
-                        if (typeof item === "string" && item.length > 0 && !hasHebrew(item)) {
-                            err(`${ePath}.${key}[${i}]`, "narrative-non-hebrew", `${key}[${i}] contains no Hebrew characters`);
-                        }
-                    });
-                }
-            }
-            // User stories
-            const userStories = Array.isArray(el["userStories"]) ? el["userStories"] : [];
-            if (userStories.length < 2) {
-                warn(`${ePath}.userStories`, "few-user-stories", `UC "${id}" has ${userStories.length} user stor${userStories.length === 1 ? "y" : "ies"} — cover every distinct stakeholder goal`);
-            }
-            // Scenarios / flow steps
-            const scenarios = Array.isArray(el["scenarios"]) ? el["scenarios"] : [];
-            if (scenarios.length === 0) {
-                err(`${ePath}.scenarios`, "missing-scenarios", `UC "${id}" has no scenarios`);
-            }
-            for (const [si, sce] of scenarios.entries()) {
-                const sPath = `${ePath}.scenarios[${si}]`;
-                const flow = Array.isArray(sce["flow"]) ? sce["flow"] : [];
-                if (flow.length === 0) {
-                    err(`${sPath}.flow`, "empty-flow", `scenario "${sce["id"]}" in UC "${id}" has no flow steps`);
-                }
-                const flowLen = flow.length;
-                for (const [fi, step] of flow.entries()) {
-                    const stepPath = `${sPath}.flow[${fi}]`;
-                    if (step["kind"] === "actor" && typeof step["actor"] === "string" && !actorIds.has(step["actor"])) {
-                        err(stepPath, "unknown-actor-ref", `flow step references unknown actor id "${step["actor"]}"`);
-                    }
-                    if (step["kind"] === "include") {
-                        const targetUc = String(step["uc"] ?? "");
-                        if (!ucIds.has(targetUc)) {
-                            err(stepPath, "unknown-uc-ref", `«include» step references unknown UC id "${targetUc}"`);
-                        }
-                        else if (!includeSet.has(`${id}:${targetUc}`)) {
-                            err(stepPath, "include-step-no-relationship", `«include» step references "${targetUc}" but no include relationship exists from "${id}" to "${targetUc}"`);
-                        }
-                    }
-                    if (typeof step["text"] === "string" && step["text"].length > 0 && !hasHebrew(step["text"])) {
-                        err(stepPath, "narrative-non-hebrew", "flow step text contains no Hebrew characters");
-                    }
-                }
-                const extensions = Array.isArray(sce["extensions"]) ? sce["extensions"] : [];
-                for (const [ei, ext] of extensions.entries()) {
-                    const extPath = `${sPath}.extensions[${ei}]`;
-                    if (typeof ext["at"] === "number" && (ext["at"] < 1 || ext["at"] > flowLen)) {
-                        err(extPath, "invalid-extension-at", `extension "at" value ${ext["at"]} is out of range (flow has ${flowLen} steps)`);
-                    }
-                    if (typeof ext["text"] === "string" && ext["text"].length > 0 && !hasHebrew(ext["text"])) {
-                        err(extPath, "narrative-non-hebrew", "extension text contains no Hebrew characters");
-                    }
-                }
-            }
-            // Wireframe safety (only when present and non-empty)
-            if (typeof el["wireframe"] === "string" && el["wireframe"].length > 0) {
-                if (!wireframeSafe(el["wireframe"])) {
-                    err(`${ePath}.wireframe`, "unsafe-wireframe", `wireframe for UC "${id}" contains forbidden patterns (script/on*/iframe/external URL/@import/style)`);
-                }
-                if (!hasHebrew(el["wireframe"])) {
-                    err(`${ePath}.wireframe`, "wireframe-non-hebrew", `wireframe for UC "${id}" contains no Hebrew characters`);
-                }
-            }
-        }
-    }
-    if (errors.length > 0)
-        return { ok: false, issues: errors, warnings };
-    return { ok: true, warnings };
-}

package/dist/usecase/index.d (DESKTOP-GQHOSST's conflicted copy 2026-04-19).ts

@@ -1,15 +0,0 @@
-export interface ValidationIssue {
-    path: string;
-    code: string;
-    message: string;
-}
-export type ValidateResult = {
-    ok: true;
-    warnings: ValidationIssue[];
-} | {
-    ok: false;
-    issues: ValidationIssue[];
-    warnings: ValidationIssue[];
-};
-export declare function formatIssues(issues: ValidationIssue[]): string;
-export declare function parseAndValidate(jsonText: string): ValidateResult;