Repository navigation
Conversation
… version `dokimi catalog provenance --root DIR --upstream CHECKOUT|--upstream-manifest FILE` reports, for each skill under DIR, the upstream skill and version it copies, how many commits and months behind upstream head it is, and whether it was edited. Offline: upstreams are named by the caller (local git checkouts, or a dokimi.upstream.v1 JSON manifest). dokimi ships no upstream list. A copy matches by git blob sha against the upstream history first, then by frontmatter name and word Jaccard similarity >= 0.8 (the threshold of the corpus study). The git reads use the same hardened wrapper as `catalog check`. Findings (upstream-stale, license-dropped, risk-inherited) come in a follow-up. Signed-off-by: Nikolay Petrov <nikolay.a.petrov@intel.com>
…ns and duplicate bytes - A sha-256 checkout prints 64-hex blob ids, so no byte-identical copy matched exactly. A copy's bytes are now looked up under both the sha-1 and the sha-256 blob id. - `log --raw` prints no diff for a merge commit, so a SKILL.md version a merge wrote was never indexed and commits-behind was short. Use --diff-merges=first-parent. - Several versions with identical bytes: the newest commit date wins the exact match (it was the first listed), as the module docstring says. Signed-off-by: Nikolay Petrov <nikolay.a.petrov@intel.com>
…, as documented The newest-date key ranked above the upstream order, so a later-dated upstream beat an earlier one on the command line. Keep the date as the tie-break within one upstream. Signed-off-by: Nikolay Petrov <nikolay.a.petrov@intel.com>
`catalog check --upstream CHECKOUT` and `--upstream-manifest FILE` match each loaded skill to an upstream version (the catalog provenance matcher) and add: - upstream-stale (note): the copy matches an upstream version that is not the head. - license-dropped-from-upstream (warn): an edited copy drops the upstream license. - risk-inherited-from-upstream (warn): the copy keeps unrestricted Bash, pipe-to-shell or permission-bypass-flag that its upstream version also has. Offline; nothing is fetched. Refused with --per-skill and --kind tasks. The findings are warnings or notes, so --strict and the exit code are unchanged. Signed-off-by: Nikolay Petrov <nikolay.a.petrov@intel.com>
A manifest with no entry flagged as head made every match upstream-stale, and the note then said the copy was behind the head. Stale is now reported only when the upstream's head is known: a checkout always, a manifest when an entry is flagged. --ignore now also drops the ignored risk codes before risk-inherited-from-upstream is built, so an ignored code is neither inherited nor named in a message. Signed-off-by: Nikolay Petrov <nikolay.a.petrov@intel.com>
…ream Index.head_known checks the (upstream, path) of the matched version, so one flagged entry no longer makes the unflagged paths of that manifest stale-able. Signed-off-by: Nikolay Petrov <nikolay.a.petrov@intel.com>
CLI interface change detectedThis PR changes dokimi's user-facing CLI surface (commands and/or options): + added command `dokimi catalog provenance`
+ option `--format`
+ option `--help/-h`
+ option `--root`
+ option `--upstream`
+ option `--upstream-manifest`
~ `dokimi catalog check` parameters changed:
+ added option `--upstream`
+ added option `--upstream-manifest`Updated on every push; the |
|
🔍 OpenCodeReview found 6 issue(s) in this PR. CI at By severity: 1 high, 5 medium
Review details
|
| Give `catalog check` the same upstreams as `catalog provenance` and each loaded skill that matches one gets | ||
| up to three more findings. Nothing is fetched, and none of them is an error: | ||
|
|
||
| - `upstream-stale` (note): the copy matches an upstream version that is not the upstream head. A note does not |
There was a problem hiding this comment.
Must-fix — Impact: users can interpret the absence of upstream-stale as evidence that an old copy is current, despite supplying a manifest that cannot establish this. Trigger: a manifest has a top-level head but no entry with "head": true for the matched path (including when another path is flagged). Evidence: Index.head_known() requires a flagged entry for that same path, and upstream_findings() suppresses the note otherwise; test_a_manifest_with_no_head_flag_says_nothing_is_stale and test_a_flagged_head_on_one_path_does_not_make_another_path_stale explicitly assert this behavior. Document that prerequisite and distinguish the top-level repository head from each skill path's head. Workaround: flag the current entry of each relevant path with "head": true, or use a checkout. Severity: medium because this is a bounded mismatch in the diagnostic contract, with no security or data-loss impact.
Check run: inconclusive, the result is not shown as a pass.
Suggestion:
| - `upstream-stale` (note): the copy matches an upstream version that is not the upstream head. A note does not | |
| - `upstream-stale` (note): the copy matches a non-head version of a path whose head is known. For manifests, | |
| that requires an entry of the same path with `"head": true`; the top-level `head` block alone is insufficient. A note does not |
| body = path[1:-1].encode("utf-8", errors="surrogateescape") | ||
| out = bytearray() | ||
| i = 0 | ||
| escapes = {ord("t"): 9, ord("n"): 10, ord('"'): 34, ord("\\"): 92} |
There was a problem hiding this comment.
Must-fix — decode all Git C-style path escapes, or use NUL-delimited history output. Trigger: commit two versions of skills/a\r/SKILL.md, where \r is an actual carriage return in the directory name. Evidence: Git quotes that path using \\r, but this mapping leaves it as literal backslash-plus-r; _head_blobs instead reads the real carriage return from its NUL-delimited listing. Consequently first_seen cannot join the HEAD path to its history: the head version loses its commit/date, and older versions are reported with the wrong path. Impact: incorrect provenance attribution and finding messages for valid Git paths. Workaround: rename directories to exclude these control characters. Severity: medium because provenance results are wrong for a bounded input class. The same problem affects Git's \\a, \\b, \\v and \\f escapes; cover history/HEAD agreement in a regression test.
| commits that touched each path (newest first). A deletion is a touch with no blob.""" | ||
| # --diff-merges=first-parent: a merge commit prints no diff by default, so a SKILL.md version that a merge | ||
| # resolved (or changed) would never be seen and the commits it counts as behind would be short. | ||
| log = _git(root, "-c", "core.quotepath=off", "log", "--raw", "--no-abbrev", "--no-renames", "--full-history", |
There was a problem hiding this comment.
Must-fix — explicitly request root-commit diffs with --root. Impact: the index can silently omit the initial version of a skill, losing exact matches and their stale findings. Trigger: an upstream has log.showRoot=false, adds SKILL.md in its root commit, and edits it in a later commit; the catalog contains the initial bytes. Evidence: this log command leaves root-diff behavior to repository configuration, and first_seen only receives blobs from raw diff records. _head_blobs restores only the later HEAD bytes, so the initial blob is absent; if similarity to HEAD is below 0.8, the copy becomes unmatched. Workaround: set log.showRoot=true in the checkout or supply the initial version via a manifest. Severity justification: medium because supported checkout input produces a bounded but materially incorrect provenance verdict. Add --root and a regression test with log.showRoot=false.
There was a problem hiding this comment.
Confirmed, and the result is worse than unmatched. With log.showRoot=false the root version is never indexed, so an unedited copy of it matches the head version as similar: catalog provenance prints at head and edited: yes for a copy that is one change behind. Passing --root to the log in _history fixes it.
| if head.returncode: | ||
| raise ValueError(f"{root} is not a git checkout with a commit: --upstream takes a git checkout") | ||
| head_sha = head.stdout.strip() | ||
| head_date_text = _git(root, "log", "-1", "--format=%cI", head_sha).stdout.strip() |
There was a problem hiding this comment.
Must-fix — disable signature verification on both new git log calls. Impact: inspecting an upstream can execute a repository-configured verification program with the caller's privileges, violating the data-only inspection contract. Trigger: a checkout containing a signed commit with local log.showSignature=true and gpg.program (or the signature-format-specific program) pointing to an executable. Evidence: neither this call nor _history passes --no-show-signature; the _git wrapper disables hooks/fsmonitor/transports but not signature verification. The existing guidance-history reader explicitly disables this option. Workaround: use a manifest or remove these checkout settings. Severity justification: high because an opt-in inspection of a supplied checkout can execute arbitrary local code. Add --no-show-signature to both calls and test that a configured verifier is never invoked.
There was a problem hiding this comment.
Blocking: Confirmed: a checkout with log.showSignature=true, gpg.program pointing to a script, and one commit with a gpgsig header runs that script twice during catalog provenance (once per log call). Adding -c log.showSignature=false to catalog_git._git, next to the core.fsmonitor and core.hooksPath overrides, covers both calls and any later log there.
| head_raw = data.get("head") | ||
| head: dict[str, Any] = head_raw if isinstance(head_raw, dict) else {} | ||
| upstream = Upstream( | ||
| name=name.strip(), order=order, head_commit=head.get("commit"), |
There was a problem hiding this comment.
Must-fix — validate commit fields before storing them. Trigger: a manifest with "head": {"commit": 123} or a matching skill entry with "commit": 123. Evidence: these values pass through load_manifest unchanged, but upstream_rows and to_row later apply [:12]; catalog provenance calls both, producing TypeError and the CLI's infrastructure exit 5 rather than InputError/exit 2. Impact: malformed manifest input crashes report generation instead of receiving a controlled validation error. Workaround: use string or null commit values. Severity: medium because this is a bounded failure of the manifest workflow. Validate both top-level and entry commit values as string-or-null and add regression cases.
| except ValueError as exc: | ||
| raise InputError(str(exc)) from exc |
There was a problem hiding this comment.
Must-fix — handle checkout startup errors as InputError. Trigger: catalog check --root VALID_CATALOG --upstream /nonexistent (also catalog provenance), or an upstream path naming a regular file. Evidence: load_checkout immediately invokes _git with that path as cwd; process.git propagates the resulting FileNotFoundError/NotADirectoryError, while this handler catches only ValueError and the CLI handles InputError, not OSError. Impact: bad user input produces a traceback and exit 1 instead of the actionable usage error/exit 2 used for invalid upstreams. Workaround: verify that the checkout directory exists before invoking the command. Severity justification: medium, a bounded failure of the supported CLI input-error contract. Catch expected OSError failures around checkout loading and translate them to InputError with the source path; add missing-path and regular-file cases.
|
Codecov Report❌ Patch coverage is
Additional details and impacted files@@ Coverage Diff @@
## main #849 +/- ##
==========================================
- Coverage 95.75% 95.64% -0.11%
==========================================
Files 423 427 +4
Lines 56416 56833 +417
Branches 9714 9782 +68
==========================================
+ Hits 54019 54357 +338
- Misses 1489 1541 +52
- Partials 908 935 +27
🚀 New features to boost your workflow:
|
vlad-perevezentsev
left a comment
There was a problem hiding this comment.
Review at ce9a58d. The matching by blob sha and the three findings work on a plain linear history, but the history reader still trusts the checkout's own git config and miscounts merges. The details are in the line comments. This branch also carries all of #838.
Agreed with @exai-bot: gpg.program from the checkout runs via log.showSignature; the root commit is missed with log.showRoot=false; a bad --upstream path gives a traceback; non-string commit values crash; _unquote misses \r and the other escapes; the docs do not say upstream-stale needs a flagged head entry.
What I ran, at ce9a58d:
make ci-local --offline: 22,234 passed, 0 failed, 72 skipped.- Scratch upstream repos run with
catalog provenanceandcatalog check: a--no-ffmerge (2 commits behind for one change),log.showRoot=false(a stale copy readsat head), a fake signed commit withgpg.programset (the script ran twice), a--filter=blob:noneclone, a<CR>directory name, a manifest with no head flag, and a missing or file--upstreampath.
Checked, no issues
- Matching: exact matches over sha-1 and sha-256 ids, the newest-version tie-break within one upstream, and the Jaccard fallback by frontmatter name behave as the docs say.
catalog checkwiring: the findings respect--ignore, skip unreadable skills, and are refused with--per-skilland--kind tasks; the new codes are inFINDING_CODES.- Docs and changelog: both fragments are under Added and describe the user-facing change; the CLI snapshot is current; new files carry the SPDX header.
| log = _git(root, "-c", "core.quotepath=off", "log", "--raw", "--no-abbrev", "--no-renames", "--full-history", | ||
| "--diff-merges=first-parent", "--format=C %H %cI", "HEAD", "--", _SKILL_PATHSPEC) |
There was a problem hiding this comment.
behind counts a change twice when it came in through a merge commit.
--full-history lists the side-branch commit, and --diff-merges=first-parent lists the merge with the same change. Repro: v1 on main, v2 committed on a branch, merge --no-ff; a copy of v1 is reported 2 commits behind, though the file changed once. Commits on a parallel branch are also counted by date order, not by whether they come after the version.
Suggestion: keep the full history to find the versions, but count behind on the first-parent chain only (for a version from a side branch, from the merge that brought it in).
| "at_head": v.head, | ||
| "behind_commits": 0 if v.head else v.behind, | ||
| "behind_months": v.months_behind, |
There was a problem hiding this comment.
catalog provenance reports months behind when the manifest does not say which entry is the head.
For a manifest path with no entry flagged "head": true, to_row gives at_head: false and behind_months from the top-level head date, and the summary median counts it. catalog check with the same manifest treats the head as unknown (Index.head_known) and reports no upstream-stale. Repro: head date 2026-04-01, one unflagged entry dated 2026-01-01: provenance prints 3.0 mo behind, check prints nothing.
Suggestion: pass head_known to to_row and give at_head, behind_commits and behind_months as null (text: unknown) when it is False.
| done = _git(root, "cat-file", "--batch", input=("\n".join(unique) + "\n").encode()) | ||
| if done.returncode: | ||
| raise ValueError(f"{root}: cannot read blobs: {_git_error(done)}") |
There was a problem hiding this comment.
A blobless partial clone fails the whole upstream instead of leaving out the missing blobs.
The docstring says a partial clone may lack some blobs and they are skipped, but cat-file --batch first tries to lazy-fetch a missing blob; protocol.allow=never blocks that and git exits 128. After git clone --filter=blob:none, catalog provenance --upstream <clone> gives cannot read blobs: fatal: could not fetch <sha> from promisor remote.
Suggestion: refuse a partial clone with a clear message and fix the docstring. Skipping the blobs instead would need the history marked partial, as for a shallow clone, since a copy of a missing version then reads as similar and edited.
| """The index over the given checkouts, then manifests (the order is the tie-break). Names must be distinct.""" | ||
| upstreams: list[Upstream] = [] | ||
| versions: list[Version] = [] | ||
| sources = [(load_checkout, Path(p)) for p in checkouts] + [(load_manifest, Path(p)) for p in manifests] |
There was a problem hiding this comment.
With checkouts and manifests mixed, a tie does not go to the first upstream listed.
build puts every --upstream before every --upstream-manifest, and _exact_rank compares behind before order, where a manifest version's None becomes 1 << 30. So with --upstream-manifest a.json --upstream b and the same non-head bytes in both, b wins, while the --upstream help and the changelog say the first one listed wins.
Suggestion: say in the help and the docs that checkouts come before manifests.
vchamarthi
left a comment
There was a problem hiding this comment.
🟡 Not approved yet · reviewed ce9a58d
Next: @napetrov: answer 10 open threads from exai-bot, vlad-perevezentsev and settle 1 open question (below). 2 nits optional.
Blocking
- Still holds on this head: thread by exai-bot –
upstream-staleis documented as a note for any copy that matches a non-head version. - Still holds on this head: thread by exai-bot –
_unquoteleaves\r(and\a,\b,\v,\f) as literal backslash pairs, so the history path of a directory with a carriage return does not join its HEAD path: an exact copy of its head version readscommitnull. - Still holds on this head: thread by exai-bot – With
log.showRoot=falsethe root version of a skill is not indexed: an unedited copy of it matches the head assimilarand readsat head. - Still holds on this head: thread by exai-bot – A checkout with
log.showSignature=trueand agpg.programscript:buildruns that script, and the marker file the script writes is created. - Still holds on this head: thread by exai-bot – A manifest with
"commit": 123on its head or an entry passes it on, andupstream_rowsraisesTypeErrorwhere a controlledInputErroris expected. - Still holds on this head: thread by exai-bot – A missing
--upstreampath reachesbuildasFileNotFoundError(a regular file asNotADirectoryError), andcatalog provenanceexits 5, not 2. - Still holds on this head: thread by @vlad-perevezentsev – A copy of a version that reached main through a
--no-ffmerge of a branch readsbehind2 for one change, because the side-branch commit and the merge both count. - Still holds on this head: thread by @vlad-perevezentsev – A manifest path with no flagged head reads
3.0months behind (head 2026-04-01, entry 2026-01-01), whilecatalog checktreats its head as unknown. - Still holds on this head: thread by @vlad-perevezentsev –
buildon a--filter=blob:noneclone raisesInputError(could not fetch ... from promisor remote), where the docstring says missing blobs are skipped. - Still holds on this head: thread by @vlad-perevezentsev – A checkout wins an exact tie against a manifest with the same non-head bytes whichever flag comes first, because
buildlists checkouts before manifests. - Open question for @napetrov: When a checkout and a manifest hold the same non-head bytes, the checkout wins even when the manifest flag comes first on the command line, because
buildlists checkouts before manifests. State that order in the--upstreamand--upstream-manifesthelp and indocs/external-content.md, or give a tie to the flag listed first.
Verified on ce9a58d: ✅ changed tests: 42 passed, fail on main · ✅ full suite with main merged in: 22874 passed · ✅ merges onto main ·
20 checks behind it, each with its evidence
| Area | What holds | How |
|---|---|---|
| Changed tests | the 42 tests in tests/test_catalog_provenance.py and tests/test_catalog_upstream_findings.py pass on the head |
tests on the head |
| Changed tests on main | the same two test files fail to import on main, because dokimi.external.upstream does not exist there, so they pin only the new code |
same tests on main |
| Repo checks | make ci-local --offline on the head with main merged in has no failing step |
full suite, main merged in |
| Merge | the branch merges onto main with no conflict | merge onto main |
| Strict exit | a copy with an inherited risk gives the same catalog check --strict exit code with and without --upstream-manifest, and prints risk-inherited-from-upstream |
ran it |
| Ignored risk code | --ignore allowed-tools-unrestricted-bash removes that code from the inherited finding and keeps pipe-to-shell |
ran it |
| Per-skill refusal | catalog check --per-skill --upstream-manifest exits 2 with the refusal message |
ran it |
| License drop | an edited copy that changes the license value is not reported, and one that drops the license is | ran it |
| Upstream gate | negating the --upstream flag gate in _upstream_findings fails the changed tests |
broke the code, tests caught it |
| Jaccard guard | negating the empty-set guard in _jaccard fails the changed tests |
broke the code, tests caught it |
| Months behind | negating the head check in Version.months_behind fails the changed tests |
broke the code, tests caught it |
| Provenance root check | negating the --root directory check in cmd_catalog_provenance fails the changed tests |
broke the code, tests caught it |
| Unreachable raise | the raise added after return skill_dir.as_posix() in _rel (catalog_provenance.py:24) is unreachable, so that broken variant behaves the same |
broke the code, tests caught it |
| Text | _norm_name strips quotes and a carriage return and gives None for a whitespace-only name, and _tokens splits a CRLF text into its words |
ran it, edge input (text) |
| Malformed manifest | truncated JSON, skills that is null or an object, a non-string content, a null name and a top-level list each raise InputError from load_manifest |
ran it, edge input (structured) |
| Manifest paths | a missing manifest, a directory and an empty manifest file each raise InputError from load_manifest |
ran it, edge input (paths) |
| Empty summary | summary of no rows gives zero skills and a null median |
ran it, edge input (numbers) |
| Duplicate upstream name | the same manifest given twice is refused with InputError |
ran it, edge input (collections) |
| No upstream flag | catalog provenance with no upstream flag exits 2 and says needs --upstream |
ran it, edge input (cli) |
| No name or match | a None name gives no match, and to_row(None) gives match: null with the other fields null |
ran it, edge input (none) |
|
|
||
|
|
||
| def _behind_text(row: dict) -> str: | ||
| if row["match"] is None: |
There was a problem hiding this comment.
🟡 Nit: Negating the match is None check in _behind_text (line 28) still passes the suite: an unmatched copy prints unknown where - is expected.
Input: one unmatched skill and one matched skill, text output. With the condition negated the unmatched row's behind column is unknown and the matched row's is -, and the changed tests all stay green. Expected: - for the unmatched skill, pinned by a text-output case.
Suggestion: Add a text-output case with one unmatched skill and assert its behind column is -.
Patch, run on ce9a58d: the tests now catch the broken variant; tests and lint are no worse.
Patch
--- a/dokimi/tests/test_catalog_provenance.py
+++ b/dokimi/tests/test_catalog_provenance.py
@@ -157,6 +157,14 @@
assert lines[1].startswith("# skills (1 under ")
assert lines[2] == "skill\tmatch\tupstream\tversion\tbehind\tedited"
assert lines[3].split("\t")[:2] == ["skills/pdf", "exact"]
+
+
+def test_text_output_shows_a_dash_for_an_unmatched_skill(upstream_repo, tmp_path) -> None:
+ rewritten = V2.split("# PDF")[0] + "# Sailing\nharbour sails tides anchors keel rudder mast hull wind\n"
+ root = _copy_root(tmp_path, {"skills/pdf/SKILL.md": V1, "skills/sail/SKILL.md": rewritten})
+ text = _run(root, "--upstream", str(upstream_repo), fmt="text")["text"]
+ rows = {line.split("\t")[0]: line.split("\t") for line in text.splitlines()[3:]}
+ assert rows["skills/sail"][1:] == ["unmatched", "-", "-", "-", "-"]
def test_a_shallow_clone_is_said_to_see_only_its_own_history(upstream_repo, tmp_path) -> None:| for row in report["skills"]: | ||
| upstream_text = "-" if row["upstream"] is None else f"{row['upstream']}:{row['path']}" | ||
| version = "-" if row["commit"] is None else f"{row['commit']}{' ' + row['date'] if row['date'] else ''}" | ||
| if row["version"]: |
There was a problem hiding this comment.
🟡 Nit: Negating if row["version"]: in _text (line 54) still passes the suite: a version loses its v prefix, and a skill with no version prints vNone.
Input: one skill with version: 1.0 and one with no version, text output. With the condition negated the first line reads 1.0 <commit> and the second reads vNone <commit>, and the changed tests all stay green. Expected: v1.0 <commit>, and no prefix for the unversioned skill, pinned by a text-output case.
Suggestion: Add a text-output case with a versioned and an unversioned skill and assert the version column.
Patch, run on ce9a58d: the tests now catch the broken variant; tests and lint are no worse.
Patch
--- a/dokimi/tests/test_catalog_provenance.py
+++ b/dokimi/tests/test_catalog_provenance.py
@@ -158,6 +158,14 @@
assert lines[2] == "skill\tmatch\tupstream\tversion\tbehind\tedited"
assert lines[3].split("\t")[:2] == ["skills/pdf", "exact"]
+
+
+def test_text_output_prefixes_only_a_skill_with_a_version(upstream_repo, tmp_path) -> None:
+ root = _copy_root(tmp_path, {"skills/pdf/SKILL.md": V2, "skills/old/SKILL.md": V1})
+ text = _run(root, "--upstream", str(upstream_repo), fmt="text")["text"]
+ rows = {line.split("\t")[0]: line.split("\t") for line in text.splitlines()[3:]}
+ assert rows["skills/pdf"][3].startswith("v2 ")
+ assert not rows["skills/old"][3].startswith("v")
def test_a_shallow_clone_is_said_to_see_only_its_own_history(upstream_repo, tmp_path) -> None:
shallow = tmp_path / "shallow"
Summary
Stacked on #838.
catalog checkgets--upstream CHECKOUTand--upstream-manifest FILE(the same inputs ascatalog provenance). Each loaded skill that matches an upstream version gets three findings:Risk codes are
allowed-tools-unrestricted-bash,pipe-to-shell,permission-bypass-flag. The copy side is its own review findings; the upstream side is its SKILL.md alone.Evidence
make ci-localat ce9a58d: 0 failed, 34 passed, 14 skipped.tests/test_catalog_upstream_findings.py(18 functions, 19 cases): stale note, head not stale, unmatched gets nothing, license dropped (edited only), risk inherited (exact and edited), a copy's own risk not inherited,--ignore(also for inherited risks),--strictunchanged, refusal with--per-skilland--kind tasks, bad manifest, no head flag, a head flag on one path not staling another.--ignore, no-head-flag and per-path tests fail on the previous commits and pass here.Decisions
--per-skill: the upstream index is built once in one process;--jobsworkers would each need a copy.license-dropped-from-upstreamonly for dropped licenses: a changed value is not reported.upstream-staleneeds a known head for the matched path: always for a checkout; for a manifest only when an entry of that same path is flagged"head": true. A manifest's top-levelheadblock does not say which entry is head, so no note is given. A skill listed under an old path with no flag gets no note either. Conservative: a note is never a guess. It is a note, so it changes neither the state nor the exit.--ignorealso removes the ignored risk codes from the inherited check: an ignored code is neither inherited nor named.--strict: D5 keeps only unrestricted Bash with a risky command as the strict failure.Merge Danger
Door: two-way. New codes are additive;
--upstreamis opt-in.Blast Radius:
catalog checkoutput for callers who pass the new flags only.FINDING_CODESgrows by three (--ignoreaccepts them). The CLI snapshot gains two flags. Base moved while this was in review (b434f31a0,185fee6cd, both on #838); this branch is rebased onto them.🤖 Generated with Claude Code