{"prompt":"You are comparing an AI-suggested code fix with actual changes made in a commit.\n\nYour task: Determine if the commit contains the essence of the AI fix and provide a confidence level.\n\n## AI-Suggested Fix\n\n**What it fixes:** e2e-angular:e2e-ci--src/config.test.ts, e2e-nx:e2e-ci--src/spread.test.ts, e2e-plugin:e2e-ci--src/nx-plugin.test.ts, nx:lint\n\n**Description:** fix(nx): remove eslint import/order comments\n\n**Reasoning:** The new `task-file-resolver.spec.ts` file placed `jest.mock()` calls before the imports they affect (required for Babel/SWC hoisting to work correctly), then added `// eslint-disable-next-line import/order` comments on each of those late imports to suppress any potential import-ordering warnings.\n\nHowever, `eslint-plugin-import` is not installed or configured in this workspace's ESLint setup. When ESLint encounters an inline disable comment that references an unknown rule, it does not silently i\n\n**Suggested Changes (diff):**\n```diff\ndiff --git a/packages/nx/src/hasher/task-file-resolver.spec.ts b/packages/nx/src/hasher/task-file-resolver.spec.ts\nindex 6273207b..d917c054 100644\n--- a/packages/nx/src/hasher/task-file-resolver.spec.ts\n+++ b/packages/nx/src/hasher/task-file-resolver.spec.ts\n@@ -19,11 +19,8 @@ jest.mock('../tasks-runner/utils', () => ({\n \n // ── Imports (after mocks) ────────────────────────────────────────────────────\n \n-// eslint-disable-next-line import/order\n import { HashPlanInspector } from './hash-plan-inspector';\n-// eslint-disable-next-line import/order\n import { getOutputsForTargetAndConfiguration } from '../tasks-runner/utils';\n-// eslint-disable-next-line import/order\n import { createTaskFileResolver } from './task-file-resolver';\n \n const MockHashPlanInspector = jest.mocked(HashPlanInspector);\n\n```\n\n## Actual Commit Changes\n\n**Commit Diff:**\n```diff\ndiff --git a/packages/nx/src/command-line/show/show-target/inputs.ts b/packages/nx/src/command-line/show/show-target/inputs.ts\nindex 744d308232e5b..9ba6af3f66ac8 100644\n--- a/packages/nx/src/command-line/show/show-target/inputs.ts\n+++ b/packages/nx/src/command-line/show/show-target/inputs.ts\n@@ -1,7 +1,6 @@\n import type { TargetConfiguration } from '../../../config/workspace-json-project-json';\n import type { HashInputs } from '../../../native';\n-import { workspaceRoot } from '../../../utils/workspace-root';\n-import { handleImport } from '../../../utils/handle-import';\n+import { createTaskFileResolver } from '../../../hasher/task-file-resolver';\n import type { ShowTargetInputsOptions } from '../command-object';\n import {\n resolveTarget,\n@@ -10,7 +9,6 @@ import {\n hasCustomHasher,\n pc,\n printList,\n- type ResolvedTarget,\n } from './utils';\n \n // ── Handler ─────────────────────────────────────────────────────────\n@@ -32,16 +30,29 @@ export async function showTargetInputsHandler(\n return;\n }\n \n- const hashInputs = await resolveInputFiles(t);\n+ const { projectName, targetName, configuration } = t;\n+ const taskId = configuration\n+ ? `${projectName}:${targetName}:${configuration}`\n+ : `${projectName}:${targetName}`;\n+\n+ const resolver = await createTaskFileResolver({\n+ projectGraph: t.graph,\n+ nxJson: t.nxJson,\n+ });\n+\n+ const hashInputs = resolver.getRawInputs(taskId);\n+ if (!hashInputs) {\n+ throw new Error(`Could not find hash plan for task \"${taskId}\".`);\n+ }\n \n if (args.check !== undefined) {\n const checkItems = deduplicateFolderEntries(args.check);\n const results = checkItems.map((input) =>\n- resolveCheckFromInputs(input, t.projectName, t.targetName, hashInputs)\n+ resolveCheckFromInputs(input, projectName, targetName, hashInputs)\n );\n \n if (results.length >= 2) {\n- renderBatchCheckInputs(results, t.projectName, t.targetName);\n+ renderBatchCheckInputs(results, projectName, targetName);\n } else {\n for (const data of results) renderCheckInput(data);\n }\n@@ -54,8 +65,8 @@ export async function showTargetInputsHandler(\n }\n \n renderInputs(\n- { project: t.projectName, target: t.targetName, ...hashInputs },\n- t.node.data.targets[t.targetName].inputs,\n+ { project: projectName, target: targetName, ...hashInputs },\n+ t.node.data.targets[targetName].inputs,\n args\n );\n }\n@@ -64,36 +75,6 @@ export async function showTargetInputsHandler(\n \n type CheckInputResult = ReturnType;\n \n-async function resolveInputFiles(t: ResolvedTarget): Promise {\n- const { projectName, targetName, configuration, graph, nxJson } = t;\n- const { HashPlanInspector } = (await handleImport(\n- '../../../hasher/hash-plan-inspector.js',\n- __dirname\n- )) as typeof import('../../../hasher/hash-plan-inspector');\n-\n- const inspector = new HashPlanInspector(graph, workspaceRoot, nxJson);\n- await inspector.init();\n-\n- const plan = inspector.inspectTaskInputs({\n- project: projectName,\n- target: targetName,\n- configuration,\n- });\n-\n- const targetConfig = graph.nodes[projectName]?.data?.targets?.[targetName];\n- const effectiveConfig = configuration ?? targetConfig?.defaultConfiguration;\n- const taskId = effectiveConfig\n- ? `${projectName}:${targetName}:${effectiveConfig}`\n- : `${projectName}:${targetName}`;\n- const result = plan[taskId];\n- if (!result) {\n- throw new Error(\n- `Could not find hash plan for task \"${taskId}\". Available tasks: ${Object.keys(plan).join(', ')}`\n- );\n- }\n- return result;\n-}\n-\n function resolveCheckFromInputs(\n rawValue: string,\n projectName: string,\ndiff --git a/packages/nx/src/command-line/show/show-target/outputs.ts b/packages/nx/src/command-line/show/show-target/outputs.ts\nindex 2415b0d045e3d..0b3f34d47a551 100644\n--- a/packages/nx/src/command-line/show/show-target/outputs.ts\n+++ b/packages/nx/src/command-line/show/show-target/outputs.ts\n@@ -1,4 +1,7 @@\n-import { getOutputsForTargetAndConfiguration } from '../../../tasks-runner/utils';\n+import {\n+ createTaskFileResolver,\n+ type TaskFileResolver,\n+} from '../../../hasher/task-file-resolver';\n import { workspaceRoot } from '../../../utils/workspace-root';\n import type { ShowTargetOutputsOptions } from '../command-object';\n import {\n@@ -16,12 +19,22 @@ export async function showTargetOutputsHandler(\n args: ShowTargetOutputsOptions\n ): Promise {\n const t = await resolveTarget(args);\n- const outputsData = resolveOutputsData(t);\n+\n+ const taskId = t.configuration\n+ ? `${t.projectName}:${t.targetName}:${t.configuration}`\n+ : `${t.projectName}:${t.targetName}`;\n+\n+ const resolver = await createTaskFileResolver({\n+ projectGraph: t.graph,\n+ nxJson: t.nxJson,\n+ });\n+\n+ const outputsData = resolveOutputsData(t, resolver, taskId);\n \n if (args.check !== undefined) {\n const checkItems = deduplicateFolderEntries(args.check);\n const results = checkItems.map((o) =>\n- resolveCheckOutputData(o, outputsData)\n+ resolveCheckOutputData(o, outputsData, resolver, taskId)\n );\n \n if (results.length >= 2) {\n@@ -49,13 +62,15 @@ export async function showTargetOutputsHandler(\n type OutputsData = ReturnType;\n type CheckOutputResult = ReturnType;\n \n-function resolveOutputsData(t: ResolvedTarget) {\n+function resolveOutputsData(\n+ t: ResolvedTarget,\n+ resolver: TaskFileResolver,\n+ taskId: string\n+) {\n const { projectName, targetName, configuration, node } = t;\n- const resolvedOutputs = getOutputsForTargetAndConfiguration(\n- { project: projectName, target: targetName, configuration },\n- {},\n- node\n- );\n+ // Use the resolver to obtain resolved output paths — avoids duplicating\n+ // the getOutputsForTargetAndConfiguration call that the resolver already makes.\n+ const resolvedOutputs = resolver.getOutputs(taskId);\n \n const targetConfig = node.data.targets?.[targetName];\n const configuredOutputs: string[] = targetConfig?.outputs ?? [];\n@@ -93,25 +108,17 @@ function resolveOutputsData(t: ResolvedTarget) {\n \n function resolveCheckOutputData(\n rawFileToCheck: string,\n- outputsData: OutputsData\n+ outputsData: OutputsData,\n+ resolver: TaskFileResolver,\n+ taskId: string\n ) {\n const fileToCheck = normalizePath(rawFileToCheck);\n const { outputPaths, expandedOutputs } = outputsData;\n \n- let matchedOutput: string | null = null;\n- for (const outputPath of outputPaths) {\n- const normalizedOutput = outputPath.replace(/\\\\/g, '/');\n- if (\n- fileToCheck === normalizedOutput ||\n- fileToCheck.startsWith(normalizedOutput + '/')\n- ) {\n- matchedOutput = outputPath;\n- break;\n- }\n- }\n- if (!matchedOutput && expandedOutputs.includes(fileToCheck)) {\n- matchedOutput = fileToCheck;\n- }\n+ // Delegate the direct-match decision to the resolver (handles exact, prefix,\n+ // and glob matching via minimatch — supersedes the previous manual prefix\n+ // comparison + expandedOutputs exact-match approach).\n+ const matchedOutput = resolver.isOutput(taskId, fileToCheck);\n \n let containedOutputPaths: string[] = [];\n let containedExpandedOutputs: string[] = [];\ndiff --git a/packages/nx/src/devkit-exports.ts b/packages/nx/src/devkit-exports.ts\nindex 6a2038292ef1a..c939e18790161 100644\n--- a/packages/nx/src/devkit-exports.ts\n+++ b/packages/nx/src/devkit-exports.ts\n@@ -259,21 +259,3 @@ export { cacheDir } from './utils/cache-directory';\n export { createProjectFileMapUsingProjectGraph } from './project-graph/file-map-utils';\n \n export { isDaemonEnabled } from './daemon/client/client';\n-\n-/**\n- * @category Sandbox\n- */\n-export { HashPlanInspector } from './hasher/hash-plan-inspector';\n-\n-/**\n- * @category Sandbox\n- */\n-export type {\n- SandboxViolationInput,\n- SandboxViolationResult,\n-} from './hasher/verify-sandbox-violations';\n-\n-/**\n- * @category Sandbox\n- */\n-export { verifySandboxViolations } from './hasher/verify-sandbox-violations';\ndiff --git a/packages/nx/src/devkit-internals.ts b/packages/nx/src/devkit-internals.ts\nindex 402b7c1963a10..1967bcc4ff1c8 100644\n--- a/packages/nx/src/devkit-internals.ts\n+++ b/packages/nx/src/devkit-internals.ts\n@@ -47,3 +47,6 @@ export { globalSpinner } from './utils/spinner';\n export { signalToCode } from './utils/exit-codes';\n export { handleImport } from './utils/handle-import';\n export { PluginCache, safeWriteFileCache } from './utils/plugin-cache-utils';\n+export { HashPlanInspector } from './hasher/hash-plan-inspector';\n+export type { TaskFileResolver } from './hasher/task-file-resolver';\n+export { createTaskFileResolver } from './hasher/task-file-resolver';\ndiff --git a/packages/nx/src/hasher/task-file-resolver.spec.ts b/packages/nx/src/hasher/task-file-resolver.spec.ts\nnew file mode 100644\nindex 0000000000000..6273207b338de\n--- /dev/null\n+++ b/packages/nx/src/hasher/task-file-resolver.spec.ts\n@@ -0,0 +1,298 @@\n+import type { ProjectGraph } from '../config/project-graph';\n+import type { HashInputs } from '../native';\n+\n+// ── Mocks must be declared BEFORE imports that use them ─────────────────────\n+//\n+// jest.mock() calls are hoisted to the top of the file by Babel/SWC, which\n+// means any factory closure runs before module-level `const` declarations are\n+// initialised. The pattern below avoids referencing outer-scope variables\n+// inside the factory; instead we configure the mock in beforeEach so every\n+// test starts with a fresh set of spies.\n+\n+jest.mock('./hash-plan-inspector', () => ({\n+ HashPlanInspector: jest.fn(),\n+}));\n+\n+jest.mock('../tasks-runner/utils', () => ({\n+ getOutputsForTargetAndConfiguration: jest.fn(),\n+}));\n+\n+// ── Imports (after mocks) ────────────────────────────────────────────────────\n+\n+// eslint-disable-next-line import/order\n+import { HashPlanInspector } from './hash-plan-inspector';\n+// eslint-disable-next-line import/order\n+import { getOutputsForTargetAndConfiguration } from '../tasks-runner/utils';\n+// eslint-disable-next-line import/order\n+import { createTaskFileResolver } from './task-file-resolver';\n+\n+const MockHashPlanInspector = jest.mocked(HashPlanInspector);\n+const mockGetOutputs = jest.mocked(getOutputsForTargetAndConfiguration);\n+\n+// ── Per-test mock spies ──────────────────────────────────────────────────────\n+\n+let mockInit: jest.Mock;\n+let mockInspectTaskInputs: jest.Mock;\n+\n+// ── Helpers ──────────────────────────────────────────────────────────────────\n+\n+function buildGraph(): ProjectGraph {\n+ return {\n+ nodes: {\n+ myproj: {\n+ name: 'myproj',\n+ type: 'lib',\n+ data: {\n+ root: 'libs/myproj',\n+ targets: {\n+ build: {\n+ executor: '@nx/js:tsc',\n+ outputs: ['dist/libs/myproj'],\n+ },\n+ },\n+ },\n+ },\n+ },\n+ dependencies: { myproj: [] },\n+ } as unknown as ProjectGraph;\n+}\n+\n+function makeHashInputs(files: string[]): HashInputs {\n+ return {\n+ files,\n+ runtime: [],\n+ environment: [],\n+ depOutputs: [],\n+ external: [],\n+ };\n+}\n+\n+// ── Tests ────────────────────────────────────────────────────────────────────\n+\n+describe('createTaskFileResolver', () => {\n+ beforeEach(() => {\n+ jest.clearAllMocks();\n+\n+ // Rebuild per-test spies so callers can customise return values.\n+ mockInit = jest.fn().mockResolvedValue(undefined);\n+ mockInspectTaskInputs = jest.fn();\n+\n+ MockHashPlanInspector.mockImplementation(\n+ () =>\n+ ({\n+ init: mockInit,\n+ inspectTaskInputs: mockInspectTaskInputs,\n+ }) as unknown as HashPlanInspector\n+ );\n+\n+ // Default: no outputs\n+ mockGetOutputs.mockReturnValue([]);\n+ });\n+\n+ it('initialises the HashPlanInspector exactly once', async () => {\n+ const graph = buildGraph();\n+ mockInspectTaskInputs.mockReturnValue({\n+ 'myproj:build': makeHashInputs([]),\n+ });\n+\n+ const resolver = await createTaskFileResolver({ projectGraph: graph });\n+\n+ // Trigger multiple calls to exercise init-once guarantee\n+ resolver.getInputs('myproj:build');\n+ resolver.getInputs('myproj:build');\n+ resolver.getOutputs('myproj:build');\n+\n+ expect(MockHashPlanInspector).toHaveBeenCalledTimes(1);\n+ expect(mockInit).toHaveBeenCalledTimes(1);\n+ });\n+\n+ describe('getInputs', () => {\n+ it('returns the expanded file list from the inspector', async () => {\n+ const graph = buildGraph();\n+ mockInspectTaskInputs.mockReturnValue({\n+ 'myproj:build': makeHashInputs([\n+ 'libs/myproj/src/index.ts',\n+ 'libs/myproj/package.json',\n+ ]),\n+ });\n+\n+ const resolver = await createTaskFileResolver({ projectGraph: graph });\n+ const inputs = resolver.getInputs('myproj:build');\n+\n+ expect(inputs).toEqual([\n+ 'libs/myproj/src/index.ts',\n+ 'libs/myproj/package.json',\n+ ]);\n+ });\n+\n+ it('returns empty array when inspector finds no files', async () => {\n+ const graph = buildGraph();\n+ mockInspectTaskInputs.mockReturnValue({\n+ 'myproj:build': makeHashInputs([]),\n+ });\n+\n+ const resolver = await createTaskFileResolver({ projectGraph: graph });\n+ expect(resolver.getInputs('myproj:build')).toEqual([]);\n+ });\n+\n+ it('caches result — inspectTaskInputs called only once per taskId', async () => {\n+ const graph = buildGraph();\n+ mockInspectTaskInputs.mockReturnValue({\n+ 'myproj:build': makeHashInputs(['libs/myproj/src/index.ts']),\n+ });\n+\n+ const resolver = await createTaskFileResolver({ projectGraph: graph });\n+ resolver.getInputs('myproj:build');\n+ resolver.getInputs('myproj:build');\n+ resolver.getInputs('myproj:build');\n+\n+ expect(mockInspectTaskInputs).toHaveBeenCalledTimes(1);\n+ });\n+ });\n+\n+ describe('getOutputs', () => {\n+ it('returns the output patterns for the task', async () => {\n+ const graph = buildGraph();\n+ mockGetOutputs.mockReturnValue([\n+ 'dist/libs/myproj',\n+ 'dist/libs/myproj/**',\n+ ]);\n+\n+ const resolver = await createTaskFileResolver({ projectGraph: graph });\n+ const outputs = resolver.getOutputs('myproj:build');\n+\n+ expect(outputs).toEqual(['dist/libs/myproj', 'dist/libs/myproj/**']);\n+ });\n+\n+ it('returns empty array when node has no matching target', async () => {\n+ const graph = buildGraph();\n+\n+ const resolver = await createTaskFileResolver({ projectGraph: graph });\n+ // 'myproj:test' target does not exist in graph\n+ const outputs = resolver.getOutputs('myproj:test');\n+\n+ expect(outputs).toEqual([]);\n+ expect(mockGetOutputs).not.toHaveBeenCalled();\n+ });\n+\n+ it('caches result — getOutputsForTargetAndConfiguration called only once per taskId', async () => {\n+ const graph = buildGraph();\n+ mockGetOutputs.mockReturnValue(['dist/libs/myproj']);\n+\n+ const resolver = await createTaskFileResolver({ projectGraph: graph });\n+ resolver.getOutputs('myproj:build');\n+ resolver.getOutputs('myproj:build');\n+ resolver.getOutputs('myproj:build');\n+\n+ expect(mockGetOutputs).toHaveBeenCalledTimes(1);\n+ });\n+ });\n+\n+ describe('isInput', () => {\n+ it('returns true for a path in the input file list (exact match)', async () => {\n+ const graph = buildGraph();\n+ mockInspectTaskInputs.mockReturnValue({\n+ 'myproj:build': makeHashInputs(['libs/myproj/src/index.ts']),\n+ });\n+\n+ const resolver = await createTaskFileResolver({ projectGraph: graph });\n+ expect(resolver.isInput('myproj:build', 'libs/myproj/src/index.ts')).toBe(\n+ true\n+ );\n+ });\n+\n+ it('returns false for a path NOT in the input file list', async () => {\n+ const graph = buildGraph();\n+ mockInspectTaskInputs.mockReturnValue({\n+ 'myproj:build': makeHashInputs(['libs/myproj/src/index.ts']),\n+ });\n+\n+ const resolver = await createTaskFileResolver({ projectGraph: graph });\n+ expect(resolver.isInput('myproj:build', 'libs/other/src/index.ts')).toBe(\n+ false\n+ );\n+ });\n+ });\n+\n+ describe('isOutput', () => {\n+ it('returns true for an exact match against an output pattern', async () => {\n+ const graph = buildGraph();\n+ mockGetOutputs.mockReturnValue(['dist/libs/myproj/index.js']);\n+\n+ const resolver = await createTaskFileResolver({ projectGraph: graph });\n+ expect(\n+ resolver.isOutput('myproj:build', 'dist/libs/myproj/index.js')\n+ ).toBe(true);\n+ });\n+\n+ it('returns true when path is nested inside an output directory', async () => {\n+ const graph = buildGraph();\n+ mockGetOutputs.mockReturnValue(['dist/libs/myproj']);\n+\n+ const resolver = await createTaskFileResolver({ projectGraph: graph });\n+ expect(\n+ resolver.isOutput('myproj:build', 'dist/libs/myproj/deep/file.js')\n+ ).toBe(true);\n+ });\n+\n+ it('returns true for a glob pattern match (dist/**)', async () => {\n+ const graph = buildGraph();\n+ mockGetOutputs.mockReturnValue(['dist/**']);\n+\n+ const resolver = await createTaskFileResolver({ projectGraph: graph });\n+ expect(resolver.isOutput('myproj:build', 'dist/main.js')).toBe(true);\n+ expect(resolver.isOutput('myproj:build', 'dist/nested/chunk.js')).toBe(\n+ true\n+ );\n+ });\n+\n+ it('returns false for a path that does NOT match any output pattern', async () => {\n+ const graph = buildGraph();\n+ mockGetOutputs.mockReturnValue(['dist/**']);\n+\n+ const resolver = await createTaskFileResolver({ projectGraph: graph });\n+ expect(resolver.isOutput('myproj:build', 'other-dir/file.js')).toBe(\n+ false\n+ );\n+ });\n+ });\n+\n+ describe('caching across both getInputs and getOutputs', () => {\n+ it('does not call underlying APIs more than once per taskId even with mixed calls', async () => {\n+ const graph = buildGraph();\n+ mockInspectTaskInputs.mockReturnValue({\n+ 'myproj:build': makeHashInputs(['libs/myproj/src/index.ts']),\n+ });\n+ mockGetOutputs.mockReturnValue(['dist/libs/myproj']);\n+\n+ const resolver = await createTaskFileResolver({ projectGraph: graph });\n+\n+ // Interleaved calls for the same taskId\n+ resolver.getInputs('myproj:build');\n+ resolver.getOutputs('myproj:build');\n+ resolver.getInputs('myproj:build');\n+ resolver.getOutputs('myproj:build');\n+\n+ expect(mockInspectTaskInputs).toHaveBeenCalledTimes(1);\n+ expect(mockGetOutputs).toHaveBeenCalledTimes(1);\n+ });\n+ });\n+\n+ describe('parseTaskId validation', () => {\n+ it('throws on a taskId that has no colon (no target)', async () => {\n+ const graph = buildGraph();\n+ const resolver = await createTaskFileResolver({ projectGraph: graph });\n+\n+ expect(() => resolver.getInputs('justproject')).toThrow(\n+ /Invalid taskId \"justproject\"/\n+ );\n+ });\n+\n+ it('throws on an empty taskId string', async () => {\n+ const graph = buildGraph();\n+ const resolver = await createTaskFileResolver({ projectGraph: graph });\n+\n+ expect(() => resolver.getInputs('')).toThrow(/Invalid taskId \"\"/);\n+ });\n+ });\n+});\ndiff --git a/packages/nx/src/hasher/task-file-resolver.ts b/packages/nx/src/hasher/task-file-resolver.ts\nnew file mode 100644\nindex 0000000000000..f6e3b9ec4bc4f\n--- /dev/null\n+++ b/packages/nx/src/hasher/task-file-resolver.ts\n@@ -0,0 +1,131 @@\n+import { minimatch } from 'minimatch';\n+import type { NxJsonConfiguration } from '../config/nx-json';\n+import type { ProjectGraph } from '../config/project-graph';\n+import type { HashInputs } from '../native';\n+import { getOutputsForTargetAndConfiguration } from '../tasks-runner/utils';\n+import { splitByColons } from '../utils/split-target';\n+import { workspaceRoot as defaultWorkspaceRoot } from '../utils/workspace-root';\n+import { HashPlanInspector } from './hash-plan-inspector';\n+\n+export interface TaskFileResolver {\n+ /** Full hash plan entry (files + runtime + environment + depOutputs + external). */\n+ getRawInputs(taskId: string): HashInputs | null;\n+ getInputs(taskId: string): string[];\n+ getOutputs(taskId: string): string[];\n+ isInput(taskId: string, path: string): boolean;\n+ isOutput(taskId: string, path: string): boolean;\n+}\n+\n+export async function createTaskFileResolver(options: {\n+ projectGraph: ProjectGraph;\n+ nxJson?: NxJsonConfiguration;\n+ workspaceRoot?: string;\n+}): Promise {\n+ const workspaceRoot = options.workspaceRoot ?? defaultWorkspaceRoot;\n+ const inspector = new HashPlanInspector(\n+ options.projectGraph,\n+ workspaceRoot,\n+ options.nxJson\n+ );\n+ await inspector.init();\n+\n+ // Cache the full HashInputs (null = task not found). A single cache entry\n+ // serves both getRawInputs() and getInputs() so the inspector is never\n+ // called more than once per taskId.\n+ const hashInputsCache = new Map();\n+ const outputsCache = new Map();\n+\n+ function parseTaskId(taskId: string): {\n+ project: string;\n+ target: string;\n+ configuration?: string;\n+ } {\n+ const [project, target, configuration] = splitByColons(taskId);\n+ if (!project || !target) {\n+ throw new Error(\n+ `Invalid taskId \"${taskId}\" — expected \"project:target[:configuration]\"`\n+ );\n+ }\n+ return { project, target, configuration };\n+ }\n+\n+ function getRawInputs(taskId: string): HashInputs | null {\n+ if (hashInputsCache.has(taskId)) {\n+ return hashInputsCache.get(taskId) ?? null;\n+ }\n+\n+ const { project, target, configuration } = parseTaskId(taskId);\n+\n+ let planResult: Record = {};\n+ try {\n+ planResult = inspector.inspectTaskInputs({\n+ project,\n+ target,\n+ configuration,\n+ });\n+ } catch {\n+ // Project / target not found in graph — treat as no inputs.\n+ hashInputsCache.set(taskId, null);\n+ return null;\n+ }\n+\n+ // The result key is usually the same as taskId but may include a\n+ // defaultConfiguration suffix when none was explicitly given.\n+ let inputs: HashInputs | undefined = planResult[taskId];\n+ if (!inputs) {\n+ const prefix = `${project}:${target}`;\n+ for (const [key, val] of Object.entries(planResult)) {\n+ if (key === prefix || key.startsWith(prefix + ':')) {\n+ inputs = val;\n+ break;\n+ }\n+ }\n+ }\n+\n+ const result = inputs ?? null;\n+ hashInputsCache.set(taskId, result);\n+ return result;\n+ }\n+\n+ function getInputs(taskId: string): string[] {\n+ return getRawInputs(taskId)?.files ?? [];\n+ }\n+\n+ function getOutputs(taskId: string): string[] {\n+ const cached = outputsCache.get(taskId);\n+ if (cached !== undefined) return cached;\n+\n+ const { project, target, configuration } = parseTaskId(taskId);\n+ const node = options.projectGraph.nodes[project];\n+ const outputs = node?.data?.targets?.[target]\n+ ? getOutputsForTargetAndConfiguration(\n+ { project, target, configuration },\n+ {},\n+ node\n+ )\n+ : [];\n+\n+ outputsCache.set(taskId, outputs);\n+ return outputs;\n+ }\n+\n+ return {\n+ getRawInputs,\n+ getInputs,\n+ getOutputs,\n+ isInput(taskId: string, path: string): boolean {\n+ return getInputs(taskId).includes(path);\n+ },\n+ isOutput(taskId: string, path: string): boolean {\n+ const normalized = path.replace(/\\\\/g, '/');\n+ return getOutputs(taskId).some((pattern) => {\n+ const normalizedPattern = pattern.replace(/\\\\/g, '/');\n+ return (\n+ normalized === normalizedPattern ||\n+ normalized.startsWith(normalizedPattern + '/') ||\n+ minimatch(normalized, normalizedPattern, { dot: true })\n+ );\n+ });\n+ },\n+ };\n+}\ndiff --git a/packages/nx/src/hasher/verify-sandbox-violations.spec.ts b/packages/nx/src/hasher/verify-sandbox-violations.spec.ts\ndeleted file mode 100644\nindex e2131a2fc85a7..0000000000000\n--- a/packages/nx/src/hasher/verify-sandbox-violations.spec.ts\n+++ /dev/null\n@@ -1,379 +0,0 @@\n-import type { ProjectGraph } from '../config/project-graph';\n-import type { HashInputs } from '../native';\n-\n-// ── Mocks must be declared BEFORE imports that use them ─────────────────────\n-//\n-// jest.mock() calls are hoisted to the top of the file by Babel/SWC, which\n-// means any factory closure runs before module-level `const` declarations are\n-// initialised. The pattern below avoids referencing outer-scope variables\n-// inside the factory; instead we configure the mock in beforeEach so every\n-// test starts with a fresh set of spies.\n-\n-jest.mock('./hash-plan-inspector', () => ({\n- HashPlanInspector: jest.fn(),\n-}));\n-\n-jest.mock('../tasks-runner/utils', () => ({\n- getOutputsForTargetAndConfiguration: jest.fn(),\n-}));\n-\n-// ── Imports (after mocks) ────────────────────────────────────────────────────\n-\n-// eslint-disable-next-line import/order\n-import { HashPlanInspector } from './hash-plan-inspector';\n-// eslint-disable-next-line import/order\n-import { getOutputsForTargetAndConfiguration } from '../tasks-runner/utils';\n-// eslint-disable-next-line import/order\n-import { verifySandboxViolations } from './verify-sandbox-violations';\n-\n-const MockHashPlanInspector = jest.mocked(HashPlanInspector);\n-const mockGetOutputs = jest.mocked(getOutputsForTargetAndConfiguration);\n-\n-// ── Per-test mock spies ──────────────────────────────────────────────────────\n-\n-let mockInit: jest.Mock;\n-let mockInspectTaskInputs: jest.Mock;\n-\n-// ── Helpers ──────────────────────────────────────────────────────────────────\n-\n-function buildGraph(): ProjectGraph {\n- return {\n- nodes: {\n- myproj: {\n- name: 'myproj',\n- type: 'lib',\n- data: {\n- root: 'libs/myproj',\n- targets: {\n- build: {\n- executor: '@nx/js:tsc',\n- outputs: ['dist/libs/myproj'],\n- },\n- },\n- },\n- },\n- },\n- dependencies: { myproj: [] },\n- } as unknown as ProjectGraph;\n-}\n-\n-function makeHashInputs(files: string[]): HashInputs {\n- return {\n- files,\n- runtime: [],\n- environment: [],\n- depOutputs: [],\n- external: [],\n- };\n-}\n-\n-// ── Tests ────────────────────────────────────────────────────────────────────\n-\n-describe('verifySandboxViolations', () => {\n- beforeEach(() => {\n- jest.clearAllMocks();\n-\n- // Rebuild per-test spies so callers can customise return values.\n- mockInit = jest.fn().mockResolvedValue(undefined);\n- mockInspectTaskInputs = jest.fn();\n-\n- MockHashPlanInspector.mockImplementation(\n- () =>\n- ({\n- init: mockInit,\n- inspectTaskInputs: mockInspectTaskInputs,\n- }) as unknown as HashPlanInspector\n- );\n-\n- // Default: no outputs\n- mockGetOutputs.mockReturnValue([]);\n- });\n-\n- it('returns empty array for empty violations', async () => {\n- const result = await verifySandboxViolations([], {\n- projectGraph: buildGraph(),\n- });\n- expect(result).toEqual([]);\n- expect(MockHashPlanInspector).not.toHaveBeenCalled();\n- });\n-\n- describe('all-reconciled case', () => {\n- it('returns ok:true when every read and write is accounted for', async () => {\n- const graph = buildGraph();\n-\n- mockInspectTaskInputs.mockReturnValue({\n- 'myproj:build': makeHashInputs([\n- 'libs/myproj/src/index.ts',\n- 'libs/myproj/package.json',\n- ]),\n- });\n- mockGetOutputs.mockReturnValue(['dist/libs/myproj']);\n-\n- const [result] = await verifySandboxViolations(\n- [\n- {\n- taskId: 'myproj:build',\n- reads: ['libs/myproj/src/index.ts', 'libs/myproj/package.json'],\n- writes: ['dist/libs/myproj/index.js'],\n- },\n- ],\n- { projectGraph: graph }\n- );\n-\n- expect(result.ok).toBe(true);\n- expect(result.reads.reconciled).toEqual([\n- 'libs/myproj/src/index.ts',\n- 'libs/myproj/package.json',\n- ]);\n- expect(result.reads.stillUnexpected).toEqual([]);\n- expect(result.writes.reconciled).toEqual(['dist/libs/myproj/index.js']);\n- expect(result.writes.stillUnexpected).toEqual([]);\n- });\n- });\n-\n- describe('mixed case', () => {\n- it('splits paths into reconciled and stillUnexpected correctly', async () => {\n- const graph = buildGraph();\n-\n- mockInspectTaskInputs.mockReturnValue({\n- 'myproj:build': makeHashInputs(['libs/myproj/src/index.ts']),\n- });\n- mockGetOutputs.mockReturnValue(['dist/libs/myproj']);\n-\n- const [result] = await verifySandboxViolations(\n- [\n- {\n- taskId: 'myproj:build',\n- reads: ['libs/myproj/src/index.ts', 'some/secret/file.ts'],\n- writes: ['dist/libs/myproj/bundle.js', '/tmp/shadow-file'],\n- },\n- ],\n- { projectGraph: graph }\n- );\n-\n- expect(result.ok).toBe(false);\n- expect(result.reads.reconciled).toEqual(['libs/myproj/src/index.ts']);\n- expect(result.reads.stillUnexpected).toEqual(['some/secret/file.ts']);\n- expect(result.writes.reconciled).toEqual(['dist/libs/myproj/bundle.js']);\n- expect(result.writes.stillUnexpected).toEqual(['/tmp/shadow-file']);\n- });\n- });\n-\n- describe('all-still-unexpected case', () => {\n- it('returns ok:false when nothing is reconciled', async () => {\n- const graph = buildGraph();\n-\n- mockInspectTaskInputs.mockReturnValue({\n- 'myproj:build': makeHashInputs([]),\n- });\n- mockGetOutputs.mockReturnValue([]);\n-\n- const [result] = await verifySandboxViolations(\n- [\n- {\n- taskId: 'myproj:build',\n- reads: ['sneaky/read.ts'],\n- writes: ['sneaky/write.js'],\n- },\n- ],\n- { projectGraph: graph }\n- );\n-\n- expect(result.ok).toBe(false);\n- expect(result.reads.stillUnexpected).toEqual(['sneaky/read.ts']);\n- expect(result.writes.stillUnexpected).toEqual(['sneaky/write.js']);\n- expect(result.reads.reconciled).toEqual([]);\n- expect(result.writes.reconciled).toEqual([]);\n- });\n- });\n-\n- describe('glob output matching', () => {\n- it('reconciles a write that matches a glob output pattern', async () => {\n- const graph = buildGraph();\n-\n- mockInspectTaskInputs.mockReturnValue({\n- 'myproj:build': makeHashInputs([]),\n- });\n- // Output is a glob pattern\n- mockGetOutputs.mockReturnValue(['dist/**']);\n-\n- const [result] = await verifySandboxViolations(\n- [\n- {\n- taskId: 'myproj:build',\n- writes: ['dist/main.js', 'dist/nested/chunk.js'],\n- },\n- ],\n- { projectGraph: graph }\n- );\n-\n- expect(result.writes.reconciled).toEqual([\n- 'dist/main.js',\n- 'dist/nested/chunk.js',\n- ]);\n- expect(result.writes.stillUnexpected).toEqual([]);\n- expect(result.ok).toBe(true);\n- });\n-\n- it('does NOT reconcile a write that is outside the glob pattern', async () => {\n- const graph = buildGraph();\n-\n- mockInspectTaskInputs.mockReturnValue({\n- 'myproj:build': makeHashInputs([]),\n- });\n- mockGetOutputs.mockReturnValue(['dist/**']);\n-\n- const [result] = await verifySandboxViolations(\n- [\n- {\n- taskId: 'myproj:build',\n- writes: ['other-dir/file.js'],\n- },\n- ],\n- { projectGraph: graph }\n- );\n-\n- expect(result.writes.stillUnexpected).toEqual(['other-dir/file.js']);\n- expect(result.ok).toBe(false);\n- });\n- });\n-\n- describe('empty reads and writes', () => {\n- it('handles undefined reads and writes as empty arrays', async () => {\n- const graph = buildGraph();\n-\n- mockInspectTaskInputs.mockReturnValue({\n- 'myproj:build': makeHashInputs([]),\n- });\n-\n- const [result] = await verifySandboxViolations(\n- [{ taskId: 'myproj:build' }],\n- { projectGraph: graph }\n- );\n-\n- expect(result.reads.reconciled).toEqual([]);\n- expect(result.reads.stillUnexpected).toEqual([]);\n- expect(result.writes.reconciled).toEqual([]);\n- expect(result.writes.stillUnexpected).toEqual([]);\n- expect(result.ok).toBe(true);\n- });\n-\n- it('handles explicitly empty reads and writes arrays', async () => {\n- const graph = buildGraph();\n-\n- mockInspectTaskInputs.mockReturnValue({\n- 'myproj:build': makeHashInputs([]),\n- });\n-\n- const [result] = await verifySandboxViolations(\n- [{ taskId: 'myproj:build', reads: [], writes: [] }],\n- { projectGraph: graph }\n- );\n-\n- expect(result.reads.reconciled).toEqual([]);\n- expect(result.reads.stillUnexpected).toEqual([]);\n- expect(result.writes.reconciled).toEqual([]);\n- expect(result.writes.stillUnexpected).toEqual([]);\n- expect(result.ok).toBe(true);\n- });\n- });\n-\n- describe('deduplication of inspector calls', () => {\n- it('calls inspectTaskInputs only once for duplicate taskIds', async () => {\n- const graph = buildGraph();\n-\n- mockInspectTaskInputs.mockReturnValue({\n- 'myproj:build': makeHashInputs(['libs/myproj/src/index.ts']),\n- });\n- mockGetOutputs.mockReturnValue(['dist/libs/myproj']);\n-\n- await verifySandboxViolations(\n- [\n- {\n- taskId: 'myproj:build',\n- reads: ['libs/myproj/src/index.ts'],\n- },\n- {\n- taskId: 'myproj:build',\n- reads: ['libs/myproj/src/index.ts'],\n- writes: ['dist/libs/myproj/bundle.js'],\n- },\n- {\n- taskId: 'myproj:build',\n- writes: ['dist/libs/myproj/other.js'],\n- },\n- ],\n- { projectGraph: graph }\n- );\n-\n- // Three violations with the same taskId → inspector called only once\n- expect(mockInspectTaskInputs).toHaveBeenCalledTimes(1);\n- });\n-\n- it('builds the HashPlanInspector exactly once for the whole batch', async () => {\n- const graph = buildGraph();\n-\n- mockInspectTaskInputs.mockReturnValue({\n- 'myproj:build': makeHashInputs([]),\n- });\n-\n- await verifySandboxViolations(\n- [\n- { taskId: 'myproj:build' },\n- { taskId: 'myproj:build' },\n- { taskId: 'myproj:build' },\n- ],\n- { projectGraph: graph }\n- );\n-\n- expect(MockHashPlanInspector).toHaveBeenCalledTimes(1);\n- expect(mockInit).toHaveBeenCalledTimes(1);\n- });\n-\n- it('calls inspectTaskInputs once per unique taskId across multiple distinct tasks', async () => {\n- // Two-project graph\n- const graph = {\n- nodes: {\n- myproj: {\n- name: 'myproj',\n- type: 'lib',\n- data: {\n- root: 'libs/myproj',\n- targets: { build: { executor: '@nx/js:tsc' } },\n- },\n- },\n- otherproj: {\n- name: 'otherproj',\n- type: 'lib',\n- data: {\n- root: 'libs/otherproj',\n- targets: { build: { executor: '@nx/js:tsc' } },\n- },\n- },\n- },\n- dependencies: { myproj: [], otherproj: [] },\n- } as unknown as ProjectGraph;\n-\n- mockInspectTaskInputs\n- .mockReturnValueOnce({\n- 'myproj:build': makeHashInputs(['libs/myproj/src/index.ts']),\n- })\n- .mockReturnValueOnce({\n- 'otherproj:build': makeHashInputs(['libs/otherproj/src/index.ts']),\n- });\n-\n- await verifySandboxViolations(\n- [\n- { taskId: 'myproj:build', reads: ['libs/myproj/src/index.ts'] },\n- { taskId: 'otherproj:build', reads: ['libs/otherproj/src/index.ts'] },\n- // Duplicate — should NOT cause a third call\n- { taskId: 'myproj:build', reads: ['libs/myproj/src/index.ts'] },\n- ],\n- { projectGraph: graph }\n- );\n-\n- // Two unique taskIds → exactly two inspectTaskInputs calls\n- expect(mockInspectTaskInputs).toHaveBeenCalledTimes(2);\n- });\n- });\n-});\ndiff --git a/packages/nx/src/hasher/verify-sandbox-violations.ts b/packages/nx/src/hasher/verify-sandbox-violations.ts\ndeleted file mode 100644\nindex b2613f4647a07..0000000000000\n--- a/packages/nx/src/hasher/verify-sandbox-violations.ts\n+++ /dev/null\n@@ -1,227 +0,0 @@\n-import { minimatch } from 'minimatch';\n-import { NxJsonConfiguration } from '../config/nx-json';\n-import { ProjectGraph } from '../config/project-graph';\n-import { HashInputs } from '../native';\n-import { getOutputsForTargetAndConfiguration } from '../tasks-runner/utils';\n-import { splitTargetFromNodes } from '../utils/split-target';\n-import { workspaceRoot as defaultWorkspaceRoot } from '../utils/workspace-root';\n-import { HashPlanInspector } from './hash-plan-inspector';\n-\n-/**\n- * A single sandbox violation report produced by a prior task run.\n- * All paths must be workspace-relative POSIX paths (forward slashes, no\n- * leading slash). The verifier does not normalise paths — callers must ensure\n- * consistency with how Nx records file paths in its own data structures.\n- */\n-export interface SandboxViolationInput {\n- /** Full Nx task ID, e.g. `\"myproj:build\"` or `\"myproj:build:production\"`. */\n- taskId: string;\n- /** Workspace-relative POSIX paths that were read outside the sandbox. */\n- reads?: string[];\n- /** Workspace-relative POSIX paths that were written outside the sandbox. */\n- writes?: string[];\n-}\n-\n-/**\n- * The reconciliation result for a single sandbox violation.\n- */\n-export interface SandboxViolationResult {\n- /** The task ID from the original {@link SandboxViolationInput}. */\n- taskId: string;\n- reads: {\n- /** Paths that are legitimate declared inputs for this task. */\n- reconciled: string[];\n- /** Paths that are still not covered by any declared input. */\n- stillUnexpected: string[];\n- };\n- writes: {\n- /** Paths that are legitimate declared outputs for this task. */\n- reconciled: string[];\n- /** Paths that are still not covered by any declared output. */\n- stillUnexpected: string[];\n- };\n- /**\n- * `true` when every reported read and write is accounted for by the\n- * current workspace configuration.\n- */\n- ok: boolean;\n-}\n-\n-/**\n- * Verifies whether file paths reported as sandbox violations would be\n- * considered legitimate inputs or outputs in the **current** workspace\n- * configuration.\n- *\n- * ### Path format requirement\n- * All paths in {@link SandboxViolationInput.reads} and\n- * {@link SandboxViolationInput.writes} **must** be workspace-relative POSIX\n- * paths (forward slashes, no leading slash, e.g. `\"libs/myproj/src/main.ts\"`).\n- * The verifier performs no normalisation — callers are responsible for\n- * ensuring paths match the format Nx uses internally.\n- *\n- * ### Inputs reconciliation\n- * A read is reconciled when it appears in the fully-expanded `files` array\n- * returned by {@link HashPlanInspector.inspectTaskInputs} for the task.\n- * Matching is exact set-membership (no glob expansion needed because the\n- * inspector already expands all file patterns).\n- *\n- * ### Outputs reconciliation\n- * A write is reconciled when it matches at least one entry from the list\n- * returned by {@link getOutputsForTargetAndConfiguration}. Matching uses:\n- * 1. Exact path equality.\n- * 2. Prefix match — the write is inside an output directory.\n- * 3. Glob match via `minimatch` — handles patterns such as `dist/**`.\n- *\n- * @param violations - One entry per task whose sandbox was violated.\n- * @param options - Workspace context. The `projectGraph` must already be\n- * fully resolved. If `nxJson` is omitted it is read from disk using the\n- * provided (or default) `workspaceRoot`.\n- */\n-export async function verifySandboxViolations(\n- violations: SandboxViolationInput[],\n- options: {\n- projectGraph: ProjectGraph;\n- nxJson?: NxJsonConfiguration;\n- workspaceRoot?: string;\n- }\n-): Promise {\n- if (violations.length === 0) return [];\n-\n- const {\n- projectGraph,\n- nxJson,\n- workspaceRoot = defaultWorkspaceRoot,\n- } = options;\n-\n- // Build the inspector once for the whole batch and initialise it once.\n- const inspector = new HashPlanInspector(projectGraph, workspaceRoot, nxJson);\n- await inspector.init();\n-\n- // Cache inspector results keyed by violation taskId to deduplicate calls\n- // when multiple violations share the same task.\n- const inputsCache = new Map();\n-\n- function getCachedInputs(taskId: string): HashInputs | undefined {\n- if (inputsCache.has(taskId)) {\n- return inputsCache.get(taskId);\n- }\n-\n- const [project, target, configuration] = splitTargetFromNodes(\n- taskId,\n- projectGraph.nodes,\n- { silent: true }\n- );\n-\n- if (!project || !target) {\n- inputsCache.set(taskId, undefined);\n- return undefined;\n- }\n-\n- let result: Record = {};\n- try {\n- result = inspector.inspectTaskInputs({ project, target, configuration });\n- } catch {\n- // Project / target not found in graph — treat as no inputs.\n- }\n-\n- // The result key is usually the same as taskId but may include a\n- // defaultConfiguration suffix when none was explicitly given.\n- let hashInputs = result[taskId];\n- if (!hashInputs) {\n- // Fallback: find any key that starts with project:target\n- const prefix = `${project}:${target}`;\n- for (const [key, inputs] of Object.entries(result)) {\n- if (key === prefix || key.startsWith(prefix + ':')) {\n- hashInputs = inputs;\n- break;\n- }\n- }\n- }\n-\n- inputsCache.set(taskId, hashInputs);\n- return hashInputs;\n- }\n-\n- return violations.map((violation) => {\n- const { taskId, reads = [], writes = [] } = violation;\n-\n- // ── Inputs reconciliation ────────────────────────────────────────────────\n- const hashInputs = getCachedInputs(taskId);\n- const inputFileSet = new Set(hashInputs?.files ?? []);\n-\n- const reconciledReads: string[] = [];\n- const unexpectedReads: string[] = [];\n- for (const read of reads) {\n- if (inputFileSet.has(read)) {\n- reconciledReads.push(read);\n- } else {\n- unexpectedReads.push(read);\n- }\n- }\n-\n- // ── Outputs reconciliation ───────────────────────────────────────────────\n- const [project, target, configuration] = splitTargetFromNodes(\n- taskId,\n- projectGraph.nodes,\n- { silent: true }\n- );\n-\n- let outputPatterns: string[] = [];\n- if (project && target) {\n- const node = projectGraph.nodes[project];\n- if (node) {\n- outputPatterns = getOutputsForTargetAndConfiguration(\n- { project, target, configuration },\n- {},\n- node\n- );\n- }\n- }\n-\n- const reconciledWrites: string[] = [];\n- const unexpectedWrites: string[] = [];\n- for (const write of writes) {\n- if (matchesAnyOutput(write, outputPatterns)) {\n- reconciledWrites.push(write);\n- } else {\n- unexpectedWrites.push(write);\n- }\n- }\n-\n- const ok = unexpectedReads.length === 0 && unexpectedWrites.length === 0;\n-\n- return {\n- taskId,\n- reads: { reconciled: reconciledReads, stillUnexpected: unexpectedReads },\n- writes: {\n- reconciled: reconciledWrites,\n- stillUnexpected: unexpectedWrites,\n- },\n- ok,\n- };\n- });\n-}\n-\n-/**\n- * Returns `true` when `filePath` is covered by at least one entry in\n- * `outputPatterns`. Handles three cases:\n- *\n- * 1. **Exact match** — the path equals the pattern literally.\n- * 2. **Prefix match** — the path is nested inside a non-glob output directory.\n- * 3. **Glob match** — the pattern contains glob characters and `minimatch`\n- * confirms a match (e.g. `dist/**` covers `dist/main.js`).\n- */\n-function matchesAnyOutput(filePath: string, outputPatterns: string[]): boolean {\n- const normalized = filePath.replace(/\\\\/g, '/');\n- for (const pattern of outputPatterns) {\n- const normalizedPattern = pattern.replace(/\\\\/g, '/');\n- if (\n- normalized === normalizedPattern ||\n- normalized.startsWith(normalizedPattern + '/') ||\n- minimatch(normalized, normalizedPattern)\n- ) {\n- return true;\n- }\n- }\n- return false;\n-}\n\n```\n\n## Instructions\n\nRate how similar the commit is to the AI fix on a scale of 0-10.\n\n**Scoring Guide:**\n- 10: Nearly identical changes (same files, same logic, same fixes)\n- 8-9: Very similar (same core changes, minor differences in implementation)\n- 6-7: Similar intent (addresses same issue, somewhat different approach)\n- 4-5: Some overlap (touches same area, but different changes)\n- 2-3: Minimal similarity (different files or completely different changes)\n- 0-1: No similarity (unrelated changes)\n\n**Criteria:**\n- Focus on: same files modified, similar logic changes, same bug being fixed\n- The commit may have additional changes beyond the AI fix - that's okay\n- Small differences in implementation are okay if the intent is the same\n\nProvide your score (0-10) and a brief reasoning (2-3 sentences) explaining your assessment.","response":"{\"score\":3,\"reasoning\":\"The AI fix specifically targets removing `// eslint-disable-next-line import/order` comments from the `task-file-resolver.spec.ts` file. The actual commit does include this file and removes those exact comments (lines 22, 24, 26 in the diff show the three comment removals). However, the commit is vastly larger in scope, involving significant refactoring of multiple files (inputs.ts, outputs.ts, devkit-exports.ts, devkit-internals.ts) and the creation of a new task-file-resolver.ts implementation. While the core fix (removing the eslint comments) is present and correct, it represents only a tiny fraction of the overall commit changes, which go far beyond the stated AI suggestion.\"}","model":"claude-haiku-4-5-20251001","cipeFixId":"69fbb3f41b5ab4e8421f3aa8","headSha":"8378d0eec36dfeb140466280ba2947f611f9fed3","timestamp":1778104359673}