@h2loop/autosar 1.5.4 → 1.7.0

package/python/ecuc_engine/rules/chain.py

@@ -0,0 +1,288 @@
+"""Completeness of the communication chain: what a message / signal needs in every layer and file.
+
+Consistency rules (overlap, ranges, extract layout) do not see an UNFINISHED change: a new message with no PduR
+route or no CanIf PDU, a signal added to the extract but not to Com, a ComSignal attached to no I-PDU, an I-PDU
+triggered on a channel but carried by no frame. These rules do, so the verify -> fix loop has something to fix.
+Nothing is keyed by names: navigation is by ECUC definition (module-relative) and by reference.
+"""
+from __future__ import annotations
+
+from . import rule
+from .system import mappings_for, system_ipdus
+
+CITE_ROUTE = ("SWS_PduR (an I-PDU handled by Com is routed by a PduR routing path to/from a lower-layer PDU); "
+              "SWS_CanIf CanIfTxPduRef/CanIfRxPduRef; Com ComPduIdRef")
+CITE_SIG = "Com ComIPduSignalRef (each ComSignal belongs to an I-PDU)"
+CITE_EXTRACT = "System Template ISignalToIPduMapping vs ECUC_Com ComSignal (the ECU configuration implements the extract)"
+CITE_TRIG = "System Template PduTriggering/FrameTriggering/ISignalTriggering (what is sent on a channel is triggered)"
+UPPER = {"Com", "PduR", "EcuC", "EcucValueCollection"}
+
+
+def _module(ctx, e) -> str:
+    return ctx.module_of(e).name
+
+
+def _pdu_users(ctx) -> dict:
+    """EcuC Pdu path -> {module names of containers that reference it}."""
+    users: dict = {}
+    for path, group in ctx.p.by_path.items():
+        e = group[0]
+        if e.kind != "container":
+            continue
+        mod = _module(ctx, e)
+        for g in group:
+            for pv in g.params:
+                if pv.is_ref and pv.value:
+                    users.setdefault(pv.value.strip(), set()).add(mod)
+    return users
+
+
+def _routes(ctx) -> dict:
+    """EcuC Pdu path -> set of EcuC Pdu paths at the other end of a PduR routing path."""
+    out: dict = {}
+    for rp in ctx.containers("PduR/PduRRoutingPaths/PduRRoutingPath"):
+        src = ctx.target(ctx.value(rp, "PduRSrcPduRRef"))
+        spdu = ctx.target(ctx.value(src, "PduRSrcPduRef")) if src is not None else None
+        for dpv in ctx.values(rp, "PduRDestPduRRef"):
+            d = ctx.target(dpv)
+            dpdu = ctx.target(ctx.value(d, "PduRDestPduRef")) if d is not None else None
+            if spdu is not None and dpdu is not None:
+                out.setdefault(spdu.path, set()).add(dpdu.path)
+                out.setdefault(dpdu.path, set()).add(spdu.path)
+    return out
+
+
+@rule("H2L-CHAIN-001", "error", CITE_ROUTE, "every Com I-PDU is routed by PduR to/from a lower-layer (bus) PDU")
+def com_ipdu_routed(ctx):
+    if not ctx.containers("PduR/PduRRoutingPaths/PduRRoutingPath"):
+        return  # no PduR configured in this project: nothing to check against
+    users = _pdu_users(ctx)
+    routes = _routes(ctx)
+    for ip in ctx.containers("Com/ComConfig/ComIPdu"):
+        pv = ctx.value(ip, "ComPduIdRef")
+        pdu = ctx.target(pv)
+        if pdu is None:
+            yield ip, ip.line, f"{ip.name}: ComPduIdRef is missing or points nowhere, so the I-PDU has no EcuC Pdu", None
+            continue
+        ends = routes.get(pdu.path, set())
+        if not ends:
+            yield ip, ip.line, (f"{ip.name}: no PduR routing path has its EcuC Pdu {pdu.name} as source or destination, "
+                                "so Com can neither send nor receive it (add the routing path)"), pv.def_ref
+            continue
+        lower = [e for e in ends if users.get(e, set()) - UPPER]
+        if not lower:
+            names = ", ".join(sorted(p.rsplit("/", 1)[-1] for p in ends))
+            yield ip, ip.line, (f"{ip.name}: routed to/from {names}, but no lower-layer module (CanIf, LinIf, FrIf, "
+                                "SoAd, ...) refers to that Pdu, so nothing reaches the bus (add the bus-interface PDU)"), pv.def_ref
+
+
+@rule("H2L-CHAIN-002", "error", CITE_SIG, "every ComSignal belongs to a Com I-PDU")
+def com_signal_attached(ctx):
+    owned = {pv.value.strip() for ip in ctx.containers("Com/ComConfig/ComIPdu")
+             for pv in ctx.values(ip, "ComIPduSignalRef") if pv.value}
+    for s in ctx.containers("Com/ComConfig/ComSignal"):
+        if s.path not in owned:
+            yield s, s.line, f"{s.name}: no ComIPdu lists it in ComIPduSignalRef, so it is never sent or received", None
+
+
+@rule("H2L-CHAIN-003", "error", CITE_EXTRACT, "every signal the extract maps into a Com I-PDU has a ComSignal")
+def extract_signals_have_comsignals(ctx):
+    sysi = ctx.p.system
+    if not sysi.by_path:
+        return
+    for ip in ctx.containers("Com/ComConfig/ComIPdu"):
+        pdu = ctx.target(ctx.value(ip, "ComPduIdRef"))
+        s_ip = system_ipdus(ctx, pdu)
+        if not s_ip:
+            continue
+        mapped = {(m.parent, m.one("I-SIGNAL-REF")) for x in s_ip for m in
+                  (sysi.get(c) for c in (sysi.get(x).children if sysi.get(x) else [])) if m is not None and m.one("I-SIGNAL-REF")}
+        if not mapped:
+            continue
+        covered = set()
+        linked_any = False
+        members = [ctx.target(pv) for pv in ctx.values(ip, "ComIPduSignalRef")]
+        for pv in ctx.values(ip, "ComIPduSignalGroupRef"):   # signal groups: their ComGroupSignals implement members
+            grp = ctx.target(pv)
+            if grp is not None:
+                members.append(grp)
+                members.extend(c for c in grp.children if ctx.rel(c.def_ref).endswith("ComGroupSignal"))
+        for s in members:
+            if s is None:
+                continue
+            ms = mappings_for(ctx, s, s_ip)
+            linked_any = linked_any or bool(ms)
+            covered |= {m.one("I-SIGNAL-REF") for m in ms}
+        if not linked_any and (ctx.values(ip, "ComIPduSignalRef") or ctx.values(ip, "ComIPduSignalGroupRef")):
+            continue  # this project's ComSignals do not link to the extract at all: nothing to compare
+        for parent, isig in sorted(mapped):
+            if isig not in covered:
+                yield ip, ip.line, (f"{ip.name}: the extract maps I-SIGNAL {isig.rsplit('/', 1)[-1]} into {parent} "
+                                    "but no ComSignal of this I-PDU implements it (add the ComSignal, e.g. "
+                                    "autosar_add_signal / autosar_add_like)"), None
+
+
+@rule("H2L-CHAIN-004", "warning", CITE_TRIG, "a triggered I-PDU is carried by a triggered frame; its signals are triggered")
+def extract_triggering_complete(ctx):
+    sysi = ctx.p.system
+    if not sysi.by_path:
+        return
+    frame_of = {}
+    for m in sysi.tags("PDU-TO-FRAME-MAPPING"):
+        for p in m.values.get("PDU-REF", []):
+            frame_of.setdefault(p, set()).add(m.parent)
+    triggered_frames = {ft.one("FRAME-REF") for tag in ("CAN-FRAME-TRIGGERING", "FLEXRAY-FRAME-TRIGGERING",
+                                                        "LIN-FRAME-TRIGGERING", "ETHERNET-FRAME-TRIGGERING")
+                        for ft in sysi.tags(tag)}
+    lines = {}
+    for pt in sysi.tags("PDU-TRIGGERING"):
+        ipdu = pt.one("I-PDU-REF")
+        ii = sysi.get(ipdu)
+        if ii is None or ii.tag != "I-SIGNAL-I-PDU":
+            continue
+        frames = frame_of.get(ipdu, set())
+        if frames and not (frames & triggered_frames):
+            lines.setdefault(pt.path, []).append(
+                f"I-PDU {ipdu.rsplit('/', 1)[-1]} is triggered on {pt.parent} but its frame(s) "
+                f"{', '.join(sorted(f.rsplit('/', 1)[-1] for f in frames))} have no frame triggering")
+        trig = {sysi.get(st).one("I-SIGNAL-REF") for st in pt.values.get("I-SIGNAL-TRIGGERING-REF", []) if sysi.get(st)}
+        if not pt.values.get("I-SIGNAL-TRIGGERING-REF"):
+            continue  # this project does not list signal triggerings on PDU triggerings
+        for c in ii.children:
+            m = sysi.get(c)
+            isig = m.one("I-SIGNAL-REF") if m is not None else None
+            if isig and isig not in trig:
+                lines.setdefault(pt.path, []).append(
+                    f"I-SIGNAL {isig.rsplit('/', 1)[-1]} is mapped into {ipdu.rsplit('/', 1)[-1]} but {pt.path.rsplit('/', 1)[-1]} "
+                    "has no I-SIGNAL-TRIGGERING for it")
+    if not lines:
+        return
+    # report against an ECUC element is the framework's shape; anchor each finding on a Com I-PDU that uses it
+    anchors = {}
+    for ip in ctx.containers("Com/ComConfig/ComIPdu"):
+        pdu = ctx.target(ctx.value(ip, "ComPduIdRef"))
+        for x in system_ipdus(ctx, pdu):
+            anchors.setdefault(x, ip)
+    for ptp, msgs in sorted(lines.items()):
+        pt = sysi.get(ptp)
+        ip = anchors.get(pt.one("I-PDU-REF")) if pt else None
+        if ip is None:
+            continue
+        for msg in msgs:
+            yield ip, ip.line, msg, None
+
+
+def _mapped_system_signals(sysi) -> set:
+    """System signals that a SYSTEM-MAPPING maps to an SWC data element (SENDER-RECEIVER-TO-SIGNAL-MAPPING)."""
+    out = set()
+    for sm in sysi.tags("SYSTEM-MAPPING"):
+        out.update(sm.values.get("SYSTEM-SIGNAL-REF", []))
+    return out
+
+
+@rule("H2L-CHAIN-005", "warning", "System Template SenderReceiverToSignalMapping (application data reaches the bus "
+      "through a data element mapped to the system signal)", "a sent signal is mapped to an SWC data element")
+def sent_signal_mapped_to_swc(ctx):
+    sysi = ctx.p.system
+    if not sysi.by_path:
+        return
+    mapped = _mapped_system_signals(sysi)
+    if not mapped:
+        return  # this project maps no data elements to signals: nothing to compare against
+    for ip in ctx.containers("Com/ComConfig/ComIPdu"):
+        if (ctx.text(ip, "ComIPduDirection") or "").upper() != "SEND":
+            continue
+        pdu = ctx.target(ctx.value(ip, "ComPduIdRef"))
+        s_ip = system_ipdus(ctx, pdu)
+        sigs = [ctx.target(pv) for pv in ctx.values(ip, "ComIPduSignalRef")]
+        linked = [(s, mappings_for(ctx, s, s_ip)) for s in sigs if s is not None]
+        # only where the I-PDU's other signals ARE mapped: a whole BSW-filled I-PDU (counters, NM) is not flagged
+        has = [s for s, ms in linked if any(sysi.get(m.one("I-SIGNAL-REF")) and
+                                            sysi.get(m.one("I-SIGNAL-REF")).one("SYSTEM-SIGNAL-REF") in mapped for m in ms)]
+        if not has and len(linked) > 1:
+            continue
+        for s, ms in linked:
+            ss = {sysi.get(m.one("I-SIGNAL-REF")).one("SYSTEM-SIGNAL-REF") for m in ms if sysi.get(m.one("I-SIGNAL-REF"))}
+            if ms and not (ss & mapped):
+                yield s, s.line, (f"{s.name} (sent in {ip.name}): its system signal {', '.join(sorted(x.rsplit('/', 1)[-1] for x in ss if x))} "
+                                  "is not mapped to any SWC data element (no SENDER-RECEIVER-TO-SIGNAL-MAPPING), so no "
+                                  "application value reaches it; map the providing port's data element to it"), None
+
+
+@rule("H2L-CHAIN-006", "warning", "SWS_Rte data send/receive points (a port no runnable accesses is never served)",
+      "every sender-receiver port of an SWC is accessed by a runnable")
+def port_accessed(ctx):
+    sysi = ctx.p.system
+    if not sysi.by_path:
+        return
+    accessed = set()
+    for tag in ("VARIABLE-ACCESS", "RUNNABLE-ENTITY", "SWC-INTERNAL-BEHAVIOR"):
+        for i in sysi.tags(tag):
+            accessed.update(i.values.get("PORT-PROTOTYPE-REF", []))
+    if not accessed:
+        return
+    swcs = [i for t in ("APPLICATION-SW-COMPONENT-TYPE", "SENSOR-ACTUATOR-SW-COMPONENT-TYPE") for i in sysi.tags(t)]
+    anchors = ctx.containers("Rte/RteSwComponentInstance") or ctx.containers("Com/ComConfig/ComIPdu")
+    for swc in swcs:
+        ports = [sysi.get(c) for c in swc.children]
+        sr = [p for p in ports if p is not None and p.tag in ("P-PORT-PROTOTYPE", "R-PORT-PROTOTYPE")
+              and (sysi.get(p.one("PROVIDED-INTERFACE-TREF") or p.one("REQUIRED-INTERFACE-TREF")) or p).tag == "SENDER-RECEIVER-INTERFACE"]
+        if not any(p.path in accessed for p in sr):
+            continue  # this SWC has no accessed S/R port at all (not modelled to that depth)
+        for p in sr:
+            if p.path not in accessed and anchors:
+                a = anchors[0]
+                yield a, a.line, (f"port {p.path} of {swc.path.rsplit('/', 1)[-1]} is not accessed by any runnable "
+                                  "(no data send/receive point refers to it), so the RTE never reads or writes it"), None
+
+
+def _ident_int(v):
+    try:
+        return int(str(v).strip(), 0)
+    except (TypeError, ValueError):
+        return None
+
+
+@rule("H2L-CHAIN-007", "error", "System Template FrameTriggering.identifier (one frame per CAN id on a channel)",
+      "two frames do not use the same CAN id on one channel")
+def frame_ids_unique(ctx):
+    sysi = ctx.p.system
+    if not sysi.by_path:
+        return
+    seen: dict = {}
+    for ft in sysi.tags("CAN-FRAME-TRIGGERING"):
+        i = _ident_int(ft.one("IDENTIFIER"))
+        if i is not None:
+            seen.setdefault((ft.parent, i), []).append(ft)
+    anchors = ctx.containers("CanIf/CanIfInitCfg/CanIfTxPduCfg") or ctx.containers("Com/ComConfig/ComIPdu")
+    if not anchors:
+        return
+    for (ch, i), fts in sorted(seen.items(), key=lambda x: (x[0][0] or "", x[0][1])):
+        if len(fts) > 1:
+            a = anchors[0]
+            yield a, a.line, (f"CAN id 0x{i:X} is used by {len(fts)} frame triggerings on {ch}: "
+                              f"{', '.join(f.path.rsplit('/', 1)[-1] for f in fts)} (a new frame kept its template's id?)"), None
+
+
+@rule("H2L-SYS-003", "error", "System Template CanFrameTriggering.identifier vs CanIf CanIfTxPduCanId/CanIfRxPduCanId",
+      "a CanIf PDU's CAN id equals the frame triggering id of the frame that carries it")
+def canif_id_matches_extract(ctx):
+    sysi = ctx.p.system
+    if not sysi.by_path:
+        return
+    ft_by_ipdu: dict = {}
+    for ft in sysi.tags("CAN-FRAME-TRIGGERING"):
+        for ip in sysi.ipdus_of_triggering(ft.path):
+            ft_by_ipdu.setdefault(ip, []).append(ft)
+    for kind, idp, refp in (("Tx", "CanIfTxPduCanId", "CanIfTxPduRef"), ("Rx", "CanIfRxPduCanId", "CanIfRxPduRef")):
+        for c in ctx.containers(f"CanIf/CanIfInitCfg/CanIf{kind}PduCfg"):
+            pv = ctx.value(c, idp)
+            cid = _ident_int(pv.value) if pv is not None else None
+            pdu = ctx.target(ctx.value(c, refp))
+            if cid is None or pdu is None:
+                continue
+            fts = [ft for ip in system_ipdus(ctx, pdu) for ft in ft_by_ipdu.get(ip, [])]
+            ids = {_ident_int(ft.one("IDENTIFIER")) for ft in fts} - {None}
+            if ids and cid not in ids:
+                yield c, pv.node.line, (f"{c.name}: {idp}=0x{cid:X} but the extract sends its I-PDU in a frame triggered "
+                                        f"with id {', '.join(f'0x{x:X}' for x in sorted(ids))}"), pv.def_ref

package/python/ecuc_engine/validate.py

@@ -23,6 +23,8 @@ Hand-written semantic rules (ecuc_engine/rules, ids H2L-*) run afterwards, with
 """
 from __future__ import annotations
 
+import os
+
 from typing import Optional
 
 from . import defs as D
@@ -211,7 +213,8 @@ def validate(project: Project, files: Optional[list] = None, module: Optional[st
         check_elem_group(m.path)
 
     from .rules import run_rules
-    dg.items.extend(run_rules(project))
+    found = list(run_rules(project))
+    dg.items.extend(_delta_only(project, found))
     from .probe import load_cfg
     cfg = load_cfg(project.root)
     if code:  # configuration completeness seen from the C code: handles used but not configured
@@ -282,3 +285,67 @@ def validate(project: Project, files: Optional[list] = None, module: Optional[st
 def _nomatch(project: Project, msg: str) -> dict:
     return {"file": "", "line": 0, "path": project.root, "rule": "H2L-FILTER-NOMATCH", "severity": "error",
             "message": msg, "defRef": None}
+
+
+# Convention rules (a sent signal mapped to an SWC data element, a port accessed by a runnable) are true for what a
+# change adds but not for every project's legacy (BSW-filled counters, unused ports). They report only findings that
+# the last commit did not already have, i.e. what this working copy's changes left incomplete. Without git (or
+# without a commit) they report nothing.
+DELTA_RULES = ("H2L-CHAIN-005", "H2L-CHAIN-006")
+
+
+def _delta_only(project: Project, found: list) -> list:
+    keep = [d for d in found if d["rule"] not in DELTA_RULES]
+    delta = [d for d in found if d["rule"] in DELTA_RULES]
+    if not delta:
+        return keep
+    base = _baseline_findings(project)
+    if base is None:
+        return keep
+    import re as _re
+    key = lambda d: (d["rule"], d["path"], _re.sub(r"(\.arxml|\.ARXML):\d+", r"\1", d["message"]))  # noqa: E731
+    return keep + [d for d in delta if key(d) not in {key(b) for b in base}]
+
+
+def _baseline_findings(project: Project) -> Optional[list]:
+    """DELTA_RULES findings on the files as of git HEAD (None when there is no usable HEAD)."""
+    import shutil
+    import subprocess
+    import tempfile
+    root = project.root
+    try:
+        top = subprocess.run(["git", "-C", root, "rev-parse", "--show-toplevel"], capture_output=True, text=True,
+                             timeout=20).stdout.strip()
+        if not top or subprocess.run(["git", "-C", root, "rev-parse", "--verify", "-q", "HEAD"], capture_output=True,
+                                     timeout=20).returncode != 0:
+            return None
+    except (OSError, subprocess.SubprocessError):
+        return None
+    files = list(project.sources.config) + list(project.sources.input)
+    tmp = tempfile.mkdtemp(prefix="ecuc-base-")
+    try:
+        for f in files:
+            rel_top = os.path.relpath(os.path.realpath(f), os.path.realpath(top))
+            r = subprocess.run(["git", "-C", top, "show", f"HEAD:{rel_top}"], capture_output=True, timeout=60)
+            if r.returncode != 0:
+                continue  # new in this working copy: absent from the baseline
+            dst = os.path.join(tmp, os.path.relpath(f, root))
+            os.makedirs(os.path.dirname(dst), exist_ok=True)
+            with open(dst, "wb") as fh:
+                fh.write(r.stdout)
+        cfg = [os.path.join(tmp, os.path.relpath(f, root)) for f in project.sources.config
+               if os.path.exists(os.path.join(tmp, os.path.relpath(f, root)))]
+        inp = os.path.join(tmp, ".hydron")
+        os.makedirs(inp, exist_ok=True)
+        import json as _json
+        with open(os.path.join(inp, "autosar.json"), "w") as fh:
+            _json.dump({"input": [os.path.relpath(os.path.join(tmp, os.path.relpath(f, root)), tmp)
+                                  for f in project.sources.input
+                                  if os.path.exists(os.path.join(tmp, os.path.relpath(f, root)))]}, fh)
+        from .rules import run_rules
+        bp = Project(tmp, config_files=cfg or None, def_files=project.sources.defs or None)
+        return [d for d in run_rules(bp) if d["rule"] in DELTA_RULES]
+    except Exception:  # noqa: BLE001 -- a baseline that cannot be built just turns the delta rules off
+        return None
+    finally:
+        shutil.rmtree(tmp, ignore_errors=True)

package/skills/autosar/SKILL.md

@@ -71,6 +71,7 @@ grounding, no tools, no exploring the project.
 | Verify ALL ARXML (ECUC rules + extract/SWC schema, references, DEST) | `ecuc_validate` (unfiltered) |
 | Edit System extract / SWC / interface XML | `arxml_edit` (DEST inferred, schema-ordered, refs checked) |
 | Add a signal end to end (ECUC + extract + DBC) | `autosar_add_signal` |
+| Add a new message / port / runnable+event / Dem event / NvM block / interface **like an existing one**, in every file at once | `autosar_add_like like=<existing stem> name=<new stem> also={member: new} set={...}` |
 | What may be set/added here (types, ranges, literals, multiplicity) | `ecuc_read path=… schema=true`, or a def path `/AUTOSAR/EcucDefs/<Mod>/…` |
 | Change config | `ecuc_edit ops=[…]` (`dry_run` first for large edits) |
 | Check config | `ecuc_validate` |
@@ -110,7 +111,13 @@ Do not decide what to change from memory or from the prompt alone. Each change g
 3. **Change** with the structured tools only (`ecuc_edit`, `arxml_edit` incl. `new_file`, `autosar_add_signal`). Prefer
    one call per coherent change; nothing is written if any op fails.
 4. **Verify in two steps → fix → verify, until clean.**
-   - Validation 1 (deterministic, the hard gate): `ecuc_validate` (ECUC and extract/SWC files alike), then
+   - Validation 1 (deterministic, the hard gate): `ecuc_validate` (ECUC and extract/SWC files alike, including the
+     COMPLETENESS rules: H2L-CHAIN-001 Com I-PDU routed by PduR to a bus PDU, -002 ComSignal attached to an I-PDU,
+     -003 extract signal implemented by a ComSignal, -004 triggered I-PDU in a triggered frame, -005 sent signal mapped
+     to a port data element, -006 port accessed by a runnable, -007 no CAN id used twice on a channel, H2L-SYS-003 CanIf
+     CAN id = frame id; -005/-006 report only what this working copy's changes added). An H2L-CHAIN finding means the
+     change is UNFINISHED: do the missing part, then validate again. `arxml_edit`, `autosar_add_like` and
+     `autosar_add_signal` validate after every write and say what is still to do.
      `autosar_generate` + `autosar_codegen_diff` / `autosar_build` and `autosar_verify_rte` where the project has them.
    - Validation 2 (against the documents): `ecuc_validate docs=true` checks every element changed in this session
      against the ingested specs/manuals and returns a checklist; answer it line by line (OK / VIOLATED / NOT COVERED,
@@ -118,11 +125,26 @@ Do not decide what to change from memory or from the prompt alone. Each change g
    On any problem: read it, go back to step 1 for that fact, fix with the structured tools, verify again. Repeat until
    every check is clean. Then re-read the request and tick each todo against the evidence. Never report done with a
    failing or unrun check; if something cannot be made clean, say exactly what and why.
-   The pack enforces this: the first edit of a session is refused until a grounding tool ran, C edits need
+   The pack enforces this: the first edit of a session is refused until a grounding tool ran (and the refusal
+   carries the context engine's facts for that edit's target, run for you), C edits need
    `autosar_build_context` (or `autosar_audit`) first, and the system prompt lists every open verification item
    (unvalidated edits, failing validation, unverified C, changed elements not yet checked against the documents)
    until it is resolved.
 
+## A new thing that resembles an existing one: autosar_add_like (preferred)
+Most changes add something the project already has one of: a message, a port, a runnable with its timing event, a
+Dem event with its DTC, an NvM block with its Fee block. Do not build those op by op. Pick the existing one most like
+the new one (same direction, bus, kind), then:
+1. `autosar_add_like like=<its stem> name=<new stem> dry_run=true`: read the Created list (every file it touches)
+   and the "Not copied" / "single-valued" lists.
+2. Name the members you want too: `also={"DrvDoorOpenSts": "SettingsAckCounter"}` gives the new message one signal
+   cloned from that one.
+3. Set the values the request gives with `set` (ECUC param name, XML tag, or `Owner:key` when several clones have
+   it): CAN id (`IDENTIFIER`, `CanIfTxPduCanId`), lengths (`PduLength`, `FRAME-LENGTH`, `I-SIGNAL-I-PDU:LENGTH`),
+   period (`ComTxModeTimePeriod`), signal layout (`<sig>:ComBitPosition`, `<sig>:ComBitSize`, `START-POSITION`) ...
+4. Run it without dry_run. It validates and rolls back on any new finding. Then fix what is listed as single-valued
+   (e.g. the S/R-to-signal mapping of a new port) with arxml_edit, and verify as below.
+
 ## New ARXML file (SWC, interface, data types, extract) from nothing
 1. ONE `arxml_edit` call. Its first op creates the file:
    `{op:"new_file", file:"Input/SWC_X.arxml", packages:["/DataTypes", "/Interfaces", "/Swcs"]}` (R25-11 header and empty