morluto/rea

Fork 0

mirror of https://github.com/morluto/rea.git synced 2026-11-05 06:45:22 +00:00

[GH-ISSUE #7603] [Bug] Divergent unknown-history import recommends re-importing an unchanged valid bundle #4531

New issue

Closed

opened 2026-10-31 00:50:32 +00:00 by bsakaguchi · 0 comments

bsakaguchi commented

2026-10-31 00:50:32 +00:00

Owner

Originally created by @coygeek on GitHub (Oct 27, 2026).
Original GitHub issue: https://github.com/morluto/rea/issues/7603

Before submitting

I searched the open and closed issues for a related report.
I removed credentials, tokens, private paths, and sensitive target data.

Area

MCP or agent integration

Observed behavior

After importing one exported investigation branch, this MCP request refuses a second, independently valid branch whose revision 2 of the same residual unknown has a different status:

{"name":"import_evidence_bundle","arguments":{"path":"<absolute path to second exported branch>"}}

The refusal reports evidence_integrity_mismatch, says the Evidence is invalid or changed, and recommends recreating or re-importing it. Repeating the same import gives the same refusal. Its only detail is reason: "Conflicting unknown revision"; it does not identify which unknown or revision conflicts. Both exported branches import successfully in fresh sessions, pass standalone CLI validation, and re-export byte-for-byte. The retained session bundle remains unchanged after each refusal.

Atomic rejection of divergent immutable histories is expected. The defect is the canonical message and recovery instruction treating this retained/incoming history collision as something re-importing the valid bundle can repair.

Reproduction

Start at the baseline below with locked dependencies, the prepared dist/ build and Node.js 24.22.1 on PATH. Python 3 is used only to build fixtures and launch the commands. No analysis engine is needed.
Run this block from the checkout root. It isolates every REA process's HOME/XDG paths, creates both branches through real stdio MCP tools, tries both merge orders twice, checks full retained-bundle equality, validates each branch independently, and removes the fixtures on exit. REA_VERIFY_SCRATCH optionally selects the parent of its disposable directory.

python3 - <<'PYREPLAY'
import json, os, pathlib, subprocess, tempfile, zipfile

env = {k: v for k, v in os.environ.items()
       if not k.startswith(('REA_', 'HOPPER_', 'GHIDRA_'))}
env.update(REA_LOG_LEVEL='silent', NODE_DISABLE_COMPILE_CACHE='1')
with tempfile.TemporaryDirectory(dir=os.environ.get('REA_VERIFY_SCRATCH')) as directory:
    root = pathlib.Path(directory)
    for key in ('HOME', 'XDG_CONFIG_HOME', 'XDG_CACHE_HOME', 'XDG_DATA_HOME',
                'XDG_STATE_HOME', 'TMPDIR'):
        folder = root / key.lower()
        folder.mkdir()
        env[key] = str(folder)
    env['REPRO_DIR'] = str(root)
    def run(*args, source=None):
        result = subprocess.run(['node', *args], input=source, env=env,
            capture_output=True, text=True, timeout=120)
        assert result.returncode == 0, result.stdout + result.stderr
        assert not result.stderr, result.stderr
        return result.stdout
    with zipfile.ZipFile(root / 'fixture.zip', 'w') as archive:
        archive.writestr('a.txt', 'hello\n')
        archive.writestr('b.txt', 'second\n')
    run('scripts/rea.mjs', 'inspect-artifact', str(root / 'fixture.zip'),
        '--evidence_output', str(root / 'base.json'), '--format', 'json')
    print(run('--input-type=module', source=r'''
import assert from 'node:assert/strict';
import {readFileSync} from 'node:fs';
import {join} from 'node:path';
import {Client} from '@modelcontextprotocol/client';
import {StdioClientTransport} from '@modelcontextprotocol/client/stdio';
const root = process.env.REPRO_DIR;
const id = JSON.parse(readFileSync(join(root, 'base.json'), 'utf8')).records[0].evidence_id;
async function connect() {
  const c = new Client({name: 'unknown-merge-check', version: '1'});
  await c.connect(new StdioClientTransport({command: process.execPath,
    args: ['dist/main.js'], cwd: process.cwd(), env: process.env, stderr: 'pipe'}));
  return c;
}
async function call(c, name, args = {}) {
  return JSON.parse((await c.callTool({name, arguments: args})).content[0].text);
}
async function good(c, name, args = {}) {
  const r = await call(c, name, args);
  assert.ok(!r.error, JSON.stringify(r));
  return r.result;
}
const input = {question: 'Can this unknown history merge?', severity: 'medium',
  domain: 'evidence', required_confidence: 'observed', supporting_evidence_ids: [id],
  required_authority: null, required_environment: null, recommended_probes: [], relationships: []};
for (const [status, file] of [['investigating', 'a.json'], ['blocked', 'b.json']]) {
  const c = await connect();
  try {
    await good(c, 'import_evidence_bundle', {path: join(root, 'base.json')});
    const u = await good(c, 'record_unknown', input);
    const updated = await good(c, 'update_unknown', {unknown_id: u.unknown_id,
      expected_revision: 1, status, severity: 'medium', supporting_evidence_ids: [id],
      contradicting_evidence_ids: [], required_authority: null, required_confidence: 'observed',
      required_environment: null, recommended_probes: [], relationships: [], resolution: null});
    assert.equal(updated.revision, 2);
    await good(c, 'export_evidence_bundle', {path: join(root, file)});
  } finally { await c.close(); }
}
for (const [first, second] of [['a.json', 'b.json'], ['b.json', 'a.json']]) {
  const c = await connect();
  try {
    await good(c, 'import_evidence_bundle', {path: join(root, first)});
    const before = await good(c, 'get_evidence_bundle');
    for (let attempt = 1; attempt <= 2; attempt++) {
      const result = await call(c, 'import_evidence_bundle', {path: join(root, second)});
      assert.equal(result.error.code, 'evidence_integrity_mismatch');
      assert.equal(result.error.details.reason, 'Conflicting unknown revision');
      assert.deepEqual(await good(c, 'get_evidence_bundle'), before);
      console.log(JSON.stringify({first, second, attempt, error: result.error, unchanged: true}));
    }
  } finally { await c.close(); }
}
'''), end='')
    for name in ('a', 'b'):
        source = root / (name + '.json')
        target = root / (name + '.canonical.json')
        imported = json.loads(run('scripts/rea.mjs', 'evidence-import', str(source), '--json'))
        assert imported == {'imported': 4, 'unknowns_added': 2, 'total': 4}
        run('scripts/rea.mjs', 'evidence-export', str(source), str(target), '--json')
        assert source.read_bytes() == target.read_bytes()
        print(name + ': standalone import succeeded; canonical bytes unchanged')
PYREPLAY

Each of the four merge attempts prints the diagnostic below with unchanged: true. The controls then print:

a: standalone import succeeded; canonical bytes unchanged
b: standalone import succeeded; canonical bytes unchanged

The original replay and two executions of the reduced reproduction each produced the same four refusals: twelve matching attempts across both import orders. These executions include repeats of each unchanged import rather than independent random fixtures.

Expected behavior

Keep rejecting divergent unknown histories atomically, while reporting that the incoming history conflicts with history retained by this session. Recovery should explain that re-importing unchanged content into the unchanged session cannot resolve it. It should direct callers to inspect or select the relevant histories, or explicitly state that combining them requires reconciliation outside the available import operation. An unknown ID and revision would make the refusal easier to act on, but no particular new code or details layout is required by this report.

The repository's Architecture and Cleanup invariant requires meaningful failure reasons and preserved identity across boundaries. The import contract promises authenticated, atomic merging, and the existing ledger regression expressly requires rejection of divergent heads. The proposed correction preserves that rejection; it does not request automatic conflict resolution. Source locators are in Evidence below.

Impact and scope

P2: the canonical remediation gives ineffective recovery advice for a bounded investigation-handoff conflict. The observed retry never succeeds, and the error omits the identity needed to locate the conflicting history. Both branches remain valid and usable independently in fresh sessions, which is a demonstrated way to inspect either history. A supported lossless way to combine both conflicting histories was not established.

The complete session bundle stayed unchanged after every refused import. No corruption, data loss, automatic retry loop, discarded investigation, or production occurrence rate was observed. Only the two-revision, one-unknown fixture and the stated runtime were tested. Longer histories, inter-unknown relationships, and repairing a conflict through later updates were not executed.

REA version

Exact node scripts/rea.mjs --version output:

6.8.0

Source baseline: 65f1c447344a423fa2785847dbcea1e9a9e2454a.

Runtime and platform

Node.js v24.22.1; macOS 27.0.1; arm64. Used the prepared source-checkout build; no runtime rebuild or dependency installation was performed during verification.

Target and artifact context

A synthetic ZIP with two short text entries supplies authentic supporting Evidence through inspect-artifact. Two separate MCP sessions record the same question and update revision 2 to investigating versus blocked, then export their own canonical bundles. No binary is opened, no target code executes, and no Hopper, Ghidra or GUI application is required.

Interface

MCP

Earliest failure stage

Artifact or evidence registration

Relevant output or evidence

The second import in each order returns isError: true and the following decoded MCP text content. Repeating the identical request returns the same fields:

{"error":{"code":"evidence_integrity_mismatch","category":"integrity_mismatch","message":"Evidence is invalid or has changed. Recreate or re-import it, then try again.","retryable":false,"remediation":{"action":"Evidence is invalid or has changed. Recreate or re-import it, then try again."},"details":{"reason":"Conflicting unknown revision"}}}

There is no recovery field. The first import succeeds with imported: 4, unknowns_added: 2, total: 4. Standalone CLI imports return those same counts with exit 0. Both CLI exports succeed, and direct byte comparison confirms each exported branch is already canonical. The reproduction asserts equality of the complete retained bundle before and after each rejected merge.

Source at the baseline:

AGENTS.md, Architecture and Cleanup: preserve identity and meaningful failure reasons across boundaries.
src/contracts/sessionToolContracts.ts:92-95: supported authenticated atomic import operation.
src/application/investigation/EvidenceLedger.residualUnknown.test.ts:391-443: divergent heads must be rejected atomically.
src/application/investigation/EvidenceLedger.ts:140-149: finds an existing equal unknown-ID/revision key with a different revision digest and returns the conflict reason before committing.
src/server/registerSessionRecordTools.ts:110-137: authenticates the selected file, attempts the session merge and projects the refusal through MCP.
src/domain/analysisErrorPresentation.ts:320-321 supplies the invalid-or-changed/re-import wording; src/domain/analysisErrorProjection.ts:383 emits the reason string without the conflicting identity.

Typed outcome or recovery expected

A nonretryable refusal describing the retained/incoming unknown-history conflict and an honest recovery limitation or achievable next action. Preserve authentication checks, divergent-history rejection and complete session atomicity. The exact code, new fields and replacement wording remain implementation choices.

Analysis or suspected cause

Source-derived: the merge conflict uses the general Evidence integrity error without a specific user message, so the shared presentation supplies generic re-import guidance. The ledger knows the existing and incoming revisions when rejecting, but that context is not carried in the error. This explains the observed projection; no implementation fix was made or tested.

Additional context

The open/closed issue and PR search found no matching report whose closure would fix this recovery instruction for valid divergent histories.

#7562, closed #2050 and closed #5932 concern selecting authentic Evidence of the wrong kind or role. These inputs are complete, authentic bundles with conflicting histories.
#7330 and open PR #7358 concern noncanonical record-order diagnostics. Both bundles here are canonical.
Closed #5396 concerns duplicate creation incorrectly marked retryable; closed #3925 concerns deterministic comparison replay that should succeed. This report retains nonretryable import rejection.
Closed #5921 uses an unknown-history conflict to expose failed target-state restoration. Its closure requires restoring the prior profile and explicitly preserves conflict rejection; no target switch occurs here.
Open #3005 concerns update_unknown failing, while branch updates succeed here. Closed #6300 and merged PR #6321 concern malformed residual graphs, while both generated branches here authenticate.

No last-known-good version or regression of those closed fixes is claimed. Documentation does not establish a mandatory import-conflict code or digest-field schema. The narrower failure-reason and recovery correction is sufficient.

Triage assessment

Impact level: P2
Assessment status: supported
Impact basis: The supported import path gives ineffective canonical recovery advice for valid conflicting histories; unchanged retries fail in both orders, while retained state stays intact. No general outage or data loss was observed.
Workaround status: available
Workaround basis: Each branch imports successfully in a fresh session and can be inspected independently, preserving its own history. This avoids the misleading retry instruction; it does not establish a way to combine both histories.

Originally created by @coygeek on GitHub (Oct 27, 2026). Original GitHub issue: https://github.com/morluto/rea/issues/7603 ### Before submitting - [x] I searched the open and closed issues for a related report. - [x] I removed credentials, tokens, private paths, and sensitive target data. ### Area MCP or agent integration ### Observed behavior After importing one exported investigation branch, this MCP request refuses a second, independently valid branch whose revision 2 of the same residual unknown has a different status: ```json {"name":"import_evidence_bundle","arguments":{"path":"<absolute path to second exported branch>"}} ``` The refusal reports `evidence_integrity_mismatch`, says the Evidence is invalid or changed, and recommends recreating or re-importing it. Repeating the same import gives the same refusal. Its only detail is `reason: "Conflicting unknown revision"`; it does not identify which unknown or revision conflicts. Both exported branches import successfully in fresh sessions, pass standalone CLI validation, and re-export byte-for-byte. The retained session bundle remains unchanged after each refusal. Atomic rejection of divergent immutable histories is expected. The defect is the canonical message and recovery instruction treating this retained/incoming history collision as something re-importing the valid bundle can repair. ### Reproduction 1. Start at the baseline below with locked dependencies, the prepared `dist/` build and Node.js 24.22.1 on PATH. Python 3 is used only to build fixtures and launch the commands. No analysis engine is needed. 2. Run this block from the checkout root. It isolates every REA process's HOME/XDG paths, creates both branches through real stdio MCP tools, tries both merge orders twice, checks full retained-bundle equality, validates each branch independently, and removes the fixtures on exit. `REA_VERIFY_SCRATCH` optionally selects the parent of its disposable directory. ```sh python3 - <<'PYREPLAY' import json, os, pathlib, subprocess, tempfile, zipfile env = {k: v for k, v in os.environ.items() if not k.startswith(('REA_', 'HOPPER_', 'GHIDRA_'))} env.update(REA_LOG_LEVEL='silent', NODE_DISABLE_COMPILE_CACHE='1') with tempfile.TemporaryDirectory(dir=os.environ.get('REA_VERIFY_SCRATCH')) as directory: root = pathlib.Path(directory) for key in ('HOME', 'XDG_CONFIG_HOME', 'XDG_CACHE_HOME', 'XDG_DATA_HOME', 'XDG_STATE_HOME', 'TMPDIR'): folder = root / key.lower() folder.mkdir() env[key] = str(folder) env['REPRO_DIR'] = str(root) def run(*args, source=None): result = subprocess.run(['node', *args], input=source, env=env, capture_output=True, text=True, timeout=120) assert result.returncode == 0, result.stdout + result.stderr assert not result.stderr, result.stderr return result.stdout with zipfile.ZipFile(root / 'fixture.zip', 'w') as archive: archive.writestr('a.txt', 'hello\n') archive.writestr('b.txt', 'second\n') run('scripts/rea.mjs', 'inspect-artifact', str(root / 'fixture.zip'), '--evidence_output', str(root / 'base.json'), '--format', 'json') print(run('--input-type=module', source=r''' import assert from 'node:assert/strict'; import {readFileSync} from 'node:fs'; import {join} from 'node:path'; import {Client} from '@modelcontextprotocol/client'; import {StdioClientTransport} from '@modelcontextprotocol/client/stdio'; const root = process.env.REPRO_DIR; const id = JSON.parse(readFileSync(join(root, 'base.json'), 'utf8')).records[0].evidence_id; async function connect() { const c = new Client({name: 'unknown-merge-check', version: '1'}); await c.connect(new StdioClientTransport({command: process.execPath, args: ['dist/main.js'], cwd: process.cwd(), env: process.env, stderr: 'pipe'})); return c; } async function call(c, name, args = {}) { return JSON.parse((await c.callTool({name, arguments: args})).content[0].text); } async function good(c, name, args = {}) { const r = await call(c, name, args); assert.ok(!r.error, JSON.stringify(r)); return r.result; } const input = {question: 'Can this unknown history merge?', severity: 'medium', domain: 'evidence', required_confidence: 'observed', supporting_evidence_ids: [id], required_authority: null, required_environment: null, recommended_probes: [], relationships: []}; for (const [status, file] of [['investigating', 'a.json'], ['blocked', 'b.json']]) { const c = await connect(); try { await good(c, 'import_evidence_bundle', {path: join(root, 'base.json')}); const u = await good(c, 'record_unknown', input); const updated = await good(c, 'update_unknown', {unknown_id: u.unknown_id, expected_revision: 1, status, severity: 'medium', supporting_evidence_ids: [id], contradicting_evidence_ids: [], required_authority: null, required_confidence: 'observed', required_environment: null, recommended_probes: [], relationships: [], resolution: null}); assert.equal(updated.revision, 2); await good(c, 'export_evidence_bundle', {path: join(root, file)}); } finally { await c.close(); } } for (const [first, second] of [['a.json', 'b.json'], ['b.json', 'a.json']]) { const c = await connect(); try { await good(c, 'import_evidence_bundle', {path: join(root, first)}); const before = await good(c, 'get_evidence_bundle'); for (let attempt = 1; attempt <= 2; attempt++) { const result = await call(c, 'import_evidence_bundle', {path: join(root, second)}); assert.equal(result.error.code, 'evidence_integrity_mismatch'); assert.equal(result.error.details.reason, 'Conflicting unknown revision'); assert.deepEqual(await good(c, 'get_evidence_bundle'), before); console.log(JSON.stringify({first, second, attempt, error: result.error, unchanged: true})); } } finally { await c.close(); } } '''), end='') for name in ('a', 'b'): source = root / (name + '.json') target = root / (name + '.canonical.json') imported = json.loads(run('scripts/rea.mjs', 'evidence-import', str(source), '--json')) assert imported == {'imported': 4, 'unknowns_added': 2, 'total': 4} run('scripts/rea.mjs', 'evidence-export', str(source), str(target), '--json') assert source.read_bytes() == target.read_bytes() print(name + ': standalone import succeeded; canonical bytes unchanged') PYREPLAY ``` 3. Each of the four merge attempts prints the diagnostic below with `unchanged: true`. The controls then print: ```text a: standalone import succeeded; canonical bytes unchanged b: standalone import succeeded; canonical bytes unchanged ``` The original replay and two executions of the reduced reproduction each produced the same four refusals: twelve matching attempts across both import orders. These executions include repeats of each unchanged import rather than independent random fixtures. ### Expected behavior Keep rejecting divergent unknown histories atomically, while reporting that the incoming history conflicts with history retained by this session. Recovery should explain that re-importing unchanged content into the unchanged session cannot resolve it. It should direct callers to inspect or select the relevant histories, or explicitly state that combining them requires reconciliation outside the available import operation. An unknown ID and revision would make the refusal easier to act on, but no particular new code or details layout is required by this report. The repository's Architecture and Cleanup invariant requires meaningful failure reasons and preserved identity across boundaries. The import contract promises authenticated, atomic merging, and the existing ledger regression expressly requires rejection of divergent heads. The proposed correction preserves that rejection; it does not request automatic conflict resolution. Source locators are in Evidence below. ### Impact and scope P2: the canonical remediation gives ineffective recovery advice for a bounded investigation-handoff conflict. The observed retry never succeeds, and the error omits the identity needed to locate the conflicting history. Both branches remain valid and usable independently in fresh sessions, which is a demonstrated way to inspect either history. A supported lossless way to combine both conflicting histories was not established. The complete session bundle stayed unchanged after every refused import. No corruption, data loss, automatic retry loop, discarded investigation, or production occurrence rate was observed. Only the two-revision, one-unknown fixture and the stated runtime were tested. Longer histories, inter-unknown relationships, and repairing a conflict through later updates were not executed. ### REA version Exact `node scripts/rea.mjs --version` output: ```text 6.8.0 ``` Source baseline: `65f1c447344a423fa2785847dbcea1e9a9e2454a`. ### Runtime and platform Node.js v24.22.1; macOS 27.0.1; arm64. Used the prepared source-checkout build; no runtime rebuild or dependency installation was performed during verification. ### Target and artifact context A synthetic ZIP with two short text entries supplies authentic supporting Evidence through `inspect-artifact`. Two separate MCP sessions record the same question and update revision 2 to `investigating` versus `blocked`, then export their own canonical bundles. No binary is opened, no target code executes, and no Hopper, Ghidra or GUI application is required. ### Interface MCP ### Earliest failure stage Artifact or evidence registration ### Relevant output or evidence The second import in each order returns `isError: true` and the following decoded MCP text content. Repeating the identical request returns the same fields: ```json {"error":{"code":"evidence_integrity_mismatch","category":"integrity_mismatch","message":"Evidence is invalid or has changed. Recreate or re-import it, then try again.","retryable":false,"remediation":{"action":"Evidence is invalid or has changed. Recreate or re-import it, then try again."},"details":{"reason":"Conflicting unknown revision"}}} ``` There is no `recovery` field. The first import succeeds with `imported: 4`, `unknowns_added: 2`, `total: 4`. Standalone CLI imports return those same counts with exit 0. Both CLI exports succeed, and direct byte comparison confirms each exported branch is already canonical. The reproduction asserts equality of the complete retained bundle before and after each rejected merge. Source at the baseline: - `AGENTS.md`, Architecture and Cleanup: preserve identity and meaningful failure reasons across boundaries. - `src/contracts/sessionToolContracts.ts:92-95`: supported authenticated atomic import operation. - `src/application/investigation/EvidenceLedger.residualUnknown.test.ts:391-443`: divergent heads must be rejected atomically. - `src/application/investigation/EvidenceLedger.ts:140-149`: finds an existing equal unknown-ID/revision key with a different revision digest and returns the conflict reason before committing. - `src/server/registerSessionRecordTools.ts:110-137`: authenticates the selected file, attempts the session merge and projects the refusal through MCP. - `src/domain/analysisErrorPresentation.ts:320-321` supplies the invalid-or-changed/re-import wording; `src/domain/analysisErrorProjection.ts:383` emits the reason string without the conflicting identity. ### Typed outcome or recovery expected A nonretryable refusal describing the retained/incoming unknown-history conflict and an honest recovery limitation or achievable next action. Preserve authentication checks, divergent-history rejection and complete session atomicity. The exact code, new fields and replacement wording remain implementation choices. ### Analysis or suspected cause Source-derived: the merge conflict uses the general Evidence integrity error without a specific user message, so the shared presentation supplies generic re-import guidance. The ledger knows the existing and incoming revisions when rejecting, but that context is not carried in the error. This explains the observed projection; no implementation fix was made or tested. ### Additional context The open/closed issue and PR search found no matching report whose closure would fix this recovery instruction for valid divergent histories. - [#7562](https://github.com/morluto/rea/issues/7562), closed [#2050](https://github.com/morluto/rea/issues/2050) and closed [#5932](https://github.com/morluto/rea/issues/5932) concern selecting authentic Evidence of the wrong kind or role. These inputs are complete, authentic bundles with conflicting histories. - [#7330](https://github.com/morluto/rea/issues/7330) and open [PR #7358](https://github.com/morluto/rea/pull/7358) concern noncanonical record-order diagnostics. Both bundles here are canonical. - Closed [#5396](https://github.com/morluto/rea/issues/5396) concerns duplicate creation incorrectly marked retryable; closed [#3925](https://github.com/morluto/rea/issues/3925) concerns deterministic comparison replay that should succeed. This report retains nonretryable import rejection. - Closed [#5921](https://github.com/morluto/rea/issues/5921) uses an unknown-history conflict to expose failed target-state restoration. Its closure requires restoring the prior profile and explicitly preserves conflict rejection; no target switch occurs here. - Open [#3005](https://github.com/morluto/rea/issues/3005) concerns `update_unknown` failing, while branch updates succeed here. Closed [#6300](https://github.com/morluto/rea/issues/6300) and merged [PR #6321](https://github.com/morluto/rea/pull/6321) concern malformed residual graphs, while both generated branches here authenticate. No last-known-good version or regression of those closed fixes is claimed. Documentation does not establish a mandatory import-conflict code or digest-field schema. The narrower failure-reason and recovery correction is sufficient. ## Triage assessment - Impact level: P2 - Assessment status: supported - Impact basis: The supported import path gives ineffective canonical recovery advice for valid conflicting histories; unchanged retries fail in both orders, while retained state stays intact. No general outage or data loss was observed. - Workaround status: available - Workaround basis: Each branch imports successfully in a fresh session and can be inspected independently, preserving its own history. This avoids the misleading retry instruction; it does not establish a way to combine both histories.

bsakaguchi closed this issue

2026-10-31 00:50:33 +00:00

bsakaguchi referenced this issue

2026-10-31 01:13:20 +00:00

[PR #4531] [MERGED] fix(ghidra): reject byte matches outside searched coverage #6293