[brettheap]

Lane: openreposhape-1 (openRepoShape-1)
Claim: #525 (comment)

What

After an adoption, the doctor asked again about paths the adoption plan had already answered. It also gave no way out for a submodule moved on purpose, and said nothing about the row of a submodule that had been removed. This PR closes #525, which holds two lines of #457: N7 and L1-08.

• N7: execute now records the plan's answers to the path policy's own questions, and the doctor stops asking them.
  • execute appends an answered_paths: block to the split's project.yaml, right after An adopted assembly records nothing about which leg a human chose for a source submodule, so shape-doctor.py cannot verify a kept gitlink's placement and can only note it; adopt should write the plan's submodule answers into the assembly #189's submodules: block. Each row has the same shape as a submodules: row: path (a directory keeps its one /), leg, an optional resolution: and an optional source_commit.
  • A row is written for each plan entry answered spec or code that covers a path the policy's own walk leaves leg: null. .gitmodules is left to submodules:.
  • The doctor's placement row treats a row as the answer to that question in that leg. An answered examples/ is no longer review_required: it is named in the row and listed under answered_paths in --json.
• L1-08: a submodule moved or removed since the adoption.
  • Moved. A submodule sits in a leg its row does not name, and the leg the row does name holds no submodule at that path. It is still MISPLACED, and the row now says it moved. Where every path the row lists is such a move, or a leg's .gitmodules that goes with it, the NEXT is the doctor itself again instead of --placement-plan, and the WHY gives both ways out: edit the row by hand in the pull request that bumps the pins, or move the submodule back. A .gitmodules goes with the move in the leg the submodule went into, and also in the leg it left when a plain git rm left that file tracked and empty there.
  • Removed. A row whose path no leg holds a submodule at is a note (detail.unheld), never a finding.
  • AGENTS.md now says that a move or removal the human decided is recorded by editing its row by hand, in that pull request, and that this is not the manifest edit rule 3 forbids.

Why (repro on main)

All three were measured on main 2247dbff with a local source, --local-remote-dir, and a stub gh first on PATH.

The setup. The source holds README.md, src/app/util.py, docs/index.md, examples/golden-run/*.json and a submodule at vendor/rules. The plan answered examples/ as spec, and vendor/ and .gitmodules as code, each with a resolution:. check exits 0, execute says adoption verified, and the recursive clone and bootstrap both exit 0. The split's project.yaml gets one submodules: row for vendor/rules and nothing about examples/.

case	doctor	placement row	NEXT	validate-manifest.py
N7: the adopted assembly	COMPLIANT, exit 0	note: "1 path(s) the policy will not call: spec/examples/: ambiguous by rule ambiguous-examples"	--placement-plan	manifest ok
L1-08 (a): vendor/rules moved from code to spec. The code leg drops it and its emptied .gitmodules, the spec leg adds it, each by its own pull request, and bump-leg.py runs for each pin (both exit 0)	MISPLACED (1 path), exit 1	FINDING: "1 submodule(s) sit in a leg other than the one project.yaml's submodules: records for them (#189): spec/vendor/rules (recorded in the code leg); 2 more path(s) need a human's reading"	--placement-plan, whose WHY says "Moving one is a pull request on each leg and a pin bump in the root, so this command makes neither"	manifest ok
L1-08 (b): vendor/rules removed from the code leg, then bump-leg.py	COMPLIANT, exit 0	the same note as N7; nothing about the row	--placement-plan	manifest ok, with the row still in project.yaml and neither leg holding the path

On this branch, the same script gives:

• N7: COMPLIANT, and the row is ok: "… project.yaml's answered_paths: answers the question the policy asks of 1 path(s) (adopt-project.py: record the plan's answers in project.yaml, so the doctor's placement row and the submodules: rows follow them #525): spec/examples/ (rule ambiguous-examples)".
• (a): still MISPLACED (1 path), exit 1, with "1 submodule(s) moved out of the leg project.yaml's submodules: records for them, which no longer holds them (adopt-project.py: record the plan's answers in project.yaml, so the doctor's placement row and the submodules: rows follow them #525): spec/vendor/rules (recorded in the code leg)". The NEXT is the doctor's own line, and the WHY gives both ways out.
• (b): COMPLIANT, and the row is a note: "project.yaml's submodules: records 1 submodule(s) no leg holds (adopt-project.py: record the plan's answers in project.yaml, so the doctor's placement row and the submodules: rows follow them #525): vendor/rules (recorded in the code leg); one removed on purpose has its row deleted by hand, in the pull request that bumps the pins".

How

• adopt-project.py.

  • ANSWER_RECORD = "answered_paths" is the key. The doctor reads it through the module, as it reads SUBMODULE_RECORD.
  • answered_path_record(policy, entries, tree, commit) runs the policy's own walk again over the source's paths that are not gitlinks. It picks out the paths the walk leaves leg: null, and writes one row for each entry _answered_legs reads as answered spec or code that covers one of them, except .gitmodules.
  • The rows come from that walk, not from the plan's hand-edited review_required:. So an entry a person split by hand gets a row for each half.
  • cmd_execute computes the block before _create_leg_remotes, so a policy file that does not load refuses before any leg exists. _commit_the_split appends the block after the submodules: block.
  • submodule_record and the new function share one row writer, _record_block. A plan with no such entry gets "", and the manifest is byte for byte what it was.

• templates/assembly-root/scripts/validate-manifest.py.

  • The submodules: row checker is generalised to a _Record (key, finding-code stem, wording, and whether a directory row may end in /), and both records go through it.
  • The new codes are manifest-answered-paths, manifest-answered-path, manifest-answered-leg, manifest-answered-resolution and manifest-answered-commit.
  • Two rules are new for answered_paths:. A directory's row keeps its one /. And no row may lie under another (path 'examples/golden/a.json' overlaps the row for 'examples/': a path is answered once), because check refuses a path that two entries cover.
  • The submodules: findings are word for word what they were.
  • Neither record is checked against the legs: CI runs this validator whether or not the legs were fetched.

• shape-doctor.py, placement row.

  • recorded_answers() reads the rows through the same recorded_rows() as recorded_submodules().
  • answered_questions() settles a walked question when every tracked file under it is covered by exactly one row (using adopt-project.py's _covering) and that row names this leg. A row naming the other leg settles nothing and is never MISPLACED. .gitmodules is never settled this way. In a project with no answered_paths: it returns the questions as they are, without holding any of them against the leg's files.
  • moved_and_unheld() does two things. It marks a misplaced submodule moved when the leg its row names was read and holds no gitlink at that path. And, only when every leg was read, it lists the submodules: rows no leg holds.
  • moved_alone() decides whether every listed path is a move. That includes a leg's .gitmodules whose only unrecorded submodules moved into that leg, and the .gitmodules a plain git rm leaves tracked and empty in a leg a moved submodule left, where that leg now keeps no submodule at all. When every one is, check_placement gives the NEXT as the doctor's own line, built exactly as unreadable_next builds it for a file only a person can mend, and the WHY MOVED_BY_HAND.
  • New --json keys appear only when there is something to put in them: detail.answered_paths with counts.answered_paths, detail.unheld with counts.unheld, and moved on a misplaced entry. The new key is not An adopted assembly records nothing about which leg a human chose for a source submodule, so shape-doctor.py cannot verify a kept gitlink's placement and can only note it; adopt should write the plan's submodule answers into the assembly #189's per-leg answered. Every other report stays byte for byte what it was.
  • The rules for the other leg and for stale answered rows are in the module docstring.

• AGENTS.md. Two 4-line passages are rewritten as 4 lines each, so the file stays at 490 of 490 lines:

  • under "Adopting", both records and "no command rewrites them";
  • in Checking point 4, that a move or removal the human decided is recorded by editing the row by hand, in the pull request that bumps the pins, which is not the edit point 3 forbids.

  README.md and docs/handbook.html are not touched.

Tests

New: tests/test_doctor_recorded_answers.py, 27 tests. It imports the doctor suite's own fixtures and helpers instead of copying them; its record_answers writes answered_paths: through record_submodules.

On main's source, 18 of the 27 fail. The other 9 pass on main by design: each guards a rule that main already keeps, and each fails under a revert below. All of them were run against main's code (the revert table's R0).

• N7, in the doctor (8 tests, on the scaffolded project):
  • an answer in its leg settles the question, with the row ok and detail.answered_paths;
  • an answer naming the other leg leaves a note and nothing MISPLACED;
  • a question is answered file by file (4 cases);
  • .gitmodules is never answered by answered_paths:;
  • an answer no leg holds is silent, and the report is the scaffold's own word for word.
• L1-08, in the doctor (8 tests):
  • a move made in both legs, with and without the spec leg's .gitmodules, and one whose git rm left the code leg's .gitmodules tracked and empty: MISPLACED, NEXT the doctor's own line, WHY MOVED_BY_HAND;
  • three cases that keep the plan: the code leg still holds it, a question sits beside the move, or the recorded leg was not read. Where the submodule did not move, the row says An adopted assembly records nothing about which leg a human chose for a source submodule, so shape-doctor.py cannot verify a kept gitlink's placement and can only note it; adopt should write the plan's submodule answers into the assembly #189's own MISPLACED clause word for word, and not the moved clause;
  • a row no leg holds is a note with detail.unheld and no NEXT;
  • nothing is said where a leg was not read.
• AGENTS.md (1 test): it says who edits a row and when.
• execute's record (6 unit tests): answered spec, answered root, answered drop, split by hand, and a confident rule overridden (not recorded); and a plan with no such question appends "".
• End to end with git filter-repo (4 tests, 2 adoptions):
  • N7: the record is written and the doctor asks no more;
  • a move made with git rm (and git rm -f of the .gitmodules it empties) and git submodule add, then finished by editing the row (leg:, resolution:, no source_commit:), ending COMPLIANT with manifest ok;
  • a removal: a note until the row is deleted;
  • a split with no answered question: the manifest ends byte for byte on An adopted assembly records nothing about which leg a human chose for a source submodule, so shape-doctor.py cannot verify a kept gitlink's placement and can only note it; adopt should write the plan's submodule answers into the assembly #189's block, with no answered_paths.

Changed: tests/test_manifest_validator.py.

• test_a_record_is_accepted now runs over both records.
• The An adopted assembly records nothing about which leg a human chose for a source submodule, so shape-doctor.py cannot verify a kept gitlink's placement and can only note it; adopt should write the plan's submodule answers into the assembly #189 refusals go through a shared assert_refused.
• There are 11 new refusal cases for answered_paths:, plus "not a list" and the overlap sentence. 13 of these 14 new items fail on main; the "accepted" case passes there, because main's validator ignores the key.

Changed: one #189 test in tests/test_shape_doctor.py. test_a_submodule_in_the_other_leg_from_its_record_is_misplaced stages .cursor in the code leg with a record naming the spec leg, which holds none. That is now a move already made: the entry gains moved: True, the reason is the "moved out of" clause, and the NEXT is no plan. Its other assertions, including the placement plan it writes, are unchanged.

Changed: tests/test_doctor_next_is_a_command.py. Its CASES gains check_placement-moved, a submodule staged in the spec leg with its row naming the code leg. The property test holds its NEXT to one command and nothing else, and its WHY to MOVED_BY_HAND's opening words.

Revert table. Each change was reverted alone in a scratch clone of the branch head 42572caa (the merge below), and 131 tests were run there with git filter-repo: the new file, tests/test_manifest_validator.py, the changed #189 test and the new CASES entry. Every one of the 27 new tests fails under at least one revert from R1 to R18.

revert	decision	tests that fail
R0: every source file as on main	all	33 (18 new doctor/adopt tests, 13 validator tests, the #189 test, the CASES entry)
R1: execute writes no answered_paths:	key	3: the N7, move and removal end-to-end tests
R2: .gitmodules recorded too	rows by the walk, .gitmodules left out	8: the record unit tests, the byte-for-byte test, N7 end to end
R3: every entry kept in a leg recorded (no question filter)	only the policy's own questions	8 (the same 8, including the confident-rule override case)
R4: the validator reads no answered_paths:	the validator's check	13 validator tests
R5: no directory rows (examples/ refused)	the row shape	8
R6: no overlap check	no row under another	2
R7: the doctor takes no answer	N7	6
R8: a row for either leg answers	the other leg stays a question	2
R9: answered_paths: answers .gitmodules	.gitmodules is submodules:'s	1
R16: any covered file answers a question	file by file	2
R10: a finished move keeps --placement-plan	no plan for a finished move	6 (with the #189 test and the CASES entry)
R11: no move marked	a move is said	7 (with the #189 test and the CASES entry)
R17: the emptied .gitmodules of the leg a move left keeps the plan	a plain git rm move names no plan	1
R18: a move called where the recorded leg still holds it	a move half made is not a move	1
R15: a move called from an unread leg	nothing said where a leg is unread	1
R12: no row-no-leg-holds note	the removal note	2
R14: unheld named with a leg unread	nothing said where a leg is unread	1
R13: AGENTS.md as on main	who edits a row	1

Three things have no row of their own. "A stale answer is silent" has no code to revert: its test fails only under R5, and it pins the report word for word. The confident-rule override is out of scope: its unit case fails under R2 and R3. And answered_questions returning at once where there is no answered_paths: changes no output, only the time: in a probe at 60,000 files and 3,000 questions, holding each question against every file had taken 48.8 s, where the walk itself takes about 6 s.

Runs. Every run used /usr/bin/python3 -m pytest with a stub gh first on PATH, GH_TOKEN bogus, an empty GH_CONFIG_DIR and GIT_CONFIG_GLOBAL=/dev/null. Each ran in six groups per mode, and every log names its head, has dirty 0 and ends EXIT=0. The file set is every file that runs or imports adopt-project.py, shape-doctor.py, bump-leg.py or validate-manifest.py, plus tests/test_shape_doctor.py, tests/test_scaffold_leg_path_collisions.py, tests/test_repo_hygiene.py and the new file.

At the branch head, 42572caa. It is the merge of main 3f768a66 into the review round below. The merge was clean, with no conflicted path: git auto-merged AGENTS.md and adopt-project.py, and also shape-doctor.py, tests/test_doctor_next_is_a_command.py and tests/test_shape_doctor.py, which #555 had rewritten. Its tree is the one git merge-tree predicted, this branch's own changed lines against main are the same 1,289 they were against its base, and AGENTS.md stays at 490 of 490 lines. 110 files:

mode	passed	skipped	failed
git filter-repo on PATH	7,665	17	0
hidden (PATH=/usr/local/bin:/usr/bin:/bin, stub first)	7,347	335	0

45d080ae changes only three comments, so that they cite #525 rather than a reviewer's working name, and tests/test_doctor_recorded_answers.py and tests/test_shape_doctor.py pass there: 427 passed, 3 skipped, 0 failed.

At b640d34e, the review round before the merge, 105 files: 7,308 passed and 17 skipped with git filter-repo; 6,991 passed and 334 skipped hidden; none failed.

Windows

CI runs on Linux only since #597, so nothing here runs on Windows. The tests still keep to what Windows needs, which costs nothing:

• No test counts "\n" in bytes a helper wrote. Manifests and records are written as bytes.
• Every path the tests create is legal on NTFS.

The new file, tests/test_manifest_validator.py, the changed #189 test and the new CASES entry were also run at 42572caa under a Windows newline emulation: a pytest plugin, kept outside the repository, that makes text-mode Path.write_text and text-mode stdin write \r\n. 131 passed, EXIT=0.

Not in this PR

• A plan that overrides a confident rule. For example, docs/ (rule spec-governance) answered code. That passes check, verifies, and is MISPLACED (1 path) on the doctor's first run. Recording it would mean letting a manifest row override a policy FINDING, so it stays outside adopt-project.py: record the plan's answers in project.yaml, so the doctor's placement row and the submodules: rows follow them #525 and is noted for Tracking: adopt-project.py, converting an existing repository in place #457.
• No command rewrites a row. bump-leg.py never reads submodules:, it sees one leg per run, and its commit is the pin, the digest and the workflows and nothing else.

Known limits

• Older projects. A project adopted before this PR has no answered_paths:, and its doctor asks as before. Nothing here says how to answer an old project's questions in its manifest.
• The wording of a move's .gitmodules. In the move case, a .gitmodules that goes with the move (the spec leg's, or the empty one a plain git rm leaves in the code leg) is still counted among the "more path(s) need a human's reading" until the row is edited, although it does not change the NEXT.
• The empty .gitmodules a plain git rm leaves. Once such a move is finished by editing the row, that empty file is still the policy's question in the leg the submodule left: a note, with --placement-plan as the NEXT, until it is deleted there. No record answers an empty .gitmodules, and main asks it the same way, so it is noted for Tracking: adopt-project.py, converting an existing repository in place #457.
• Each project's copy of validate-manifest.py. It reads upstream-changed to update-shape.py check until apply is run. That is how an upstream validator fix reaches a project.

This PR answers two lines of #457, N7 and L1-08, and #457 itself stays open.

Closes #525

🤖 Generated with Claude Code

Summary by Sourcery

Persist adoption answers and improve doctor handling of intentionally moved or removed submodules.

New Features:

• Record adoption answers to policy questions in answered_paths: so the doctor does not ask them again.
• Report intentionally moved or removed submodules with actionable placement guidance.

Bug Fixes:

• Prevent previously answered ambiguous paths from being reported as unresolved after adoption.
• Distinguish completed submodule moves from ordinary misplaced submodules and surface removed submodule records as notes.

Enhancements:

• Extend manifest validation to cover answered_paths: records, including directory paths and overlapping-row checks.
• Update doctor JSON and placement output with answered-path, moved, and unheld details.
• Clarify ownership and hand-edit procedures for changed submodule records in AGENTS.md.

Tests:

• Add comprehensive unit and end-to-end coverage for recorded answers, moved and removed submodules, manifest validation, and doctor command guidance.

[sourcery-ai]

Sorry @brettheap, you've used your own review budget of 250,000 diff characters for the last 7 days.

You can request another review in 1 day and 9 hours by commenting @sourcery-ai review. Upgrade to get a review now.

[sourcery-ai]

Reviewer's Guide

The PR records adoption answers to policy-owned path questions in project.yaml, teaches the doctor to honor those answers only in the named leg, and adds explicit handling for intentional submodule moves and removals, backed by shared validation, documentation, and broad regression coverage.

Sequence diagram for recording adoption answers during execute

sequenceDiagram
    participant User
    participant Execute as adopt-project.py execute
    participant Policy as PathPolicy
    participant Manifest as project.yaml

    User->>Execute: cmd_execute()
    Execute->>Policy: PathPolicy.load(PATH_POLICY)
    Execute->>Policy: walk(source paths)
    Policy-->>Execute: policy questions with leg: null
    Execute->>Execute: answered_path_record(entries, tree, commit)
    Execute->>Manifest: append submodules: and answered_paths:
    Execute-->>User: adoption verified

Loading

Sequence diagram for doctoring recorded answers and submodule placement

sequenceDiagram
    participant Doctor as shape-doctor.py
    participant Manifest as project.yaml
    participant Policy as PathPolicy
    participant Legs as Adopted legs

    Doctor->>Manifest: recorded_submodules()
    Doctor->>Manifest: recorded_answers()
    Doctor->>Legs: audit_leg(spec and code)
    Legs-->>Doctor: tracked files, gitlinks, .gitmodules
    Doctor->>Policy: walk(each leg)
    Policy-->>Doctor: placement questions
    Doctor->>Doctor: answered_questions()
    Doctor->>Doctor: moved_and_unheld()
    alt answered_paths row names this leg
        Doctor-->>Doctor: mark question answered
    else recorded submodule moved or is unheld
        Doctor-->>Doctor: mark moved or emit removal note
    end
    Doctor-->>Doctor: placement verdict and next command

Loading

Entity relationship diagram for adoption manifest records

erDiagram
    PROJECT_MANIFEST ||--o{ SUBMODULE_RECORD : contains
    PROJECT_MANIFEST ||--o{ ANSWERED_PATH_RECORD : contains

    PROJECT_MANIFEST {
        yaml submodules
        yaml answered_paths
    }
    SUBMODULE_RECORD {
        string path
        string leg
        string resolution
        string source_commit
    }
    ANSWERED_PATH_RECORD {
        string path
        string leg
        string resolution
        string source_commit
    }

Loading

Flow diagram for intentional submodule move handling

flowchart TD
    A[Doctor audits both legs] --> B{Submodule differs from recorded leg?}
    B -->|No| C[Keep existing placement result]
    B -->|Yes| D{Recorded leg was read and holds no gitlink?}
    D -->|No| E[Report ordinary MISPLACED result]
    D -->|Yes| F[Mark submodule moved]
    F --> G{Every misplaced path is a completed move?}
    G -->|Yes| H[Next: run shape-doctor.py again]
    H --> I[Human edits submodules row or moves it back]
    G -->|No| J[Next: --placement-plan]

Loading

File-Level Changes

Change	Details	Files
Persist adoption-plan answers for policy questions in the manifest and use them to suppress duplicate doctor questions.	Add answered_paths: rows derived from the policy walk, excluding gitlinks and .gitmodules, while preserving the existing manifest when no such answers exist. Refactor manifest record writing and validation to share row handling, including directory paths, overlap detection, field validation, and dedicated findings. Teach the doctor to resolve questions file-by-file only when rows name the current leg, and expose answered paths in human and JSON reports.	adopt-project.py shape-doctor.py templates/assembly-root/scripts/validate-manifest.py AGENTS.md tests/test_doctor_recorded_answers.py tests/test_manifest_validator.py
Make intentional submodule moves and removals explicit without generating an obsolete placement plan.	Mark a misplaced submodule as moved when its recorded leg no longer holds it and the destination leg does. Use the doctor itself as the next action for completed moves, with guidance to edit the row by hand or move the submodule back. Report rows for removed submodules as compliant notes with detail.unheld, while avoiding conclusions when legs are unreadable. Document the required human row edits and preserve prior placement behavior for incomplete or unrelated moves.	shape-doctor.py AGENTS.md tests/test_doctor_recorded_answers.py tests/test_shape_doctor.py tests/test_doctor_next_is_a_command.py
Expand regression coverage across unit, validator, doctor, and end-to-end adoption scenarios.	Cover answered directories, split answers, wrong-leg answers, .gitmodules exclusion, stale rows, moves, removals, unreadable legs, and manifest preservation. Validate accepted and rejected answered_paths: schemas, including malformed paths, overlaps, invalid legs, resolutions, commits, and non-list records. Add command-property coverage for the move-specific NEXT and verify end-to-end manifest, doctor, and validator outcomes.	tests/test_doctor_recorded_answers.py tests/test_manifest_validator.py tests/test_shape_doctor.py tests/test_doctor_next_is_a_command.py

Assessment against linked issues

Issue	Objective	Addressed	Explanation
#525	Record adoption-plan answers to paths the policy left undecided in project.yaml, and have the doctor treat those answers as resolved in the specified leg rather than asking again.	✅
#525	Make deliberate submodule moves actionable by identifying completed moves, explaining how to update the recorded row or move the submodule back, and documenting that the row is edited by hand in the pin-bumping pull request.	✅
#525	Report rows for removed submodules as informational notes, not findings, and validate the new answered_paths: records.	✅

---

Tips and commands

Interacting with Sourcery

• Trigger a new review: Comment @sourcery-ai review on the pull request.
• Continue discussions: Reply directly to Sourcery's review comments.
• Generate a GitHub issue from a review comment: Ask Sourcery to create an
  issue from a review comment by replying to it. You can also reply to a
  review comment with @sourcery-ai issue to create an issue from it.
• Generate a pull request title: Write @sourcery-ai anywhere in the pull
  request title to generate a title at any time. You can also comment
  @sourcery-ai title on the pull request to (re-)generate the title at any time.
• Generate a pull request summary: Write @sourcery-ai summary anywhere in
  the pull request body to generate a PR summary at any time exactly where you
  want it. You can also comment @sourcery-ai summary on the pull request to
  (re-)generate the summary at any time.
• Generate reviewer's guide: Comment @sourcery-ai guide on the pull
  request to (re-)generate the reviewer's guide at any time.
• Resolve all Sourcery comments: Comment @sourcery-ai resolve on the
  pull request to resolve all Sourcery comments. Useful if you've already
  addressed all the comments and don't want to see them anymore.
• Dismiss all Sourcery reviews: Comment @sourcery-ai dismiss on the pull
  request to dismiss all existing Sourcery reviews. Especially useful if you
  want to start fresh with a new review - don't forget to comment
  @sourcery-ai review to trigger a new review!

Customizing Your Experience

Access your dashboard to:

• Enable or disable review features such as the Sourcery-generated pull request
  summary, the reviewer's guide, and others.
• Change the review language.
• Add, remove or edit custom review instructions.
• Adjust other review settings.

Getting Help

• Contact our support team for questions or feedback.
• Visit our documentation for detailed guides and information.
• Keep in touch with the Sourcery team by following us on X/Twitter, LinkedIn or GitHub.

[sonarqubecloud]

Quality Gate passed

Issues
1 New issue
0 Accepted issues

Measures
0 Security Hotspots
0.0% Coverage on New Code
0.0% Duplication on New Code

See analysis details on SonarQube Cloud