morluto/rea

Fork 0

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

[GH-ISSUE #5990] [Bug] Managed graph wrong-role Evidence has inconsistent CLI and MCP diagnostics #3659

New issue

Closed

opened 2026-10-31 00:42:48 +00:00 by bsakaguchi · 1 comment

bsakaguchi commented

2026-10-31 00:42:48 +00:00

Owner

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

Before submitting

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

Area

Evidence, artifacts, or reconstruction

Observed behavior

project_managed_application_graph reports an unchanged, authentic managed inspection record selected for the wrong input role as evidence_integrity_mismatch over MCP, with advice to recreate or re-import it. The CLI rejects the identical input as invalid_request, but its issue has an empty field path and names only the expected operation.

I reproduced this for all three graph input fields using fresh records returned by the public static inspectors. The records authenticate and pass the graph request schema. Selecting the correct record succeeds through both adapters with equal normalized results.

Reproduction

From the source checkout with locked dependencies installed and the runtime already built, run the following. It uses the repository's PE/CLI fixture builder and the actual built stdio MCP server and CLI. The fixture is inspected statically; no assembly execution, external native engine, mocked provider or test runner is involved. Child processes use an isolated home and temporary directory.

node --input-type=module <<'JS'
import assert from 'node:assert/strict';
import { mkdtemp, mkdir, writeFile } from 'node:fs/promises';
import { tmpdir } from 'node:os';
import { join } from 'node:path';
import { spawnSync } from 'node:child_process';
import { Client } from '@modelcontextprotocol/client';
import { StdioClientTransport } from '@modelcontextprotocol/client/stdio';
import { buildManagedPeFixture } from './scripts/fixtures/managed/pe.mjs';
import { parseEvidence } from './dist/domain/evidence.js';
import { projectManagedApplicationGraphInputSchema } from './dist/domain/managed/managedApplicationGraph.js';

const work = await mkdtemp(join(process.env.REA_REPRO_DIRECTORY ?? tmpdir(), 'rea-managed-role-'));
const env = { PATH: process.env.PATH, HOME: join(work, 'home'), TMPDIR: work, REA_LOG_LEVEL: 'silent' };
await mkdir(env.HOME);
const path = join(work, 'fixture.dll');
await writeFile(path, buildManagedPeFixture());
const client = new Client({ name: 'managed-role-reproduction', version: '1' });
const transport = new StdioClientTransport({ command: process.execPath,
  args: [join(process.cwd(), 'scripts/rea.mjs'), 'mcp'], env, stderr: 'pipe' });
transport.stderr?.resume();
const call = (name, input) => client.callTool({ name, arguments: input });
const record = response => {
  assert.notEqual(response.isError, true, JSON.stringify(response));
  return parseEvidence(response.structuredContent);
};
async function cli(input, label, status) {
  const file = join(work, `${label}.json`);
  await writeFile(file, JSON.stringify(input));
  const result = spawnSync(process.execPath,
    ['scripts/rea.mjs', 'project-managed-application-graph', file, '--json'],
    { env, encoding: 'utf8', timeout: 60000, maxBuffer: 16777216 });
  if (result.error) throw result.error;
  assert.equal(result.status, status, result.stderr);
  const output = JSON.parse(result.stdout);
  await writeFile(join(work, `${label}-cli-output.json`), JSON.stringify(output, null, 2));
  return output;
}
try {
  await client.connect(transport);
  const artifact = record(await call('inspect_managed_artifact', { path }));
  const members = record(await call('inspect_managed_members', { path }));
  const boundaries = record(await call('inspect_managed_native_boundaries', { path }));
  for (const [field, wrong, good, expected] of [
    ['managed_members', artifact, members, 'inspect_managed_members'],
    ['managed_artifact', members, artifact, 'inspect_managed_artifact'],
    ['managed_native_boundaries', artifact, boundaries, 'inspect_managed_native_boundaries'],
  ]) {
    const input = { [field]: wrong };
    projectManagedApplicationGraphInputSchema.parse(input);
    assert.deepEqual(parseEvidence(JSON.parse(JSON.stringify(wrong))), wrong);
    const response = await call('project_managed_application_graph', input);
    await writeFile(join(work, `${field}-mcp-output.json`), JSON.stringify(response, null, 2));
    assert.equal(response.isError, true);
    const mcp = JSON.parse(response.content.find(item => item.type === 'text').text).error;
    assert.equal(mcp.code, 'evidence_integrity_mismatch');
    assert.equal(mcp.category, 'integrity_mismatch');
    assert.equal(mcp.details.reason, `Expected ${expected} Evidence, received ${wrong.operation}`);
    assert.equal(mcp.recovery, undefined);
    const command = await cli(input, field, 1);
    assert.equal(command.code, 'invalid_request');
    assert.equal(command.category, 'invalid_input');
    assert.deepEqual(command.details.issues, [{ path: [], reason: 'invalid_value', message: `Evidence operation is not ${expected}` }]);
    assert.equal(command.recovery.kind, 'inspect_input_contract');
    const corrected = { [field]: good };
    const mcpControl = record(await call('project_managed_application_graph', corrected));
    const cliControl = parseEvidence(await cli(corrected, `${field}-control`, 0));
    assert.deepEqual(mcpControl.normalized_result, cliControl.normalized_result);
    console.log(JSON.stringify({ field, supplied: wrong.operation, expected, mcp, cli: command,
      corrected: { mcp: mcpControl.operation, cli: cliControl.operation, equal_results: true } }));
  }
  await client.ping();
  console.log('All three wrong-operation cases and corrected-input controls passed; MCP ping succeeded.');
} finally {
  await client.close();
  await transport.close();
}
JS

The script executed once and exited 0 after asserting each currently incorrect diagnostic and its corrected-input control. It does not assert that the current classification is desirable.

Expected behavior

Treat authentic Evidence selected for the wrong workflow role consistently as invalid_request / invalid_input. Identify the rejected field (managed_artifact, managed_members or managed_native_boundaries), explain the expected and supplied operations, and direct the caller to correct its selection. Preserve integrity errors for actual authentication failures or contradictions within an Evidence record.

The managed graph contract projects authenticated artifact, member and native-boundary Evidence; the shared graph parser assigns the expected operation to each slot. The repository's operating contract requires shared CLI/MCP workflow semantics. The analogous process comparison boundary distinguishes authentication failures from authenticated wrong-role selections, and its MCP regression requires an input error naming the rejected side.

Impact and scope

P2: callers branching on typed diagnostics receive incompatible failure families and recovery actions for the same correctable input selection. MCP advises recreating valid Evidence; CLI names the expected operation but omits the rejected field and supplied operation. No accepted invalid graph, corruption, actual automated retry loop or security boundary crossing was observed.

The demonstrated scope is all three inline graph fields, with one wrong-operation call per field per adapter. Correct record selection is an observed workaround: each corrected request succeeded through both adapters with equal normalized results. Other managed workflows, retained-reference inputs and predicate-only mismatches were not separately exercised.

REA version

rea-agents 6.7.0; source revision 52415975942a4b9c53a817915b313ccc404f280e.

Runtime and platform

macOS 27.0.1 arm64; Node.js v26.12.0. This is admitted by the package's Node engine range; the repository's pinned Node 24.18.0 was not separately tested.

Target and artifact context

Repository-generated managed PE/CLI fixture. Fresh inspect_managed_artifact, inspect_managed_members and inspect_managed_native_boundaries Evidence came from the built production static-inspection tools and was supplied unchanged. No real application assembly or managed runtime was exercised.

Interface

MCP

Earliest failure stage

Request parsing or validation

Relevant output or evidence

For managed_members containing inspect_managed_artifact Evidence, MCP returned isError: true with:

{
  "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": "Expected inspect_managed_members Evidence, received inspect_managed_artifact"
    }
  }
}

The identical request on CLI exited 1 and returned invalid_request / invalid_input, retryable: false, with:

{
  "recovery": {
    "kind": "inspect_input_contract",
    "operation": "project_managed_application_graph"
  },
  "details": {
    "operation": "project_managed_application_graph",
    "issues": [{
      "path": [],
      "reason": "invalid_value",
      "message": "Evidence operation is not inspect_managed_members"
    }]
  }
}

CLI remediation tells the caller to read the declared schema or usage and correct the listed fields. The other two cases had the same diagnostic shapes, with the expected operation changed to inspect_managed_artifact or inspect_managed_native_boundaries.

Each corrected CLI call exited 0; each corrected MCP call succeeded. Both returned project_managed_application_graph Evidence with equal normalized results. The MCP connection remained responsive to ping after all cases.

Typed outcome or recovery expected

invalid_request / invalid_input on both adapters, with details.issues naming the selected field, the expected and actual operation, and recovery.kind: inspect_input_contract for project_managed_application_graph. Recreating unchanged valid Evidence should not be the prescribed recovery for choosing the wrong input record.

Analysis or suspected cause

Source-derived: the MCP resolver authenticates Evidence and then wraps an operation/predicate allowlist failure in EvidenceIntegrityError. The MCP graph handler runs these field-specific checks before the shared application service.

The CLI command calls that service directly. The shared parser throws a plain TypeError containing only the expected operation. The service catch routes it through workflowInputError, which supplies a root-path issue. Field-aware role validation needs to preserve the distinction between a wrong caller selection and the parser's separate internal identity checks.

Additional context

Related but separate report #5988 covers correctly selected managed Evidence with contradictory internal identities being mislabeled invalid_request, requiring an integrity outcome at different guards.

Related #5932 concerns the independent compare_functions operation/predicate gate; #5961 concerns native matching inventory/observation roles. Repairing either leaves these managed resolver and parser checks unchanged.

Closed #4639 concerned authentic native observations explicitly accepted as unsupported by managed/native verification. Its native-observation allowlist was removed; the three managed-role allowlists remain. Merged PR #1089 preserved constraint messages while keeping the existing input-error classification and root paths for later nested validation; it did not reconcile this operation-selection divergence.

Contradictions between a correctly selected record's subject, artifact digest or token scope are a separate integrity case. This reproduction uses internally consistent, unchanged inspector output. A blanket conversion of all managed parser failures to integrity errors would misclassify the selection case above.

The relevant managed parser, service, resolver, graph adapters and contract remain unchanged at fetched origin/main revision 25e1a24a3ed3671a0148757555f18d16c29d936a. That later revision was inspected, not executed. No last-known-good release was established.

Originally created by @coygeek on GitHub (Oct 21, 2026). Original GitHub issue: https://github.com/morluto/rea/issues/5990 ### 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 Evidence, artifacts, or reconstruction ### Observed behavior `project_managed_application_graph` reports an unchanged, authentic managed inspection record selected for the wrong input role as `evidence_integrity_mismatch` over MCP, with advice to recreate or re-import it. The CLI rejects the identical input as `invalid_request`, but its issue has an empty field path and names only the expected operation. I reproduced this for all three graph input fields using fresh records returned by the public static inspectors. The records authenticate and pass the graph request schema. Selecting the correct record succeeds through both adapters with equal normalized results. ### Reproduction From the source checkout with locked dependencies installed and the runtime already built, run the following. It uses the repository's PE/CLI fixture builder and the actual built stdio MCP server and CLI. The fixture is inspected statically; no assembly execution, external native engine, mocked provider or test runner is involved. Child processes use an isolated home and temporary directory. ```sh node --input-type=module <<'JS' import assert from 'node:assert/strict'; import { mkdtemp, mkdir, writeFile } from 'node:fs/promises'; import { tmpdir } from 'node:os'; import { join } from 'node:path'; import { spawnSync } from 'node:child_process'; import { Client } from '@modelcontextprotocol/client'; import { StdioClientTransport } from '@modelcontextprotocol/client/stdio'; import { buildManagedPeFixture } from './scripts/fixtures/managed/pe.mjs'; import { parseEvidence } from './dist/domain/evidence.js'; import { projectManagedApplicationGraphInputSchema } from './dist/domain/managed/managedApplicationGraph.js'; const work = await mkdtemp(join(process.env.REA_REPRO_DIRECTORY ?? tmpdir(), 'rea-managed-role-')); const env = { PATH: process.env.PATH, HOME: join(work, 'home'), TMPDIR: work, REA_LOG_LEVEL: 'silent' }; await mkdir(env.HOME); const path = join(work, 'fixture.dll'); await writeFile(path, buildManagedPeFixture()); const client = new Client({ name: 'managed-role-reproduction', version: '1' }); const transport = new StdioClientTransport({ command: process.execPath, args: [join(process.cwd(), 'scripts/rea.mjs'), 'mcp'], env, stderr: 'pipe' }); transport.stderr?.resume(); const call = (name, input) => client.callTool({ name, arguments: input }); const record = response => { assert.notEqual(response.isError, true, JSON.stringify(response)); return parseEvidence(response.structuredContent); }; async function cli(input, label, status) { const file = join(work, `${label}.json`); await writeFile(file, JSON.stringify(input)); const result = spawnSync(process.execPath, ['scripts/rea.mjs', 'project-managed-application-graph', file, '--json'], { env, encoding: 'utf8', timeout: 60000, maxBuffer: 16777216 }); if (result.error) throw result.error; assert.equal(result.status, status, result.stderr); const output = JSON.parse(result.stdout); await writeFile(join(work, `${label}-cli-output.json`), JSON.stringify(output, null, 2)); return output; } try { await client.connect(transport); const artifact = record(await call('inspect_managed_artifact', { path })); const members = record(await call('inspect_managed_members', { path })); const boundaries = record(await call('inspect_managed_native_boundaries', { path })); for (const [field, wrong, good, expected] of [ ['managed_members', artifact, members, 'inspect_managed_members'], ['managed_artifact', members, artifact, 'inspect_managed_artifact'], ['managed_native_boundaries', artifact, boundaries, 'inspect_managed_native_boundaries'], ]) { const input = { [field]: wrong }; projectManagedApplicationGraphInputSchema.parse(input); assert.deepEqual(parseEvidence(JSON.parse(JSON.stringify(wrong))), wrong); const response = await call('project_managed_application_graph', input); await writeFile(join(work, `${field}-mcp-output.json`), JSON.stringify(response, null, 2)); assert.equal(response.isError, true); const mcp = JSON.parse(response.content.find(item => item.type === 'text').text).error; assert.equal(mcp.code, 'evidence_integrity_mismatch'); assert.equal(mcp.category, 'integrity_mismatch'); assert.equal(mcp.details.reason, `Expected ${expected} Evidence, received ${wrong.operation}`); assert.equal(mcp.recovery, undefined); const command = await cli(input, field, 1); assert.equal(command.code, 'invalid_request'); assert.equal(command.category, 'invalid_input'); assert.deepEqual(command.details.issues, [{ path: [], reason: 'invalid_value', message: `Evidence operation is not ${expected}` }]); assert.equal(command.recovery.kind, 'inspect_input_contract'); const corrected = { [field]: good }; const mcpControl = record(await call('project_managed_application_graph', corrected)); const cliControl = parseEvidence(await cli(corrected, `${field}-control`, 0)); assert.deepEqual(mcpControl.normalized_result, cliControl.normalized_result); console.log(JSON.stringify({ field, supplied: wrong.operation, expected, mcp, cli: command, corrected: { mcp: mcpControl.operation, cli: cliControl.operation, equal_results: true } })); } await client.ping(); console.log('All three wrong-operation cases and corrected-input controls passed; MCP ping succeeded.'); } finally { await client.close(); await transport.close(); } JS ``` The script executed once and exited 0 after asserting each currently incorrect diagnostic and its corrected-input control. It does not assert that the current classification is desirable. ### Expected behavior Treat authentic Evidence selected for the wrong workflow role consistently as `invalid_request` / `invalid_input`. Identify the rejected field (`managed_artifact`, `managed_members` or `managed_native_boundaries`), explain the expected and supplied operations, and direct the caller to correct its selection. Preserve integrity errors for actual authentication failures or contradictions within an Evidence record. The [managed graph contract](https://github.com/morluto/rea/blob/52415975942a4b9c53a817915b313ccc404f280e/src/contracts/managed/managedWorkflowToolContracts.ts#L156-L162) projects authenticated artifact, member and native-boundary Evidence; the [shared graph parser](https://github.com/morluto/rea/blob/52415975942a4b9c53a817915b313ccc404f280e/src/domain/managed/managedApplicationGraph.ts#L206-L232) assigns the expected operation to each slot. The repository's [operating contract](https://github.com/morluto/rea/blob/52415975942a4b9c53a817915b313ccc404f280e/AGENTS.md#L3-L5) requires shared CLI/MCP workflow semantics. The analogous [process comparison boundary](https://github.com/morluto/rea/blob/52415975942a4b9c53a817915b313ccc404f280e/src/server/registerProcessComparisonTool.ts#L55-L78) distinguishes authentication failures from authenticated wrong-role selections, and its [MCP regression](https://github.com/morluto/rea/blob/52415975942a4b9c53a817915b313ccc404f280e/tests/boundary/mcp/processComparisonDiagnosticsMcp.test.ts#L448-L475) requires an input error naming the rejected side. ### Impact and scope P2: callers branching on typed diagnostics receive incompatible failure families and recovery actions for the same correctable input selection. MCP advises recreating valid Evidence; CLI names the expected operation but omits the rejected field and supplied operation. No accepted invalid graph, corruption, actual automated retry loop or security boundary crossing was observed. The demonstrated scope is all three inline graph fields, with one wrong-operation call per field per adapter. Correct record selection is an observed workaround: each corrected request succeeded through both adapters with equal normalized results. Other managed workflows, retained-reference inputs and predicate-only mismatches were not separately exercised. ### REA version `rea-agents` 6.7.0; source revision `52415975942a4b9c53a817915b313ccc404f280e`. ### Runtime and platform macOS 27.0.1 arm64; Node.js v26.12.0. This is admitted by the package's Node engine range; the repository's pinned Node 24.18.0 was not separately tested. ### Target and artifact context Repository-generated managed PE/CLI fixture. Fresh `inspect_managed_artifact`, `inspect_managed_members` and `inspect_managed_native_boundaries` Evidence came from the built production static-inspection tools and was supplied unchanged. No real application assembly or managed runtime was exercised. ### Interface MCP ### Earliest failure stage Request parsing or validation ### Relevant output or evidence For `managed_members` containing `inspect_managed_artifact` Evidence, MCP returned `isError: true` with: ```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": "Expected inspect_managed_members Evidence, received inspect_managed_artifact" } } } ``` The identical request on CLI exited 1 and returned `invalid_request` / `invalid_input`, `retryable: false`, with: ```json { "recovery": { "kind": "inspect_input_contract", "operation": "project_managed_application_graph" }, "details": { "operation": "project_managed_application_graph", "issues": [{ "path": [], "reason": "invalid_value", "message": "Evidence operation is not inspect_managed_members" }] } } ``` CLI remediation tells the caller to read the declared schema or usage and correct the listed fields. The other two cases had the same diagnostic shapes, with the expected operation changed to `inspect_managed_artifact` or `inspect_managed_native_boundaries`. Each corrected CLI call exited 0; each corrected MCP call succeeded. Both returned `project_managed_application_graph` Evidence with equal normalized results. The MCP connection remained responsive to `ping` after all cases. ### Typed outcome or recovery expected `invalid_request` / `invalid_input` on both adapters, with `details.issues` naming the selected field, the expected and actual operation, and `recovery.kind: inspect_input_contract` for `project_managed_application_graph`. Recreating unchanged valid Evidence should not be the prescribed recovery for choosing the wrong input record. ### Analysis or suspected cause Source-derived: the [MCP resolver](https://github.com/morluto/rea/blob/52415975942a4b9c53a817915b313ccc404f280e/src/server/registerManagedWorkflowTools/evidence.ts#L11-L49) authenticates Evidence and then wraps an operation/predicate allowlist failure in `EvidenceIntegrityError`. The [MCP graph handler](https://github.com/morluto/rea/blob/52415975942a4b9c53a817915b313ccc404f280e/src/server/registerManagedWorkflowTools/projectManagedApplicationGraph.ts#L31-L65) runs these field-specific checks before the shared application service. The [CLI command](https://github.com/morluto/rea/blob/52415975942a4b9c53a817915b313ccc404f280e/src/cli/managedProjectGraphCommand.ts#L16-L32) calls that service directly. The [shared parser](https://github.com/morluto/rea/blob/52415975942a4b9c53a817915b313ccc404f280e/src/domain/managed/managedInspectionEvidence.ts#L31-L33) throws a plain `TypeError` containing only the expected operation. The [service catch](https://github.com/morluto/rea/blob/52415975942a4b9c53a817915b313ccc404f280e/src/application/managed/ManagedApplicationGraphService.ts#L37-L44) routes it through [workflowInputError](https://github.com/morluto/rea/blob/52415975942a4b9c53a817915b313ccc404f280e/src/application/workflowInputError.ts#L20-L34), which supplies a root-path issue. Field-aware role validation needs to preserve the distinction between a wrong caller selection and the parser's separate internal identity checks. ### Additional context Related but separate report [#5988](https://github.com/morluto/rea/issues/5988) covers correctly selected managed Evidence with contradictory internal identities being mislabeled `invalid_request`, requiring an integrity outcome at different guards. Related #5932 concerns the independent `compare_functions` operation/predicate gate; #5961 concerns native matching inventory/observation roles. Repairing either leaves these managed resolver and parser checks unchanged. Closed #4639 concerned authentic native observations explicitly accepted as unsupported by managed/native verification. Its native-observation allowlist was removed; the three managed-role allowlists remain. Merged PR #1089 preserved constraint messages while keeping the existing input-error classification and root paths for later nested validation; it did not reconcile this operation-selection divergence. Contradictions between a correctly selected record's subject, artifact digest or token scope are a separate integrity case. This reproduction uses internally consistent, unchanged inspector output. A blanket conversion of all managed parser failures to integrity errors would misclassify the selection case above. The relevant managed parser, service, resolver, graph adapters and contract remain unchanged at fetched `origin/main` revision `25e1a24a3ed3671a0148757555f18d16c29d936a`. That later revision was inspected, not executed. No last-known-good release was established.

bsakaguchi closed this issue

2026-10-31 00:42:48 +00:00

bsakaguchi commented

2026-10-31 00:42:49 +00:00

Author

Owner

@coygeek commented on GitHub (Oct 21, 2026):

The same divergence also reproduces in verify_managed_native_boundaries at 52415975942a4b9c53a817915b313ccc404f280e. Supplying unchanged, authentic inspect_managed_artifact Evidence in managed_boundaries, alongside one authenticated inspect_signature native observation, passes the request schema but returns:

MCP: evidence_integrity_mismatch / integrity_mismatch, with “Expected inspect_managed_native_boundaries Evidence, received inspect_managed_artifact” and recreate/re-import advice.
CLI: exit 1, invalid_request / invalid_input, with issues[0].path: [] and “Evidence operation is not inspect_managed_native_boundaries”.

This was exercised through the built CLI and stdio MCP using the repository's managed PE/CLI fixture. Replacing only the selected record with correct boundary-inspection Evidence succeeds through both adapters with equal normalized results.

The verification handler uses the same boundary resolver, and its domain reader calls the same operation-check parser as the graph boundary slot. The shared repair and regression coverage should therefore include this reader's managed_boundaries field as well as the graph's managed_native_boundaries, preserving field-specific input errors for authentic wrong-role selections and integrity errors for actual record contradictions.

@coygeek commented on GitHub (Oct 21, 2026): The same divergence also reproduces in `verify_managed_native_boundaries` at `52415975942a4b9c53a817915b313ccc404f280e`. Supplying unchanged, authentic `inspect_managed_artifact` Evidence in `managed_boundaries`, alongside one authenticated `inspect_signature` native observation, passes the request schema but returns: - MCP: `evidence_integrity_mismatch` / `integrity_mismatch`, with “Expected inspect_managed_native_boundaries Evidence, received inspect_managed_artifact” and recreate/re-import advice. - CLI: exit 1, `invalid_request` / `invalid_input`, with `issues[0].path: []` and “Evidence operation is not inspect_managed_native_boundaries”. This was exercised through the built CLI and stdio MCP using the repository's managed PE/CLI fixture. Replacing only the selected record with correct boundary-inspection Evidence succeeds through both adapters with equal normalized results. The verification handler uses the [same boundary resolver](https://github.com/morluto/rea/blob/52415975942a4b9c53a817915b313ccc404f280e/src/server/registerManagedWorkflowTools/verifyManagedNativeBoundaries.ts#L36-L43), and its [domain reader](https://github.com/morluto/rea/blob/52415975942a4b9c53a817915b313ccc404f280e/src/domain/managed/managedNativeVerification.ts#L33-L40) calls the same operation-check parser as the [graph boundary slot](https://github.com/morluto/rea/blob/52415975942a4b9c53a817915b313ccc404f280e/src/domain/managed/managedApplicationGraph.ts#L225-L232). The shared repair and regression coverage should therefore include this reader's `managed_boundaries` field as well as the graph's `managed_native_boundaries`, preserving field-specific input errors for authentic wrong-role selections and integrity errors for actual record contradictions.

bsakaguchi referenced this issue

2026-10-31 01:10:03 +00:00

[PR #3659] fix(security): harden archive and Hopper probes #5868

bsakaguchi referenced this issue

2026-11-01 21:11:07 +00:00

[GH-ISSUE #5654] [Tracker] Open PRs that can't merge yet: conflicts and red CI (October 2026) #3425